ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem Ideal.pow_le_prime_iff {I P : Ideal R} [_hP : P.IsPrime] {n : ℕ} (hn : n ≠ 0) :
    I ^ n ≤ P ↔ I ≤ P
-- Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean
theorem remainder_pos {m : ℝ} (hm : 1 < m) (k : ℕ) : 0 < remainder m k
-- Mathlib/MeasureTheory/Function/Floor.lean
theorem measurable_fract [BorelSpace R] : Measurable (Int.fract : R → R)
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem mem_span_singleton' {x y : α} : x ∈ span ({y} : Set α) ↔ ∃ a, a * y = x
-- Mathlib/Order/Cover.lean
theorem mk_covBy_mk_iff_left : (a₁, b) ⋖ (a₂, b) ↔ a₁ ⋖ a₂
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsUpperSet.bot_mem (hs : IsUpperSet s) : ⊥ ∈ s ↔ s = univ
-- Mathlib/Topology/Order/Lattice.lean
lemma Continuous.finset_sup'_apply (hne : s.Nonempty) (hs : ∀ i ∈ s, Continuous (f i)) :
    Continuous (fun a ↦ s.sup' hne (f · a))
-- Mathlib/Algebra/Order/Group/Abs.lean
theorem sub_lt_of_abs_sub_lt_right (h : |a - b| < c) : a - c < b
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem uniqueMDiffOn_image (h : M ≃ₘ^n⟮I, J⟯ N) (hn : 1 ≤ n) {s : Set M} :
    UniqueMDiffOn J (h '' s) ↔ UniqueMDiffOn I s
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem smoothAt_coordChangeL {x : B} (h : x ∈ e.baseSet) (h' : x ∈ e'.baseSet) :
    SmoothAt IB 𝓘(𝕜, F →L[𝕜] F) (fun b : B => (e.coordChangeL 𝕜 e' b : F →L[𝕜] F)) x
-- Mathlib/Topology/LocallyClosed.lean
lemma IsOpenMap.coborder_preimage_subset (hf : IsOpenMap f) (s : Set Y) :
    coborder (f ⁻¹' s) ⊆ f ⁻¹' (coborder s)
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem lt_top_of_finrank_lt_finrank {s : Submodule R M} (lt : finrank R s < finrank R M) :
    s < ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem mul_self_sub_mul_self_eq (a b : Nat) : a * a - b * b = (a + b) * (a - b)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
/-- `sq` is the quadratic form mapping the vector `x : A` to `x * x` -/
@[simps!]
def sq : QuadraticMap R A A
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem functorPushforward_comp (R : Sieve X) :
    R.functorPushforward (F ⋙ G) = (R.functorPushforward F).functorPushforward G
-- Mathlib/Data/Int/Cast/Lemmas.lean
lemma _root_.Odd.intCast (hn : Odd n) : Odd (n : α)
-- Mathlib/Topology/Constructions.lean
theorem openEmbedding_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} (h : Injective f₁) :
    OpenEmbedding (Sigma.map f₁ f₂) ↔ ∀ i, OpenEmbedding (f₂ i)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem ContinuousInv.induced {α : Type*} {β : Type*} {F : Type*} [FunLike F α β] [Group α]
    [Group β] [MonoidHomClass F α β] [tβ : TopologicalSpace β] [ContinuousInv β] (f : F) :
    @ContinuousInv α (tβ.induced f) _
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
@[simp]
theorem two_nsmul_coe_pi : (2 : ℕ) • (π : Angle) = 0
-- Mathlib/Probability/ConditionalProbability.lean
/-- The axiomatic definition of conditional probability derived from a measure-theoretic one. -/
theorem cond_apply (hms : MeasurableSet s) (t : Set Ω) : μ[t|s] = (μ s)⁻¹ * μ (s ∩ t)
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
theorem list_succ_last (n) : list (n+1) = (list n).map castSucc ++ [last n]
-- Mathlib/Algebra/Polynomial/Lifts.lean
/-- A polynomial `p` lifts if and only if it is in the image of `mapAlg`. -/
theorem mem_lifts_iff_mem_alg (R : Type u) [CommSemiring R] {S : Type v} [Semiring S] [Algebra R S]
    (p : S[X]) : p ∈ lifts (algebraMap R S) ↔ p ∈ AlgHom.range (@mapAlg R _ S _ _)
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
@[fun_prop]
protected theorem differentiableWithinAt : DifferentiableWithinAt 𝕜 iso s x
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
@[simp] theorem or_eq (x y : BitVec w)                    : BitVec.or x y = x ||| y
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
theorem comp_lipschitzOnWith {Kf Kg : ℝ≥0} {f : β → γ} {g : α → β} {s : Set α}
    (hf : LipschitzWith Kf f) (hg : LipschitzOnWith Kg g s) : LipschitzOnWith (Kf * Kg) (f ∘ g) s
-- Mathlib/Algebra/Field/Basic.lean
@[simp]
theorem div_neg_self {a : K} (h : a ≠ 0) : a / -a = -1
-- Mathlib/Data/ENNReal/Basic.lean
@[simp, norm_cast]
theorem toNNReal_coe : (r : ℝ≥0∞).toNNReal = r
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
/-- Monotone convergence theorem for nonincreasing sequences of functions -/
theorem lintegral_iInf {f : ℕ → α → ℝ≥0∞} (h_meas : ∀ n, Measurable (f n)) (h_anti : Antitone f)
    (h_fin : ∫⁻ a, f 0 a ∂μ ≠ ∞) : ∫⁻ a, ⨅ n, f n a ∂μ = ⨅ n, ∫⁻ a, f n a ∂μ
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem ne_empty_of_mem (hs : s ∈ f) : s ≠ ∅
-- Mathlib/CategoryTheory/CommSq.lean
/-- Now we consider a square:
```
  A ---f---> X
  |          |
  i          p
  |          |
  v          v
  B ---g---> Y
```

The datum of a lift in a commutative square, i.e. an up-right-diagonal
morphism which makes both triangles commute. -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
@[ext]
structure LiftStruct (sq : CommSq f i p g) where
  /-- The lift. -/
  l : B ⟶ X
  /-- The upper left triangle commutes. -/
  fac_left : i ≫ l = f
  /-- The lower right triangle commutes. -/
  fac_right : l ≫ p = g
-- Mathlib/Algebra/Algebra/Hom/Rat.lean
/-- The equivalence between `RingHom` and `ℚ`-algebra homomorphisms. -/
@[simps]
def RingHom.equivRatAlgHom [Ring R] [Ring S] [Algebra ℚ R] [Algebra ℚ S] :
    (R →+* S) ≃ (R →ₐ[ℚ] S)
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem comp_refl (f : M ↪[L] N) : f.comp (refl L M) = f
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem curryFinFinset_symm_apply_const (hk : s.card = k) (hl : sᶜ.card = l)
    (f : G[×k]→L[𝕜] G[×l]→L[𝕜] G') (x : G) :
    ((curryFinFinset 𝕜 G G' hk hl).symm f fun _ => x) = f (fun _ => x) fun _ => x
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem pos_lt_eq (p₁ p₂ : Pos) : (p₁ < p₂) = (p₁.1 < p₂.1)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem eapprox_comp [MeasurableSpace γ] {f : γ → ℝ≥0∞} {g : α → γ} {n : ℕ} (hf : Measurable f)
    (hg : Measurable g) : (eapprox (f ∘ g) n : α → ℝ≥0∞) = (eapprox f n : γ →ₛ ℝ≥0∞) ∘ g
-- Mathlib/Data/Option/Basic.lean
theorem iget_of_mem [Inhabited α] {a : α} : ∀ {o : Option α}, a ∈ o → o.iget = a
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem toAddSubmonoid_sSup (s : Set (Submodule R M)) :
    (sSup s).toAddSubmonoid = sSup (toAddSubmonoid '' s)
-- Mathlib/Algebra/Homology/BifunctorHomotopy.lean
lemma zero₁ (j j' : J) (h : ¬ c.Rel j' j) :
    hom₁ h₁ f₂ F c j j' = 0
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
lemma of_openCover (H : ∀ i, P (𝒰.map i ≫ f)) : P f
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet_ge_of_countable {ι} [LinearOrder ι] {τ : Ω → ι} {f : Filtration ι m}
    [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) : MeasurableSet[f i] {ω | i ≤ τ ω}
-- Mathlib/Topology/Baire/Lemmas.lean
/-- Baire theorem: if countably many closed sets cover the whole space, then their interiors
are dense. Formulated here with `⋃₀`. -/
theorem dense_sUnion_interior_of_closed {S : Set (Set X)} (hc : ∀ s ∈ S, IsClosed s)
    (hS : S.Countable) (hU : ⋃₀ S = univ) : Dense (⋃ s ∈ S, interior s)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[simp]
theorem card_sigma {σ : α → Type*} (s : Finset α) (t : ∀ a, Finset (σ a)) :
    card (s.sigma t) = ∑ a ∈ s, card (t a)
-- Mathlib/Topology/Instances/Int.lean
@[norm_cast, simp]
theorem dist_cast_real (x y : ℤ) : dist (x : ℝ) y = dist x y
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem piecewise_empty [∀ i : α, Decidable (i ∈ (∅ : Set α))] : piecewise ∅ f g = g
-- Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean
/-- The generator of the annihilating ideal has minimal degree among
 the non-zero members of the annihilating ideal -/
theorem degree_annIdealGenerator_le_of_mem (a : A) (p : 𝕜[X]) (hp : p ∈ annIdeal 𝕜 a)
    (hpn0 : p ≠ 0) : degree (annIdealGenerator 𝕜 a) ≤ degree p
-- Mathlib/Order/Chain.lean
theorem ChainClosure.isChain (hc : ChainClosure r c) : IsChain r c
-- Mathlib/Topology/ShrinkingLemma.lean
theorem find_mem {c : Set (PartialRefinement u s)} (i : ι) (ne : c.Nonempty) : find c ne i ∈ c
-- Mathlib/NumberTheory/KummerDedekind.lean
theorem conductor_eq_top_of_powerBasis (pb : PowerBasis R S) : conductor R pb.gen = ⊤
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
@[to_additive]
nonrec theorem SmoothAt.inv {f : M → G} {x₀ : M} (hf : SmoothAt I' I f x₀) :
    SmoothAt I' I (fun x => (f x)⁻¹) x₀
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem norm_setIntegral_le_of_norm_le_const {C : ℝ} (hs : μ s < ∞) (hC : ∀ x ∈ s, ‖f x‖ ≤ C)
    (hfm : AEStronglyMeasurable f (μ.restrict s)) : ‖∫ x in s, f x ∂μ‖ ≤ C * (μ s).toReal
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem symm_symm (e : A₁ ≃ₐ[R] A₂) : e.symm.symm = e
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem all_eq (p : α → β → Bool) (l : AssocList α β) :
    all p l = l.toList.all fun (a, b) => p a b
-- Mathlib/Order/Basic.lean
theorem max_def' [LinearOrder α] (a b : α) : max a b = if b ≤ a then a else b
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem self_sub_toIocMod (a b : α) : b - toIocMod hp a b = toIocDiv hp a b • p
-- Mathlib/Data/Fintype/Card.lean
theorem of_surjective {α β} [Infinite β] (f : α → β) (hf : Surjective f) : Infinite α
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
@[measurability]
theorem measurableSet_interior : MeasurableSet (interior s)
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp]
protected theorem irrefl {v : V} : ¬G.Adj v v
-- Mathlib/NumberTheory/ZetaValues.lean
theorem periodizedBernoulli.continuous {k : ℕ} (hk : k ≠ 1) : Continuous (periodizedBernoulli k)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem characteristic_iff_le_comap : H.Characteristic ↔ ∀ ϕ : G ≃* G, H ≤ H.comap ϕ.toMonoidHom
-- Mathlib/RingTheory/IsAdjoinRoot.lean
/-- `repr` preserves addition, up to multiples of `f` -/
theorem repr_add_sub_repr_add_repr_mem_span (h : IsAdjoinRoot S f) (x y : S) :
    h.repr (x + y) - (h.repr x + h.repr y) ∈ Ideal.span ({f} : Set R[X])
-- Mathlib/Algebra/Polynomial/EraseLead.lean
@[simp]
theorem eraseLead_C_mul_X_pow (r : R) (n : ℕ) : eraseLead (C r * X ^ n) = 0
-- Mathlib/Order/Lattice.lean
@[simp, norm_cast]
theorem coe_sup [SemilatticeSup α] {P : α → Prop}
    (Psup : ∀ ⦃x y⦄, P x → P y → P (x ⊔ y)) (x y : Subtype P) :
    (haveI := Subtype.semilatticeSup Psup; (x ⊔ y : Subtype P) : α) = (x ⊔ y : α)
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- If we're boundaryless, `(extChartAt I x).target` is a neighborhood of the key point -/
theorem extChartAt_target_mem_nhds [I.Boundaryless] (x : M) :
    (extChartAt I x).target ∈ 𝓝 (extChartAt I x x)
-- Mathlib/Data/Bool/Basic.lean
theorem eq_false_of_not_eq_true' {a : Bool} : !a = true → a = false
-- Mathlib/Topology/Category/CompHaus/Limits.lean
@[reassoc (attr := simp)]
lemma pullback.lift_fst {Z : CompHaus.{u}} (a : Z ⟶ X) (b : Z ⟶ Y) (w : a ≫ f = b ≫ g) :
    pullback.lift f g a b w ≫ pullback.fst f g = a
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp]
theorem flip_apply (f : E →SL[σ₁₃] F →SL[σ₂₃] G) (x : E) (y : F) : f.flip y x = f x y
-- Mathlib/Order/Compare.lean
theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x'
-- Mathlib/Algebra/Polynomial/Monic.lean
@[simp]
theorem Monic.natDegree_map [Semiring S] [Nontrivial S] {P : R[X]} (hmo : P.Monic) (f : R →+* S) :
    (P.map f).natDegree = P.natDegree
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem natDegree_map_eq_of_injective (hf : Injective f) (p : R[X]) :
    natDegree (p.map f) = natDegree p
-- Mathlib/Data/Nat/Hyperoperation.lean
theorem hyperoperation_ge_four_zero (n k : ℕ) :
    hyperoperation (n + 4) 0 k = if Even k then 1 else 0
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem Memℒp.of_measure_le_smul {μ' : Measure α} (c : ℝ≥0∞) (hc : c ≠ ∞) (hμ'_le : μ' ≤ c • μ)
    {f : α → E} (hf : Memℒp f p μ) : Memℒp f p μ'
-- Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean
@[simp]
theorem withDensityᵥ_neg : μ.withDensityᵥ (-f) = -μ.withDensityᵥ f
-- Mathlib/Combinatorics/Quiver/Basic.lean
lemma mk_map {V W : Type*} [Quiver V] [Quiver W] {obj : V → W} {map} {X Y : V} {f : X ⟶ Y} :
    (Prefunctor.mk obj map).map f = map f
-- Mathlib/RingTheory/Ideal/Over.lean
theorem mem_of_one_mem (h : (1 : S) ∈ I) (x) : x ∈ I
-- Mathlib/Algebra/Tropical/BigOperators.lean
theorem trop_sInf_image [ConditionallyCompleteLinearOrder R] (s : Finset S) (f : S → WithTop R) :
    trop (sInf (f '' s)) = ∑ i ∈ s, trop (f i)
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma image_coe_Ici (x : ℝ) : Real.toEReal '' Ici x = Ico ↑x ⊤
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem iteratedFDeriv_zero_eq_comp :
    iteratedFDeriv 𝕜 0 f = (continuousMultilinearCurryFin0 𝕜 E F).symm ∘ f
-- Mathlib/Order/Heyting/Boundary.lean
@[simp]
theorem boundary_idem (a : α) : ∂ ∂ a = ∂ a
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[reassoc (attr := simp)]
lemma d₂_mapMap (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂) :
    K.d₂ c₁₂ i₁ i₂ i₁₂ ≫ GradedObject.mapMap (toGradedObjectMap φ) _ i₁₂ =
    (φ.f i₁).f i₂ ≫ L.d₂ c₁₂ i₁ i₂ i₁₂
-- Mathlib/RingTheory/RingHom/FiniteType.lean
theorem finiteType_stableUnderComposition : StableUnderComposition @FiniteType
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem bot_apply [∀ i, Bot (α' i)] (i : ι) : (⊥ : ∀ i, α' i) i = ⊥
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
/-- If `Irreducible (cyclotomic (p ^ (k + 1)) K)` (in particular for `K = ℚ`) and `p` is an odd
prime, then the norm of `zeta (p ^ (k + 1)) K L - 1` is `p`. -/
theorem norm_zeta_pow_sub_one_of_prime_ne_two {k : ℕ} [Fact (p : ℕ).Prime]
    [IsCyclotomicExtension {p ^ (k + 1)} K L]
    (hirr : Irreducible (cyclotomic (↑(p ^ (k + 1)) : ℕ) K)) (h : p ≠ 2) :
    norm K (zeta (p ^ (k + 1)) K L - 1) = p
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- The mean value theorem on a convex set: if the derivative of a function within this set is
bounded by `C`, then the function is `C`-Lipschitz. Version with `fderivWithin`. -/
theorem norm_image_sub_le_of_norm_fderivWithin_le (hf : DifferentiableOn 𝕜 f s)
    (bound : ∀ x ∈ s, ‖fderivWithin 𝕜 f s x‖ ≤ C) (hs : Convex ℝ s) (xs : x ∈ s) (ys : y ∈ s) :
    ‖f y - f x‖ ≤ C * ‖y - x‖
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- Express `nndist` in terms of `edist`-/
theorem nndist_edist (x y : α) : nndist x y = (edist x y).toNNReal
-- Mathlib/Logic/Basic.lean
lemma eq_false_intro {a : Prop} (h : ¬a) : a = False
-- Mathlib/CategoryTheory/Bicategory/Basic.lean
theorem whiskerRight_iff {f g : a ⟶ b} (η θ : f ⟶ g) : η ▷ 𝟙 b = θ ▷ 𝟙 b ↔ η = θ
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem map_comap_eq (f : A →ₐ[R] B) (S : Subalgebra R B) : (S.comap f).map f = S ⊓ f.range
-- Mathlib/Data/Rat/Defs.lean
protected theorem mul_add : a * (b + c) = a * b + a * c
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem hnot_eq_compl : ￢x = xᶜ
-- Mathlib/Topology/Bases.lean
protected theorem IsTopologicalBasis.secondCountableTopology {b : Set (Set α)}
    (hb : IsTopologicalBasis b) (hc : b.Countable) : SecondCountableTopology α
-- Mathlib/Analysis/Convex/Combination.lean
/-- The convex hull of `s` is equal to the set of centers of masses of finite families of points in
`s`.

For universe reasons, you shouldn't use this lemma to prove that a given center of mass belongs
to the convex hull. Use `mem_convexHull_of_exists_fintype` of the convex hull instead. -/
lemma mem_convexHull_iff_exists_fintype {s : Set E} {x : E} :
    x ∈ convexHull R s ↔ ∃ (ι : Type) (_ : Fintype ι) (w : ι → R) (z : ι → E), (∀ i, 0 ≤ w i) ∧
      ∑ i, w i = 1 ∧ (∀ i, z i ∈ s) ∧ ∑ i, w i • z i = x
-- Mathlib/Topology/Algebra/Module/WeakDual.lean
theorem coeFn_continuous : Continuous fun (x : WeakDual 𝕜 E) y => x y
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- Replacing the first point by one on the same line but the opposite ray adds π to the oriented
angle. -/
theorem _root_.Sbtw.oangle_eq_add_pi_left
    {p₁ p₁' p₂ p₃ : P} (h : Sbtw ℝ p₁ p₂ p₁') (hp₃p₂ : p₃ ≠ p₂) :
    ∡ p₁ p₂ p₃ = ∡ p₁' p₂ p₃ + π
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Equality case of the Rearrangement Inequality**: Pointwise multiplication of `f` and `g`,
which antivary together, is unchanged by a permutation if and only if `f ∘ σ` and `g` antivary
together. Stated by permuting the entries of `f`. -/
theorem Antivary.sum_comp_perm_mul_eq_sum_mul_iff (hfg : Antivary f g) :
    ∑ i, f (σ i) * g i = ∑ i, f i * g i ↔ Antivary (f ∘ σ) g
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_lt_mul_of_pos_left {a b c : Int}
  (h₁ : a < b) (h₂ : 0 < c) : c * a < c * b
-- Mathlib/GroupTheory/Index.lean
@[to_additive (attr := simp)]
theorem relindex_bot_left : (⊥ : Subgroup G).relindex H = Nat.card H
-- Mathlib/Logic/Equiv/Basic.lean
/-- An indexed sum of disjoint sums of types is equivalent to the sum of the indexed sums. -/
@[simps]
def sigmaSumDistrib (α β : ι → Type*) :
    (Σ i, α i ⊕ β i) ≃ (Σ i, α i) ⊕ (Σ i, β i)
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[fun_prop]
nonrec
theorem ContinuousAt.rexp (h : ContinuousAt f x) : ContinuousAt (fun y ↦ exp (f y)) x
-- Mathlib/LinearAlgebra/Vandermonde.lean
theorem eval_matrixOfPolynomials_eq_vandermonde_mul_matrixOfPolynomials {n : ℕ}
    (v : Fin n → R) (p : Fin n → R[X]) (h_deg : ∀ i, (p i).natDegree ≤ i) :
    Matrix.of (fun i j => ((p j).eval (v i))) =
    (Matrix.vandermonde v) * (Matrix.of (fun (i j : Fin n) => (p j).coeff i))
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is purely inseparable, then the separable closure of `F` in `E` is
equal to `F`. -/
theorem separableClosure.eq_bot_of_isPurelyInseparable [IsPurelyInseparable F E] :
    separableClosure F E = ⊥
-- Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean
theorem iteratedDeriv_const_mul {n : ℕ} {f : 𝕜 → 𝕜} (h : ContDiff 𝕜 n f) (c : 𝕜) :
    iteratedDeriv n (fun x => f (c * x)) = fun x => c ^ n * iteratedDeriv n f (c * x)
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
/-- An extensionality lemma in terms of the coercion to a pi-type.
We prove this explicitly rather than deriving it so that it is in terms of the coercion rather than
the projection `.sieves`.
-/
@[ext]
theorem ext {J₁ J₂ : GrothendieckTopology C} (h : (J₁ : ∀ X : C, Set (Sieve X)) = J₂) :
    J₁ = J₂
-- Mathlib/Data/Nat/Defs.lean
protected lemma pow_right_injective (ha : 2 ≤ a) : Injective (a ^ ·)
-- Mathlib/Data/Matroid/Dual.lean
theorem Coindep.indep (hX : M.Coindep X) : M✶.Indep X
-- Mathlib/InformationTheory/Hamming.lean
/-- Corresponds to `dist_comm`. -/
theorem hammingDist_comm (x y : ∀ i, β i) : hammingDist x y = hammingDist y x
-- Mathlib/MeasureTheory/Measure/Portmanteau.lean
/-- One pair of implications of the portmanteau theorem:
For a sequence of Borel probability measures, the following two are equivalent:

(C) The limsup of the measures of any closed set is at most the measure of the closed set
under a candidate limit measure.

(O) The liminf of the measures of any open set is at least the measure of the open set
under a candidate limit measure.
-/
theorem limsup_measure_closed_le_iff_liminf_measure_open_ge {ι : Type*} {L : Filter ι}
    {μ : Measure Ω} {μs : ι → Measure Ω} [IsProbabilityMeasure μ]
    [∀ i, IsProbabilityMeasure (μs i)] :
    (∀ F, IsClosed F → (L.limsup fun i => μs i F) ≤ μ F) ↔
      ∀ G, IsOpen G → μ G ≤ L.liminf fun i => μs i G
-- Mathlib/RingTheory/PiTensorProduct.lean
/-- To show two algebra morphisms from finite tensor products are equal, it suffices to show that
they agree on elements of the form $1 ⊗ ⋯ ⊗ a ⊗ 1 ⊗ ⋯$. -/
@[ext high]
theorem algHom_ext {S : Type*} [Finite ι] [DecidableEq ι] [Semiring S] [Algebra R S]
    ⦃f g : (⨂[R] i, A i) →ₐ[R] S⦄ (h : ∀ i, f.comp (singleAlgHom i) = g.comp (singleAlgHom i)) :
    f = g
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
lemma isFiniteMeasure {l u : ℝ} (hfl : Tendsto f atBot (𝓝 l)) (hfu : Tendsto f atTop (𝓝 u)) :
    IsFiniteMeasure f.measure
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isUnit_iff_dvd_one {x : α} : IsUnit x ↔ x ∣ 1
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocMod_add_zsmul' (a b : α) (m : ℤ) :
    toIocMod hp (a + m • p) b = toIocMod hp a b + m • p
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem isUnit_of_right_inverse (h : A * B = 1) : IsUnit A
-- Mathlib/RingTheory/Coalgebra/Basic.lean
@[simp]
theorem counit_apply (r : A × B) : (counit r : R) = counit r.1 + counit r.2
-- Mathlib/Algebra/Algebra/Unitization.lean
@[ext]
theorem ext {x y : Unitization R A} (h1 : x.fst = y.fst) (h2 : x.snd = y.snd) : x = y
-- Mathlib/Order/Filter/Bases.lean
theorem le_iff_forall_inf_principal_compl {f g : Filter α} : f ≤ g ↔ ∀ V ∈ g, f ⊓ 𝓟 Vᶜ = ⊥
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The second of two points lies in their affine span. -/
theorem right_mem_affineSpan_pair (p₁ p₂ : P) : p₂ ∈ line[k, p₁, p₂]
-- Mathlib/FieldTheory/Galois.lean
theorem is_separable_splitting_field [FiniteDimensional F E] [IsGalois F E] :
    ∃ p : F[X], p.Separable ∧ p.IsSplittingField F E
-- Mathlib/Data/Ordmap/Ordset.lean
theorem all_rotateL {P l x r} : @All α P (rotateL l x r) ↔ All P l ∧ P x ∧ All P r
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- In a pseudometric space, an open ball of infinite radius is the whole space -/
theorem Metric.eball_top_eq_univ (x : α) : EMetric.ball x ∞ = Set.univ
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem coe_coe_ringHom (f : α →+*o β) : ⇑(f : α →+* β) = f
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[norm_cast] -- @[simp] -- Porting note (#10618): simp can prove this
theorem coe_inj {f g : M [⋀^ι]→ₗ[R] N} : (f : (ι → M) → N) = g ↔ f = g
-- Mathlib/Data/List/Rotate.lean
theorem cyclicPermutations_cons (x : α) (l : List α) :
    cyclicPermutations (x :: l) = dropLast (zipWith (· ++ ·) (tails (x :: l)) (inits (x :: l)))
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem symm_trans_self (h : M ≃ₘ^n⟮I, J⟯ N) : h.symm.trans h = Diffeomorph.refl J N n
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- If a family of sets `𝒜` is contained in `ℬ`, then the algebra of sets generated by `𝒜`
is contained in the one generated by `ℬ`. -/
theorem generateSetAlgebra_mono {ℬ : Set (Set α)} (h : 𝒜 ⊆ ℬ) :
    generateSetAlgebra 𝒜 ⊆ generateSetAlgebra ℬ
-- Mathlib/RingTheory/Localization/Basic.lean
@[simp]
theorem mk'_sec (z : S) : mk' S (IsLocalization.sec M z).1 (IsLocalization.sec M z).2 = z
-- Mathlib/Init/Algebra/Classes.lean
theorem esymm {a b : α} : a ≈ b → b ≈ a
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
@[simp]
theorem changeForm_one : changeForm h (1 : CliffordAlgebra Q) = 1
-- Mathlib/Analysis/Convex/Between.lean
theorem Wbtw.sameRay_vsub_right {x y z : P} (h : Wbtw R x y z) : SameRay R (z -ᵥ x) (z -ᵥ y)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
/-- Two equivalent partial equivs have the same target. -/
theorem EqOnSource.target_eq {e e' : PartialEquiv α β} (h : e ≈ e') : e.target = e'.target
-- Mathlib/Analysis/Calculus/FDeriv/Linear.lean
@[fun_prop]
theorem IsBoundedLinearMap.differentiableAt (h : IsBoundedLinearMap 𝕜 f) : DifferentiableAt 𝕜 f x
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem eq_push_of_size_ne_zero {as : Array α} (h : as.size ≠ 0) :
    ∃ (bs : Array α) (c : α), as = bs.push c
-- Mathlib/Data/Nat/PSub.lean
@[simp]
theorem ppred_eq_none : ∀ {n : ℕ}, ppred n = none ↔ n = 0
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_to_lattice_hom (f : F) : ⇑(toLatticeHom α β f) = f
-- Mathlib/Order/Filter/AtTopBot.lean
@[simp]
theorem comap_atTop (e : α ≃o β) : comap e atTop = atTop
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- A morphism into the opposite monoid acts on the product by acting on the reversed elements. -/
@[deprecated _root_.unop_map_list_prod (since := "2023-01-10")]
protected theorem unop_map_list_prod (f : M →* Nᵐᵒᵖ) (l : List M) :
    (f l.prod).unop = (l.map (MulOpposite.unop ∘ f)).reverse.prod
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem FiniteSpanningSetsIn.disjointed_set_eq {μ : Measure α}
    (S : μ.FiniteSpanningSetsIn { s | MeasurableSet s }) : S.disjointed.set = disjointed S.set