ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem isRat_rpow_pos {a b : ℝ} {nb : ℕ}
    {num : ℤ} {den : ℕ}
    (pb : IsNat b nb) (pe' : IsRat (a ^ nb) num den) :
    IsRat (a ^ b) num den
-- Mathlib/Topology/Sober.lean
protected theorem isClosed (h : IsGenericPoint x S) : IsClosed S
-- Mathlib/RingTheory/Coalgebra/Equiv.lean
@[simp]
theorem trans_toCoalgHom :
    (e₁₂.trans e₂₃ : A →ₗc[R] C) = e₂₃.comp e₁₂
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
theorem wellFoundedOn_insert : WellFoundedOn (insert a s) r ↔ WellFoundedOn s r
-- Mathlib/RingTheory/LaurentSeries.lean
theorem coe_num_denom : (f : LaurentSeries F) = f.num / f.denom
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[simp] theorem endofunctorMonoidalCategory_tensorObj_map (F G : C ⥤ C) {X Y : C} (f : X ⟶ Y) :
    (F ⊗ G).map f = G.map (F.map f)
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem tendsto_setIntegral_of_antitone {ι : Type*} [Countable ι] [SemilatticeSup ι]
    {s : ι → Set X} (hsm : ∀ i, MeasurableSet (s i)) (h_anti : Antitone s)
    (hfi : ∃ i, IntegrableOn f (s i) μ) :
    Tendsto (fun i ↦ ∫ x in s i, f x ∂μ) atTop (𝓝 (∫ x in ⋂ n, s n, f x ∂μ))
-- Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean
theorem isLittleO_log_rpow_rpow_atTop {s : ℝ} (r : ℝ) (hs : 0 < s) :
    (fun x => log x ^ r) =o[atTop] fun x => x ^ s
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNorm_mono_nnnorm {f : α → F} {g : α → G} (h : ∀ x, ‖f x‖₊ ≤ ‖g x‖₊) :
    eLpNorm f p μ ≤ eLpNorm g p μ
-- Mathlib/Topology/ShrinkingLemma.lean
protected theorem subset (v : PartialRefinement u s) (i : ι) : v i ⊆ u i
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma Set.Ici_ciSup [Nonempty ι] {f : ι → α} (hf : BddAbove (range f)) :
    Ici (⨆ i, f i) = ⋂ i, Ici (f i)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the angle between three points is `π`, the last two points are not equal. -/
theorem right_ne_of_oangle_eq_pi {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ = π) : p₃ ≠ p₂
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
@[simp]
lemma polyCharpoly_map_eq_charpoly (x : L) :
    (polyCharpoly φ b).map (MvPolynomial.eval (b.repr x)) = (φ x).charpoly
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioo_union_Icc_eq_Ioc (h₁ : a < b) (h₂ : b ≤ c) : Ioo a b ∪ Icc b c = Ioc a c
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
/-- `zeroLocus` and `vanishingIdeal` form a galois connection. -/
theorem gc_set :
    @GaloisConnection (Set A) (Set (ProjectiveSpectrum 𝒜))ᵒᵈ _ _
      (fun s => zeroLocus 𝒜 s) fun t => vanishingIdeal t
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@[reassoc (attr := simp)]
lemma stalkMap_germ' (U : Opens Y) (x : X) (hx : f.val.base x ∈ U) :
    Y.presheaf.germ ⟨f.val.base x, hx⟩ ≫ f.stalkMap x =
      f.val.c.app (op U) ≫ X.presheaf.germ (U := (Opens.map f.val.base).obj U) ⟨x, hx⟩
-- Mathlib/FieldTheory/IntermediateField.lean
@[simp]
theorem mem_subalgebraEquivIntermediateField_symm [Algebra.IsAlgebraic K L]
    {S : IntermediateField K L} {x : L} :
    x ∈ subalgebraEquivIntermediateField.symm S ↔ x ∈ S
-- Mathlib/AlgebraicGeometry/Spec.lean
/-- The counit morphism `R ⟶ Γ(Spec R)` given by `AlgebraicGeometry.StructureSheaf.toOpen`.  -/
@[simps!]
def toSpecΓ (R : CommRingCat.{u}) : R ⟶ Γ.obj (op (Spec.toLocallyRingedSpace.obj (op R)))
-- Mathlib/Data/ENNReal/Operations.lean
theorem mul_right_mono : Monotone (· * a)
-- Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean
theorem coe_apply (x : R_hat R K) (v : HeightOneSpectrum R) : (x : K_hat R K) v = ↑(x v)
-- Mathlib/Data/List/Rotate.lean
/-- If a `l : List α` is `Nodup l`, then all of its cyclic permutants are distinct. -/
protected theorem Nodup.cyclicPermutations {l : List α} (hn : Nodup l) :
    Nodup (cyclicPermutations l)
-- Mathlib/RingTheory/JacobsonIdeal.lean
theorem comap_jacobson {f : R →+* S} {K : Ideal S} :
    comap f K.jacobson = sInf (comap f '' { J : Ideal S | K ≤ J ∧ J.IsMaximal })
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
protected theorem HasDerivWithinAt.iterate {f : 𝕜 → 𝕜} {f' : 𝕜} (hf : HasDerivWithinAt f f' s x)
    (hx : f x = x) (hs : MapsTo f s s) (n : ℕ) : HasDerivWithinAt f^[n] (f' ^ n) s x
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem zpow_eq_one_iff_dvd (h : IsPrimitiveRoot ζ k) (l : ℤ) : ζ ^ l = 1 ↔ (k : ℤ) ∣ l
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp] lemma invert_apply (f : R[T;T⁻¹]) (n : ℤ) : invert f n = f (-n)
-- Mathlib/Data/Rat/Defs.lean
protected theorem add_mul : (a + b) * c = a * c + b * c
-- Mathlib/CategoryTheory/Closed/Cartesian.lean
@[reassoc]
theorem curry_natural_right (f : A ⨯ X ⟶ Y) (g : Y ⟶ Y') :
    curry (f ≫ g) = curry f ≫ (exp _).map g
-- Mathlib/NumberTheory/ClassNumber/Finite.lean
theorem prod_finsetApprox_ne_zero : algebraMap R S (∏ m ∈ finsetApprox bS adm, m) ≠ 0
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
/-- If a monoidal functor `F` is an equivalence of categories then its inverse is also monoidal. -/
@[simps]
noncomputable def monoidalInverse [F.IsEquivalence] :
    MonoidalFunctor D C
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem factorial_mul_pow_le_factorial : ∀ {m n : ℕ}, m ! * (m + 1) ^ n ≤ (m + n)!
-- Mathlib/CategoryTheory/Limits/ColimitLimit.lean
theorem map_id_left_eq_curry_map {j : J} {k k' : K} {f : k ⟶ k'} :
    F.map ((𝟙 j, f) : (j, k) ⟶ (j, k')) = ((curry.obj F).obj j).map f
-- Mathlib/SetTheory/Surreal/Multiplication.lean
lemma P2_neg_right : P2 x₁ x₂ y ↔ P2 x₁ x₂ (-y)
-- Mathlib/Algebra/Lie/OfAssociative.lean
theorem toLieHom_injective {f g : A →ₐ[R] B} (h : (f : A →ₗ⁅R⁆ B) = (g : A →ₗ⁅R⁆ B)) : f = g
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Instances.lean
lemma SpectrumRestricts.smul_of_nonneg {A : Type*} [Ring A] [Algebra ℝ A] {a : A}
    (ha : SpectrumRestricts a ContinuousMap.realToNNReal) {r : ℝ} (hr : 0 ≤ r) :
    SpectrumRestricts (r • a) ContinuousMap.realToNNReal
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive]
theorem eq_of_eqOn_dense {s : Set M} (hs : closure s = ⊤) {f g : M →ₙ* N} (h : s.EqOn f g) :
    f = g
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem norm_le_of_forall_sum_le (hp : 0 < p.toReal) {C : ℝ} (hC : 0 ≤ C) {f : lp E p}
    (hf : ∀ s : Finset α, ∑ i ∈ s, ‖f i‖ ^ p.toReal ≤ C ^ p.toReal) : ‖f‖ ≤ C
-- Mathlib/Order/Filter/CountableInter.lean
theorem EventuallyLE.countable_iInter [Countable ι] {s t : ι → Set α} (h : ∀ i, s i ≤ᶠ[l] t i) :
    ⋂ i, s i ≤ᶠ[l] ⋂ i, t i
-- .lake/packages/batteries/Batteries/Data/List/Pairwise.lean
theorem pairwise_iff_forall_sublist : l.Pairwise R ↔ (∀ {a b}, [a,b] <+ l → R a b)
-- Mathlib/Order/SupClosed.lean
@[simp] lemma infClosure_supClosure (s : Set α) : infClosure (supClosure s) = latticeClosure s
-- Mathlib/Analysis/CstarAlgebra/Matrix.lean
lemma l2_opNorm_conjTranspose_mul_self (A : Matrix m n 𝕜) : ‖Aᴴ * A‖ = ‖A‖ * ‖A‖
-- Mathlib/CategoryTheory/Category/GaloisConnection.lean
/-- An adjunction between preorder categories induces a galois connection.
-/
theorem Adjunction.gc {L : X ⥤ Y} {R : Y ⥤ X} (adj : L ⊣ R) : GaloisConnection L.obj R.obj
-- Mathlib/FieldTheory/Finite/Polynomial.lean
theorem eq_zero_of_eval_eq_zero [Finite σ] (p : MvPolynomial σ K) (h : ∀ v : σ → K, eval v p = 0)
    (hp : p ∈ restrictDegree σ K (Fintype.card K - 1)) : p = 0
-- Mathlib/Data/Nat/Factors.lean
@[simp]
theorem primeFactorsList_eq_nil (n : ℕ) : n.primeFactorsList = [] ↔ n = 0 ∨ n = 1
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem id : (id V).NormNoninc
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
lemma ciSup_neg {p : Prop} {f : p → α} (hp : ¬ p) :
    ⨆ (h : p), f h = sSup (∅ : Set α)
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
theorem χ₄_nat_eq_if_mod_four (n : ℕ) :
    χ₄ n = if n % 2 = 0 then 0 else if n % 4 = 1 then 1 else -1
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- The result of reflecting. -/
theorem reflection_apply (p : E) : reflection K p = 2 • (orthogonalProjection K p : E) - p
-- Mathlib/Computability/Reduce.lean
theorem OneOneEquiv.congr_left {α β γ} [Primcodable α] [Primcodable β] [Primcodable γ]
    {p : α → Prop} {q : β → Prop} {r : γ → Prop} (h : OneOneEquiv p q) :
    OneOneEquiv p r ↔ OneOneEquiv q r
-- Mathlib/Probability/Density.lean
/-- **The Law of the Unconscious Statistician**: Given a random variable `X` and a measurable
function `f`, `f ∘ X` is a random variable with expectation `∫ x, pdf X x • f x ∂μ`
where `μ` is a measure on the codomain of `X`. -/
theorem integral_pdf_smul [IsFiniteMeasure ℙ] {X : Ω → E} [HasPDF X ℙ μ] {f : E → F}
    (hf : AEStronglyMeasurable f μ) : ∫ x, (pdf X ℙ μ x).toReal • f x ∂μ = ∫ x, f (X x) ∂ℙ
-- Mathlib/Control/Functor/Multivariate.lean
theorem map_map (g : α ⟹ β) (h : β ⟹ γ) (x : F α) : h <$$> g <$$> x = (h ⊚ g) <$$> x
-- Mathlib/LinearAlgebra/CliffordAlgebra/Even.lean
@[simp, nolint simpNF] -- Added `nolint simpNF` to avoid a timeout #8386
theorem aux_one : aux f 1 = 1
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
@[simp]
lemma map₁_map₂ {F G : Cᵒᵖ ⥤ Type v} {η : F ⟶ A} {μ : G ⟶ A} (ε : F ⟶ G)
    (hε : ε ≫ μ = η) {X Y : C} {s : yoneda.obj X ⟶ A} {t : yoneda.obj Y ⟶ A} (f : X ⟶ Y)
    (hf : yoneda.map f ≫ t = s) (u : OverArrows η t) :
    (u.map₁ ε hε).map₂ f hf = (u.map₂ f hf).map₁ ε hε
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive sub_nsmul_neg]
theorem inv_pow_sub (a : G) {m n : ℕ} (h : n ≤ m) : a⁻¹ ^ (m - n) = (a ^ m)⁻¹ * a ^ n
-- Mathlib/Data/QPF/Multivariate/Basic.lean
theorem has_good_supp_iff {α : TypeVec n} (x : F α) :
    (∀ p, LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u) ↔
      ∃ a f, abs ⟨a, f⟩ = x ∧ ∀ i a' f', abs ⟨a', f'⟩ = x → f i '' univ ⊆ f' i '' univ
-- Mathlib/Data/Finset/Sym.lean
@[simp]
theorem sym_eq_empty : s.sym n = ∅ ↔ n ≠ 0 ∧ s = ∅
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive addMeasure_map_restrict_apply]
lemma measure_map_restrict_apply (s : Set α) {U : Set (Quotient α_mod_G)}
    (meas_U : MeasurableSet U) :
    (μ.restrict s).map π U = μ ((π ⁻¹' U) ∩ s)
-- Mathlib/MeasureTheory/Measure/WithDensityFinite.lean
@[simp]
lemma toFinite_zero : Measure.toFinite (0 : Measure α) = 0
-- Mathlib/Dynamics/PeriodicPts.lean
protected theorem sub (hm : IsPeriodicPt f m x) (hn : IsPeriodicPt f n x) :
    IsPeriodicPt f (m - n) x
-- Mathlib/Analysis/Convex/Function.lean
/-- A convex function on a segment is upper-bounded by the max of its endpoints. -/
theorem ConvexOn.le_on_segment' (hf : ConvexOn 𝕜 s f) {x y : E} (hx : x ∈ s) (hy : y ∈ s) {a b : 𝕜}
    (ha : 0 ≤ a) (hb : 0 ≤ b) (hab : a + b = 1) : f (a • x + b • y) ≤ max (f x) (f y)
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem isAdjointPair_unique_of_nondegenerate (B : BilinForm R₁ M₁) (b : B.Nondegenerate)
    (φ ψ₁ ψ₂ : M₁ →ₗ[R₁] M₁) (hψ₁ : IsAdjointPair B B ψ₁ φ) (hψ₂ : IsAdjointPair B B ψ₂ φ) :
    ψ₁ = ψ₂
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma eq_div_of_mul_eq (hc : c ≠ 0) : a * c = b → a = b / c
-- Mathlib/Data/DFinsupp/Order.lean
theorem le_iff' (hf : f.support ⊆ s) : f ≤ g ↔ ∀ i ∈ s, f i ≤ g i
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem Nat.le_of_succ_le_succ {n m : Nat} : LE.le (succ n) (succ m) → LE.le n m
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem isBounded_image2 (f : α → β → γ) {K₁ K₂ : ℝ≥0} {s : Set α} {t : Set β}
    (hs : Bornology.IsBounded s) (ht : Bornology.IsBounded t)
    (hf₁ : ∀ b ∈ t, LipschitzOnWith K₁ (fun a => f a b) s)
    (hf₂ : ∀ a ∈ s, LipschitzOnWith K₂ (f a) t) : Bornology.IsBounded (Set.image2 f s t)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem disjoint_atBot_principal_Ioi [Preorder α] (x : α) : Disjoint atBot (𝓟 (Ioi x))
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp, mfld_simps]
theorem coe_transDiffeomorph_symm : ⇑(I.transDiffeomorph e).symm = I.symm ∘ e.symm
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem injective_codRestrict (f : F) (S : NonUnitalSubalgebra R B) (hf : ∀ x : A, f x ∈ S) :
    Function.Injective (NonUnitalAlgHom.codRestrict f S hf) ↔ Function.Injective f
-- Mathlib/Data/List/Zip.lean
@[simp]
theorem getElem_zip {l : List α} {l' : List β} {i : Nat} {h : i < (zip l l').length} :
    (zip l l')[i] =
      (l[i]'(lt_length_left_of_zip h), l'[i]'(lt_length_right_of_zip h))
-- Mathlib/ModelTheory/Graph.lean
theorem Theory.simpleGraph_isSatisfiable : Theory.IsSatisfiable Theory.simpleGraph
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
theorem inversion_vsub_center (c : P) (R : ℝ) (x : P) :
    inversion c R x -ᵥ c = (R / dist x c) ^ 2 • (x -ᵥ c)
-- Mathlib/Data/Set/Subsingleton.lean
theorem subsingleton_of_subset_singleton (h : s ⊆ {a}) : s.Subsingleton
-- Mathlib/Data/Finset/Basic.lean
/-- Useful in proofs by induction. -/
theorem forall_of_forall_cons {p : α → Prop} {h : a ∉ s} (H : ∀ x, x ∈ cons a s h → p x) (x)
    (h : x ∈ s) : p x
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem norm_condexpInd_le : ‖(condexpInd G hm μ s : G →L[ℝ] α →₁[μ] G)‖ ≤ (μ s).toReal
-- Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean
/-- The preimage under the projection from the tangent bundle of a set with unique differential in
the basis also has unique differential. -/
theorem UniqueMDiffOn.tangentBundle_proj_preimage (hs : UniqueMDiffOn I s) :
    UniqueMDiffOn I.tangent (π E (TangentSpace I) ⁻¹' s)
-- Mathlib/Order/ModularLattice.lean
theorem disjoint_sup_left_of_disjoint_sup_right [Lattice α] [OrderBot α]
    [IsModularLattice α] (h : Disjoint b c) (hsup : Disjoint a (b ⊔ c)) :
    Disjoint (a ⊔ b) c
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem mk_preimage_prod_right (ha : a ∈ s) : Prod.mk a ⁻¹' s ×ˢ t = t
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toList_eq_singleton_iff {a : α} {s : Finset α} : s.toList = [a] ↔ s = {a}
-- Mathlib/Algebra/Category/ModuleCat/Limits.lean
/-- If `J` is `u`-small, the category of `R`-modules has limits of shape `J`. -/
lemma hasLimitsOfShape [Small.{w} J] : HasLimitsOfShape J (ModuleCat.{w} R)
-- Mathlib/Analysis/Convex/StrictConvexSpace.lean
/-- In a strictly convex space, if `x` and `y` are not in the same ray, then `‖x + y‖ < ‖x‖ + ‖y‖`.
-/
theorem norm_add_lt_of_not_sameRay (h : ¬SameRay ℝ x y) : ‖x + y‖ < ‖x‖ + ‖y‖
-- Mathlib/RingTheory/Polynomial/Vieta.lean
theorem MvPolynomial.prod_X_add_C_coeff (k : ℕ) (h : k ≤ card σ) :
    (∏ i : σ, (Polynomial.X + Polynomial.C (MvPolynomial.X i)) : Polynomial _).coeff k =
    MvPolynomial.esymm σ R (card σ - k)
-- Mathlib/Geometry/Manifold/Algebra/SmoothFunctions.lean
@[simp]
theorem smul_comp {V : Type*} [NormedAddCommGroup V] [NormedSpace 𝕜 V] (r : 𝕜)
    (g : C^∞⟮I'', N'; 𝓘(𝕜, V), V⟯) (h : C^∞⟮I, N; I'', N'⟯) : (r • g).comp h = r • g.comp h
-- Mathlib/Analysis/Normed/Group/Hom.lean
protected theorem uniformContinuous (f : NormedAddGroupHom V₁ V₂) : UniformContinuous f
-- Mathlib/Probability/Independence/Kernel.lean
theorem iIndep.iIndepSets {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} {m : ι → MeasurableSpace Ω}
    {s : ι → Set (Set Ω)} (hms : ∀ n, m n = generateFrom (s n)) (h_indep : iIndep m κ μ) :
    iIndepSets s κ μ
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem lift_root (h : IsAdjoinRoot S f) : h.lift i x hx h.root = x
-- Mathlib/Algebra/Ring/Equiv.lean
protected theorem map_sub : f (x - y) = f x - f y
-- Mathlib/Data/Fintype/Basic.lean
/-- Note: this lemma is specifically about `Fintype.ofIsEmpty`. For a statement about
arbitrary `Fintype` instances, use `Finset.univ_eq_empty`. -/
theorem univ_ofIsEmpty [IsEmpty α] : @univ α Fintype.ofIsEmpty = ∅
-- Mathlib/MeasureTheory/Function/Jacobian.lean
/-- If a function is differentiable and injective on a measurable set `s`, then its restriction
to `s` is a measurable embedding. -/
theorem measurableEmbedding_of_fderivWithin (hs : MeasurableSet s)
    (hf' : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hf : InjOn f s) :
    MeasurableEmbedding (s.restrict f)
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem principal_add_iff_add_left_eq_self {o : Ordinal} :
    Principal (· + ·) o ↔ ∀ a < o, a + o = o
-- Mathlib/RingTheory/PiTensorProduct.lean
lemma mul_def (x y : ⨂[R] i, A i) : x * y = mul x y
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- If we have `IsCofiltered C`, then for any functor `F : J ⥤ C` with `FinCategory J`,
there exists a cone over `F`.
-/
theorem cone_nonempty (F : J ⥤ C) : Nonempty (Cone F)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem toSignedMeasure_eq_toSignedMeasure_iff {μ ν : Measure α} [IsFiniteMeasure μ]
    [IsFiniteMeasure ν] : μ.toSignedMeasure = ν.toSignedMeasure ↔ μ = ν
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_comp (f : InfHom β γ) (g : InfHom α β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean
lemma oddKernel_zero (x : ℝ) : oddKernel 0 x = 0
-- Mathlib/Algebra/Module/FinitePresentation.lean
lemma Module.Finite.exists_smul_of_comp_eq_of_isLocalizedModule
    [hM : Module.Finite R M] (g₁ g₂ : M →ₗ[R] N) (h : f.comp g₁ = f.comp g₂) :
    ∃ (s : S), s • g₁ = s • g₂
-- Mathlib/Analysis/Complex/Isometry.lean
@[simp]
theorem rotation_apply (a : circle) (z : ℂ) : rotation a z = a * z
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem mem_pure : b ∈ pure a ↔ b = a
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- If `n` has only one element, the determinant of an `n` by `n` matrix is just that element.
Although `Unique` implies `DecidableEq` and `Fintype`, the instances might
not be syntactically equal. Thus, we need to fill in the args explicitly. -/
@[simp]
theorem det_unique {n : Type*} [Unique n] [DecidableEq n] [Fintype n] (A : Matrix n n R) :
    det A = A default default
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
theorem of_inter_eq_of_symmDiff_eq_zero_negative (hu : MeasurableSet u) (hv : MeasurableSet v)
    (hw : MeasurableSet w) (hsu : s ≤[u] 0) (hsv : s ≤[v] 0) (hs : s (u ∆ v) = 0) :
    s (w ∩ u) = s (w ∩ v)
-- Mathlib/Order/Filter/AtTopBot.lean
/-- A function `f` maps upwards closed sets (atTop sets) to upwards closed sets when it is a
Galois insertion. The Galois "insertion" and "connection" is weakened to only require it to be an
insertion and a connection above `b'`. -/
theorem map_atTop_eq_of_gc [SemilatticeSup α] [SemilatticeSup β] {f : α → β} (g : β → α) (b' : β)
    (hf : Monotone f) (gc : ∀ a, ∀ b ≥ b', f a ≤ b ↔ a ≤ g b) (hgi : ∀ b ≥ b', b ≤ f (g b)) :
    map f atTop = atTop
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Nat.succ.inj {m n : Nat} : m.succ = n.succ → m = n
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- The composition of an orthogonal family of subspaces with an injective function is also an
orthogonal family. -/
theorem OrthogonalFamily.comp {γ : Type*} {f : γ → ι} (hf : Function.Injective f) :
    OrthogonalFamily 𝕜 (fun g => G (f g)) fun g => V (f g)
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem colimit.post_desc (c : Cocone F) :
    colimit.post F G ≫ G.map (colimit.desc F c) = colimit.desc (F ⋙ G) (G.mapCocone c)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
lemma cons_getVert {u v w n} (p : G.Walk v w) (h : G.Adj u v) (hn : n ≠ 0) :
    (p.cons h).getVert n = p.getVert (n - 1)
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem _root_.LE.le.isOpenPosMeasure (h : μ ≤ ν) : IsOpenPosMeasure ν
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem units_inv_apply_apply (f : CircleDeg1Liftˣ) (x : ℝ) :
    (f⁻¹ : CircleDeg1Liftˣ) (f x) = x
-- Mathlib/Data/Set/Card.lean
theorem Finite.encard_lt_top (h : s.Finite) : s.encard < ⊤
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem replicate_inj : replicate n a = replicate m b ↔ n = m ∧ (n = 0 ∨ a = b)
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem equiv_symm_snd (x : α × β) : ((WithLp.equiv p (α × β)).symm x).snd = x.snd
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem monic_zero_iff_subsingleton' :
    Monic (0 : R[X]) ↔ (∀ f g : R[X], f = g) ∧ ∀ a b : R, a = b
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem Sublist.erase (a : α) {l₁ l₂ : List α} (h : l₁ <+ l₂) : l₁.erase a <+ l₂.erase a
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iio_subset_Iio_union_Ico : Iio b ⊆ Iio a ∪ Ico a b
-- Mathlib/GroupTheory/Sylow.lean
theorem Sylow.smul_eq_of_normal {g : G} {P : Sylow p G} [h : (P : Subgroup G).Normal] :
    g • P = P
-- Mathlib/RingTheory/TensorProduct/Basic.lean
protected theorem one_mul (x : A ⊗[R] B) : mul (1 ⊗ₜ 1) x = x
-- Mathlib/Topology/VectorBundle/Constructions.lean
@[simp]
theorem coordChangeL_prod [e₁.IsLinear 𝕜] [e₁'.IsLinear 𝕜] [e₂.IsLinear 𝕜] [e₂'.IsLinear 𝕜] ⦃b⦄
    (hb : b ∈ (e₁.prod e₂).baseSet ∩ (e₁'.prod e₂').baseSet) :
    ((e₁.prod e₂).coordChangeL 𝕜 (e₁'.prod e₂') b : F₁ × F₂ →L[𝕜] F₁ × F₂) =
      (e₁.coordChangeL 𝕜 e₁' b : F₁ →L[𝕜] F₁).prodMap (e₂.coordChangeL 𝕜 e₂' b)
-- Mathlib/CategoryTheory/Monad/Adjunction.lean
lemma isIso_counit_of_iso (adj : L ⊣ R) (j : R ⋙ L ≅ 𝟭 D) : IsIso adj.counit
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma zpow_eq_zero_iff {n : ℤ} (hn : n ≠ 0) : a ^ n = 0 ↔ a = 0
-- Mathlib/Data/Matrix/Basic.lean
/-- The `AddEquiv` between spaces of matrices induced by an `AddEquiv` between their
coefficients. This is `Matrix.map` as an `AddEquiv`. -/
@[simps apply]
def mapMatrix (f : α ≃+ β) : Matrix m n α ≃+ Matrix m n β
-- Mathlib/Data/Finsupp/Defs.lean
@[simp, norm_cast]
theorem coe_eq_zero {f : α →₀ M} : (f : α → M) = 0 ↔ f = 0
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem tendsto_ae (h : QuasiMeasurePreserving f μa μb) : Tendsto f (ae μa) (ae μb)
-- Mathlib/Algebra/Order/Group/Int.lean
@[simp, norm_cast] lemma natCast_natAbs (n : ℤ) : (n.natAbs : ℤ) = |n|
-- Mathlib/Analysis/Convolution.lean
theorem convolutionExistsAt_flip :
    ConvolutionExistsAt g f x L.flip μ ↔ ConvolutionExistsAt f g x L μ
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem insert_ae_eq_self (a : α) (s : Set α) : (insert a s : Set α) =ᵐ[μ] s
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem diam_thickening_le {α : Type*} [PseudoMetricSpace α] (s : Set α) (hε : 0 ≤ ε) :
    diam (thickening ε s) ≤ diam s + 2 * ε
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
@[simp] lemma map_negY : negY (W'.map f) (f ∘ P) = f (W'.negY P)
-- Mathlib/Order/Filter/Basic.lean
theorem eq_sInf_of_mem_iff_exists_mem {S : Set (Filter α)} {l : Filter α}
    (h : ∀ {s}, s ∈ l ↔ ∃ f ∈ S, s ∈ f) : l = sInf S
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
protected theorem prod_mk {m : MeasurableSpace α} [TopologicalSpace β] [TopologicalSpace γ]
    {f : α → β} {g : α → γ} (hf : StronglyMeasurable f) (hg : StronglyMeasurable g) :
    StronglyMeasurable fun x => (f x, g x)
-- Mathlib/Analysis/Complex/Basic.lean
/-- The slit plane includes the open unit ball of radius `1` around `1`. -/
lemma ball_one_subset_slitPlane : Metric.ball 1 1 ⊆ slitPlane
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_units_conj' (M : (Matrix m m R)ˣ) (N : Matrix m m R) :
    det ((↑M⁻¹ : Matrix _ _ _) * N * (↑M : Matrix _ _ _)) = det N
-- Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean
theorem disjoint_splitCenterBox (I : Box ι) {s t : Set ι} (h : s ≠ t) :
    Disjoint (I.splitCenterBox s : Set (ι → ℝ)) (I.splitCenterBox t)
-- Mathlib/Order/Defs.lean
theorem eq_or_lt_of_not_lt {a b : α} (h : ¬a < b) : a = b ∨ b < a
-- Mathlib/Algebra/Ring/Subring/Basic.lean
/-- Sum of a multiset of elements in a `Subring` of a `Ring` is
in the `Subring`. -/
protected theorem multiset_sum_mem {R} [Ring R] (s : Subring R) (m : Multiset R) :
    (∀ a ∈ m, a ∈ s) → m.sum ∈ s
-- Mathlib/Data/Nat/Factorial/SuperFactorial.lean
@[simp]
theorem superFactorial_zero : sf 0 = 1
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem get?_of_valid (cs cs' : List Char) : get? ⟨cs ++ cs'⟩ ⟨utf8Len cs⟩ = cs'.head?
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toNat_concat (x : BitVec w) (b : Bool) :
    (concat x b).toNat = x.toNat * 2 + b.toNat
-- Mathlib/Data/Matroid/Constructions.lean
theorem freeOn_restrict (h : R ⊆ E) : (freeOn E) ↾ R = freeOn R
-- Mathlib/Order/SupClosed.lean
@[simp] protected lemma LinearOrder.supClosed (s : Set α) : SupClosed s