ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/SurjectiveOnStalks.lean
lemma surjectiveOnStalks_iff_forall_maximal :
    f.SurjectiveOnStalks ↔ ∀ (I : Ideal S) (_ : I.IsMaximal),
      Function.Surjective (Localization.localRingHom _ I f rfl)
-- Mathlib/Algebra/Star/SelfAdjoint.lean
/-- Self-adjoint elements commute if and only if their product is self-adjoint. -/
lemma commute_iff {R : Type*} [Mul R] [StarMul R] {x y : R}
    (hx : IsSelfAdjoint x) (hy : IsSelfAdjoint y) : Commute x y ↔ IsSelfAdjoint (x * y)
-- Mathlib/Data/Fintype/Pi.lean
lemma eval_image_piFinset_const {β} [DecidableEq β] (t : Finset β) (a : α) :
    ((piFinset fun _i : α ↦ t).image fun f ↦ f a) = t
-- Mathlib/Algebra/Tropical/Basic.lean
@[simp]
theorem trop_inj_iff (x y : R) : trop x = trop y ↔ x = y
-- Mathlib/Analysis/Calculus/LocalExtr/Rolle.lean
/-- **Rolle's Theorem** `HasDerivAt` version -/
theorem exists_hasDerivAt_eq_zero (hab : a < b) (hfc : ContinuousOn f (Icc a b)) (hfI : f a = f b)
    (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x) : ∃ c ∈ Ioo a b, f' c = 0
-- Mathlib/Order/Filter/FilterProduct.lean
@[simp, norm_cast]
theorem const_lt_iff [Preorder β] {x y : β} : (↑x : β*) < ↑y ↔ x < y
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_eq_fold [CommMonoid β] (s : Finset α) (f : α → β) :
    ∏ x ∈ s, f x = s.fold ((· * ·) : β → β → β) 1 f
-- Mathlib/MeasureTheory/Measure/GiryMonad.lean
theorem measurable_of_measurable_coe (f : β → Measure α)
    (h : ∀ (s : Set α), MeasurableSet s → Measurable fun b => f b s) : Measurable f
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
protected theorem Filter.EventuallyEq.gradient (h : f₁ =ᶠ[𝓝 x] f) : ∇ f₁ =ᶠ[𝓝 x] ∇ f
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem one_def : (1 : k[G]) = single 0 1
-- Mathlib/Data/Finset/Basic.lean
/-- A version of `LawfulSingleton.insert_emptyc_eq` that works with `dsimp`. -/
@[simp] lemma insert_empty : insert a (∅ : Finset α) = {a}
-- Mathlib/Algebra/Lie/Submodule.lean
/-- The natural functor that forgets the action of `L` as an order embedding. -/
@[simps] def toSubmodule_orderEmbedding : LieSubmodule R L M ↪o Submodule R M
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem im_to_real {x : ℝ} : imR x = 0
-- Mathlib/Topology/Order/OrderClosed.lean
theorem Iio_mem_nhds (h : a < b) : Iio b ∈ 𝓝 a
-- Mathlib/RingTheory/Ideal/Pointwise.lean
theorem mem_inv_pointwise_smul_iff {a : M} {S : Ideal R} {x : R} : x ∈ a⁻¹ • S ↔ a • x ∈ S
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem rootMultiplicity_le_iff {p : R[X]} (p0 : p ≠ 0) (a : R) (n : ℕ) :
    rootMultiplicity a p ≤ n ↔ ¬(X - C a) ^ (n + 1) ∣ p
-- Mathlib/Order/Interval/Set/OrderEmbedding.lean
@[simp] theorem preimage_Ici : e ⁻¹' Ici (e x) = Ici x
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem cosh_add_sinh : cosh x + sinh x = exp x
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem exists_and_left : (∃ x, b ∧ p x) ↔ b ∧ (∃ x, p x)
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem C_add : (C (a + a') : MvPolynomial σ R) = C a + C a'
-- Mathlib/Analysis/Convolution.lean
theorem convolution_congr [MeasurableAdd₂ G] [MeasurableNeg G] [SFinite μ]
    [IsAddRightInvariant μ] (h1 : f =ᵐ[μ] f') (h2 : g =ᵐ[μ] g') : f ⋆[L, μ] g = f' ⋆[L, μ] g'
-- Mathlib/Analysis/Calculus/LocalExtr/Rolle.lean
/-- **Rolle's Theorem**, a version for a function on an open interval: if `f` has derivative `f'`
on `(a, b)` and has the same limit `l` at `𝓝[>] a` and `𝓝[<] b`, then `f' c = 0`
for some `c ∈ (a, b)`.  -/
theorem exists_hasDerivAt_eq_zero' (hab : a < b) (hfa : Tendsto f (𝓝[>] a) (𝓝 l))
    (hfb : Tendsto f (𝓝[<] b) (𝓝 l)) (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x) :
    ∃ c ∈ Ioo a b, f' c = 0
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem trans_source' : (e.trans e').source = e.source ∩ e ⁻¹' (e.target ∩ e'.source)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem range_comp_le_range (f : A →ₐ[R] B) (g : B →ₐ[R] C) : (g.comp f).range ≤ g.range
-- Mathlib/Analysis/Quaternion.lean
@[continuity]
theorem continuous_re : Continuous fun q : ℍ => q.re
-- Mathlib/Data/Multiset/Powerset.lean
@[simp]
theorem powersetCardAux_zero (l : List α) : powersetCardAux 0 l = [0]
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem isNoetherian_zero : IsNoetherian R₁ (0 : FractionalIdeal R₁⁰ K)
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
@[simp]
theorem integralPowerBasis'_gen [hcycl : IsCyclotomicExtension {p} ℚ K] (hζ : IsPrimitiveRoot ζ p) :
    hζ.integralPowerBasis'.gen = hζ.toInteger
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma map_inr :
    (H.mapHomologicalComplex (ComplexShape.up ℤ)).map (inr φ) ≫
      (mapHomologicalComplexIso φ H).hom =
    inr ((Functor.mapHomologicalComplex H (ComplexShape.up ℤ)).map φ)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem join_replicate_nil : (replicate n ([] : List α)).join = []
-- Mathlib/Data/Ordmap/Ordset.lean
theorem all_node4R {P l x m y r} :
    @All α P (node4R l x m y r) ↔ All P l ∧ P x ∧ All P m ∧ P y ∧ All P r
-- Mathlib/Algebra/Polynomial/Module/Basic.lean
@[simp]
theorem eval_map' (f : M →ₗ[R] M) (q : PolynomialModule R M) (r : R) :
    eval r (map R f q) = f (eval r q)
-- Mathlib/FieldTheory/Tower.lean
theorem right [hf : FiniteDimensional F A] : FiniteDimensional K A
-- .lake/packages/lean4/src/lean/Init/Core.lean
/--
`LawfulRightIdentify op o` indicates `o` is a verified right identity of
`op`.
-/
class LawfulRightIdentity (op : α → β → α) (o : outParam β) extends RightIdentity op o : Prop where
  /-- Right identity `o` is an identity. -/
  right_id : ∀ a, op a o = a
-- Mathlib/Order/LiminfLimsup.lean
lemma isBoundedUnder_ge_sum {κ : Type*} [AddCommMonoid R]
    [CovariantClass R R (fun a b ↦ a + b) (· ≤ ·)] [CovariantClass R R (fun a b ↦ b + a) (· ≤ ·)]
    {u : κ → α → R} (s : Finset κ) :
    (∀ k ∈ s, f.IsBoundedUnder (· ≥ ·) (u k)) →
      f.IsBoundedUnder (· ≥ ·) (∑ k ∈ s, u k)
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
theorem FinMeasSupp.integrable {f : α →ₛ E} (h : f.FinMeasSupp μ) : Integrable f μ
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem cthickening_eq_iInter_thickening {δ : ℝ} (δ_nn : 0 ≤ δ) (E : Set α) :
    cthickening δ E = ⋂ (ε : ℝ) (_ : δ < ε), thickening ε E
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
theorem usize_size_eq : Or (Eq USize.size 4294967296) (Eq USize.size 18446744073709551616)
-- Mathlib/CategoryTheory/Limits/Types.lean
@[simp]
lemma Quot.map_ι {j j' : J} {f : j ⟶ j'} (x : F.obj j) : Quot.ι F j' (F.map f x) = Quot.ι F j x
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem embedding_coeFn : Embedding (UniformFun.ofFun ∘ (⇑) : (α →ᵇ β) → α →ᵤ β)
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp]
theorem nullHomotopicMap_f {k₂ k₁ k₀ : ι} (r₂₁ : c.Rel k₂ k₁) (r₁₀ : c.Rel k₁ k₀)
    (hom : ∀ i j, C.X i ⟶ D.X j) :
    (nullHomotopicMap hom).f k₁ = C.d k₁ k₀ ≫ hom k₀ k₁ + hom k₁ k₂ ≫ D.d k₂ k₁
-- Mathlib/Probability/Martingale/Basic.lean
theorem martingale_iff [PartialOrder E] :
    Martingale f ℱ μ ↔ Supermartingale f ℱ μ ∧ Submartingale f ℱ μ
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
/-- The morphism of short complexes `S.map F ⟶ S.map G` induced by
a natural transformation `F ⟶ G`. -/
@[simps]
def mapNatTrans {F G : C ⥤ D} [F.PreservesZeroMorphisms] [G.PreservesZeroMorphisms] (τ : F ⟶ G) :
    S.map F ⟶ S.map G
-- Mathlib/Algebra/Polynomial/Div.lean
theorem X_dvd_iff {f : R[X]} : X ∣ f ↔ f.coeff 0 = 0
-- Mathlib/Logic/Embedding/Basic.lean
@[simp]
theorem toFun_eq_coe {α β} (f : α ↪ β) : toFun f = f
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
theorem carrier.denom_not_mem : f ∉ carrier.asIdeal f_deg hm q
-- Mathlib/Data/Nat/ModEq.lean
protected theorem mul_left' (c : ℕ) (h : a ≡ b [MOD n]) : c * a ≡ c * b [MOD c * n]
-- Mathlib/Data/Multiset/Sort.lean
@[simp]
theorem sort_sorted (s : Multiset α) : Sorted r (sort r s)
-- Mathlib/Geometry/Manifold/ContMDiffMap.lean
@[ext]
theorem ext (h : ∀ x, f x = g x) : f = g
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- A variant of `of_is_coproduct` that is more useful with `apply`. -/
theorem of_is_coproduct' (h : Limits.IsColimit (BinaryCofan.mk inl inr)) (t : IsInitial Z) :
    IsPushout (t.to _) (t.to _) inl inr
-- Mathlib/Algebra/FreeMonoid/Basic.lean
@[to_additive]
theorem lift_apply (f : α → M) (l : FreeMonoid α) : lift f l = ((toList l).map f).prod
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem eq_zero_of_measure_zero {β : Type*} [NormedAddCommGroup β] {T : Set α → β} {C : ℝ}
    (hT : DominatedFinMeasAdditive μ T C) {s : Set α} (hs : MeasurableSet s) (hs_zero : μ s = 0) :
    T s = 0
-- Mathlib/Analysis/Convex/Side.lean
theorem SSameSide.not_wOppSide {s : AffineSubspace R P} {x y : P} (h : s.SSameSide x y) :
    ¬s.WOppSide x y
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
private theorem one_def : 1 = mk (abv := abv) 1
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@[ext] lemma Hom.ext' (X Y : LocallyRingedSpace.{u}) {f g : X ⟶ Y} (h : f.val = g.val) : f = g
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
/-- In an s-finite space, among disjoint null-measurable sets, only countably many can have positive
measure. -/
theorem countable_meas_pos_of_disjoint_iUnion₀ {ι : Type*} {_ : MeasurableSpace α} {μ : Measure α}
    [SFinite μ] {As : ι → Set α} (As_mble : ∀ i : ι, NullMeasurableSet (As i) μ)
    (As_disj : Pairwise (AEDisjoint μ on As)) :
    Set.Countable { i : ι | 0 < μ (As i) }
-- Mathlib/Combinatorics/Quiver/Covering.lean
theorem Prefunctor.IsCovering.comp (hφ : φ.IsCovering) (hψ : ψ.IsCovering) : (φ ⋙q ψ).IsCovering
-- Mathlib/RingTheory/Generators.lean
@[simp] lemma val_sub : (x - y).val = x.val - y.val
-- Mathlib/Data/Int/ConditionallyCompleteOrder.lean
theorem csInf_of_not_bdd_below {s : Set ℤ} (h : ¬BddBelow s) : sInf s = 0
-- Mathlib/Analysis/Calculus/Implicit.lean
theorem mem_implicitToPartialHomeomorph_target (hf : HasStrictFDerivAt f f' a)
    (hf' : range f' = ⊤) : (f a, (0 : ker f')) ∈ (hf.implicitToPartialHomeomorph f f' hf').target
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem leftOp_comp (α : F ⟶ G) (β : G ⟶ H) : NatTrans.leftOp (α ≫ β) =
    NatTrans.leftOp β ≫ NatTrans.leftOp α
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem mul_dvd_mul_left (a : α) (h : b ∣ c) : a * b ∣ a * c
-- Mathlib/Data/Set/Defs.lean
theorem diff_eq (s t : Set α) : s \ t = s ∩ tᶜ
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem exponent_dvd {n : ℕ} : exponent G ∣ n ↔ ∀ g : G, orderOf g ∣ n
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem toHomeomorph_refl : (refl 𝕜 P).toHomeomorph = Homeomorph.refl P
-- Mathlib/CategoryTheory/ComposableArrows.lean
lemma ext_succ {F G : ComposableArrows C (n + 1)} (h₀ : F.obj' 0 = G.obj' 0)
    (h : F.δ₀ = G.δ₀) (w : F.map' 0 1 = eqToHom h₀ ≫ G.map' 0 1 ≫
      eqToHom (Functor.congr_obj h.symm 0)) : F = G
-- Mathlib/Order/Heyting/Hom.lean
theorem toFun_eq_coe {f : HeytingHom α β} : f.toFun = ⇑f
-- Mathlib/RingTheory/Algebraic.lean
theorem is_transcendental_of_subsingleton [Subsingleton R] (x : A) : Transcendental R x
-- Mathlib/Analysis/NormedSpace/HomeomorphBall.lean
@[simp]
theorem PartialHomeomorph.univUnitBall_apply_zero : univUnitBall (0 : E) = 0
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem coeff_zero (n : ℕ) : coeff (0 : R[X]) n = 0
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- A continuous function whose support is contained in a compact set is strongly measurable. -/
@[to_additive]
theorem _root_.Continuous.stronglyMeasurable_of_mulSupport_subset_isCompact
    [MeasurableSpace α] [TopologicalSpace α] [OpensMeasurableSpace α] [MeasurableSpace β]
    [TopologicalSpace β] [PseudoMetrizableSpace β] [BorelSpace β] [One β] {f : α → β}
    (hf : Continuous f) {k : Set α} (hk : IsCompact k)
    (h'f : mulSupport f ⊆ k) : StronglyMeasurable f
-- Mathlib/Algebra/GroupWithZero/Semiconj.lean
lemma zpow_zpow₀ (h : Commute a b) (m n : ℤ) : Commute (a ^ m) (b ^ n)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem succ_sub {m n : Nat} (h : n ≤ m) : succ m - n = succ (m - n)
-- Mathlib/Analysis/Complex/Basic.lean
@[norm_cast]
theorem ofReal_tsum (f : α → ℝ) : (↑(∑' a, f a) : ℂ) = ∑' a, ↑(f a)
-- Mathlib/Order/Filter/Basic.lean
theorem EventuallyLE.le_sup_of_le_right [SemilatticeSup β] {l : Filter α} {f g h : α → β}
    (hg : h ≤ᶠ[l] g) : h ≤ᶠ[l] f ⊔ g
-- Mathlib/Analysis/MellinInversion.lean
private theorem rexp_neg_deriv_aux :
    ∀ x ∈ univ, HasDerivWithinAt (rexp ∘ Neg.neg) (-rexp (-x)) univ x
-- Mathlib/Logic/Function/Defs.lean
theorem HasLeftInverse.injective {f : α → β} : HasLeftInverse f → Injective f
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
@[simp]
theorem isOrtho_bot_right {U : Submodule 𝕜 E} : U ⟂ ⊥
-- Mathlib/LinearAlgebra/Isomorphisms.lean
@[simp]
theorem quotientQuotientEquivQuotientAux_mk (x : M ⧸ S) :
    quotientQuotientEquivQuotientAux S T h (Quotient.mk x) = mapQ S T LinearMap.id h x
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
theorem rightDistributor_assoc {J : Type} [Fintype J] (f : J → C) (X Y : C) :
    (rightDistributor f X ⊗ asIso (𝟙 Y)) ≪≫ rightDistributor _ Y =
      α_ (⨁ f) X Y ≪≫ rightDistributor f (X ⊗ Y) ≪≫ biproduct.mapIso fun j => (α_ _ X Y).symm
-- Mathlib/Data/Nat/Log.lean
theorem log_le_clog (b n : ℕ) : log b n ≤ clog b n
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
lemma withDensity_inv_same {μ : Measure α} {f : α → ℝ≥0∞}
    (hf : Measurable f) (hf_ne_zero : ∀ᵐ x ∂μ, f x ≠ 0) (hf_ne_top : ∀ᵐ x ∂μ, f x ≠ ∞) :
    (μ.withDensity f).withDensity (fun x ↦ (f x)⁻¹) = μ
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem normalize_monic [DecidableEq R] (h : Monic p) : normalize p = p
-- Mathlib/Data/List/Indexes.lean
@[simp, deprecated (since := "2023-02-11")]
theorem nthLe_mapIdx (l : List α) (f : ℕ → α → β) (i : ℕ) (h : i < l.length)
    (h' : i < (l.mapIdx f).length := h.trans_le (l.length_mapIdx f).ge) :
    (l.mapIdx f).nthLe i h' = f i (l.nthLe i h)
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIcc_of_gt (h : b < a) : [[a, b]] = Icc b a
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
theorem prod_Ico_eq_mul_inv {δ : Type*} [CommGroup δ] (f : ℕ → δ) {m n : ℕ} (h : m ≤ n) :
    ∏ k ∈ Ico m n, f k = (∏ k ∈ range n, f k) * (∏ k ∈ range m, f k)⁻¹
-- Mathlib/Analysis/Convolution.lean
/-- The symmetric definition of convolution where the bilinear operator is scalar multiplication. -/
theorem convolution_lsmul_swap {f : G → 𝕜} {g : G → F} :
    (f ⋆[lsmul 𝕜 𝕜, μ] g : G → F) x = ∫ t, f (x - t) • g t ∂μ
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
@[simp]
theorem toMeasure_apply_fintype [Fintype α] : p.toMeasure s = ∑ x, s.indicator p x
-- Mathlib/Data/Finset/Powerset.lean
@[simp]
theorem powersetCard_zero (s : Finset α) : s.powersetCard 0 = {∅}
-- Mathlib/Data/Finset/SMulAntidiagonal.lean
@[to_additive]
theorem isPWO_support_smulAntidiagonal {hs : s.IsPWO} {ht : t.IsPWO} :
    { a | (SMulAntidiagonal hs ht a).Nonempty }.IsPWO
-- Mathlib/LinearAlgebra/Prod.lean
theorem snd_eq_coprod : snd R M M₂ = coprod 0 LinearMap.id
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem map_zero (f : α → β) : map f 0 = 0
-- Mathlib/Analysis/MeanInequalities.lean
/-- **Minkowski inequality**: the `L_p` seminorm of the sum of two vectors is less than or equal
to the sum of the `L_p`-seminorms of the summands. A version for `Real`-valued functions. -/
theorem Lp_add_le (hp : 1 ≤ p) :
    (∑ i ∈ s, |f i + g i| ^ p) ^ (1 / p) ≤
      (∑ i ∈ s, |f i| ^ p) ^ (1 / p) + (∑ i ∈ s, |g i| ^ p) ^ (1 / p)
-- Mathlib/Data/List/Lattice.lean
@[simp]
theorem count_bagInter {a : α} :
    ∀ {l₁ l₂ : List α}, count a (l₁.bagInter l₂) = min (count a l₁) (count a l₂)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem iUnion_ofWithBot (boxes : Finset (WithBot (Box ι)))
    (le_of_mem : ∀ J ∈ boxes, (J : WithBot (Box ι)) ≤ I)
    (pairwise_disjoint : Set.Pairwise (boxes : Set (WithBot (Box ι))) Disjoint) :
    (ofWithBot boxes le_of_mem pairwise_disjoint).iUnion = ⋃ J ∈ boxes, ↑J
-- Mathlib/GroupTheory/CommutingProbability.lean
lemma commProb_nil : commProb (Product []) = 1
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem IsCycle.existsUnique_cycle {f : Perm α} (hf : IsCycle f) :
    ∃! s : Cycle α, ∃ h : s.Nodup, s.formPerm h = f
-- Mathlib/MeasureTheory/Group/AEStabilizer.lean
/-- A.e. stabilizer of a set under a group action. -/
@[to_additive (attr := simps) "A.e. stabilizer of a set under an additive group action."]
def aestabilizer (s : Set α) : Subgroup G
-- Mathlib/Algebra/Lie/SkewAdjoint.lean
@[simp]
theorem mem_skewAdjointMatricesLieSubalgebra (A : Matrix n n R) :
    A ∈ skewAdjointMatricesLieSubalgebra J ↔ A ∈ skewAdjointMatricesSubmodule J
-- Mathlib/Algebra/MvPolynomial/Rename.lean
/-- `exists_finset_rename` for two polynomials at once: for any two polynomials `p₁`, `p₂` in a
  polynomial semiring `R[σ]` of possibly infinitely many variables, `exists_finset_rename₂` yields
  a finite subset `s` of `σ` such that both `p₁` and `p₂` are contained in the polynomial semiring
  `R[s]` of finitely many variables. -/
theorem exists_finset_rename₂ (p₁ p₂ : MvPolynomial σ R) :
    ∃ (s : Finset σ) (q₁ q₂ : MvPolynomial s R), p₁ = rename (↑) q₁ ∧ p₂ = rename (↑) q₂
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- The map sending a congruence relation to its underlying equivalence relation is injective. -/
@[to_additive "The map sending an additive congruence relation to its underlying equivalence
relation is injective."]
theorem toSetoid_inj {c d : Con M} (H : c.toSetoid = d.toSetoid) : c = d
-- Mathlib/Analysis/Convex/Strong.lean
@[simp] lemma uniformConcaveOn_zero : UniformConcaveOn s 0 f ↔ ConcaveOn ℝ s f
-- Mathlib/CategoryTheory/Limits/Opposites.lean
@[reassoc (attr := simp)]
theorem pullbackIsoUnopPushout_hom_inl {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) [HasPullback f g]
    [HasPushout f.op g.op] :
    pushout.inl _ _ ≫ (pullbackIsoUnopPushout f g).hom.op = (pullback.fst f g).op
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem coe_ne_zero (z : ℤ_[p]) : (z : ℚ_[p]) ≠ 0 ↔ z ≠ 0
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_one : ⇑(1 : P →ᵃⁱ[𝕜] P) = _root_.id
-- Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean
lemma mem_of_isIso [ClosedUnderIsomorphisms P] {X Y : C} (f : X ⟶ Y) [IsIso f] (hX : P X) : P Y
-- Mathlib/Topology/Instances/ENNReal.lean
/-- Comparison test of convergence of `ℝ≥0`-valued series. -/
theorem summable_of_le {f g : β → ℝ≥0} (hgf : ∀ b, g b ≤ f b) : Summable f → Summable g
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive (attr := ext)]
theorem MulHom.ext [Mul M] [Mul N] ⦃f g : M →ₙ* N⦄ (h : ∀ x, f x = g x) : f = g
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem curryFinFinset_apply_const_aux {k l n : ℕ} {s : Finset (Fin n)} (hk : s.card = k)
    (hl : sᶜ.card = l) (f : MultilinearMap R (fun _ : Fin n => M') M₂) (x y : M') :
    (f fun i => Sum.elim (fun _ => x) (fun _ => y) ((⇑ (Equiv.symm (finSumEquivOfFinset hk hl))) i))
      = f (s.piecewise (fun _ => x) fun _ => y)
-- Mathlib/Data/Set/Card.lean
theorem encard_add_encard_compl (s : Set α) : s.encard + sᶜ.encard = (univ : Set α).encard
-- Mathlib/Data/Seq/Computation.lean
theorem eq_thinkN' (s : Computation α) [_h : Terminates s] :
    s = thinkN (pure (get s)) (length s)
-- Mathlib/Data/Num/Prime.lean
@[simp]
theorem minFac_to_nat : ∀ n : Num, (minFac n : ℕ) = Nat.minFac n
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Iio : (some : α → WithBot α) ⁻¹' Iio a = Iio a
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiffOn.contDiffWithinAt (h : ContDiffOn 𝕜 n f s) (hx : x ∈ s) :
    ContDiffWithinAt 𝕜 n f s x
-- Mathlib/Algebra/DirectSum/Module.lean
theorem coeLinearMap_eq_dfinsupp_sum [DecidableEq M] (x : DirectSum ι fun i => A i) :
    coeLinearMap A x = DFinsupp.sum x fun i => (fun x : A i => ↑x)
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem zero_le_neg_iff {x : PGame} : 0 ≤ -x ↔ x ≤ 0
-- Mathlib/CategoryTheory/Functor/Trifunctor.lean
/-- Auxiliary definition for `bifunctorComp₁₂`. -/
@[simps]
def bifunctorComp₁₂Obj (X₁ : C₁) : C₂ ⥤ C₃ ⥤ C₄
-- Mathlib/Data/Multiset/Basic.lean
@[simp, norm_cast]
theorem coe_singleton (a : α) : ([a] : Multiset α) = {a}
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
theorem exists_measurable_subset_ae_eq (h : NullMeasurableSet s μ) :
    ∃ t ⊆ s, MeasurableSet t ∧ t =ᵐ[μ] s
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem neg_bot : -(⊥ : Submodule R M) = ⊥
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem extract_zero_endPos : ∀ (s : String), s.extract 0 (endPos s) = s
-- Mathlib/CategoryTheory/NatIso.lean
theorem naturality_1 (α : F ≅ G) (f : X ⟶ Y) : α.inv.app X ≫ F.map f ≫ α.hom.app Y = G.map f
-- Mathlib/NumberTheory/NumberField/Units/Regulator.lean
/-- Let `u : Fin (rank K) → (𝓞 K)ˣ` be a family of units and let `w₁` and `w₂` be two infinite
places. Then, the two square matrices with entries `(mult w * log w (u i))_i, {w ≠ w_i}`, `i = 1,2`,
have the same determinant in absolute value. -/
theorem abs_det_eq_abs_det (u : Fin (rank K) → (𝓞 K)ˣ)
    {w₁ w₂ : InfinitePlace K} (e₁ : {w // w ≠ w₁} ≃ Fin (rank K))
    (e₂ : {w // w ≠ w₂} ≃ Fin (rank K)) :
    |(Matrix.of fun i w : {w // w ≠ w₁} ↦ (mult w.val : ℝ) * (w.val (u (e₁ i) : K)).log).det| =
    |(Matrix.of fun i w : {w // w ≠ w₂} ↦ (mult w.val : ℝ) * (w.val (u (e₂ i) : K)).log).det|
-- Mathlib/GroupTheory/Complement.lean
@[simp, nolint simpNF]
theorem equiv_mul_left (h : H) (g : G) :
    hHT.equiv (h * g) = (h * (hHT.equiv g).fst, (hHT.equiv g).snd)
-- Mathlib/Geometry/Euclidean/Sphere/Basic.lean
/-- A single point is concyclic. -/
theorem concyclic_singleton (p : P) : Concyclic ({p} : Set P)
-- Mathlib/RingTheory/PrimeSpectrum.lean
@[simp]
theorem zeroLocus_span (s : Set R) : zeroLocus (Ideal.span s : Set R) = zeroLocus s
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem coe_comp_of {X Y Z : Type u} [CommSemiring X] [CommSemiring Y] [CommSemiring Z]
    (f : X →+* Y) (g : Y →+* Z) :
    @DFunLike.coe no_index (CommSemiRingCat.of X ⟶ CommSemiRingCat.of Z) X
      (fun _ ↦ Z) _
      (CategoryStruct.comp (X := CommSemiRingCat.of X) (Y := CommSemiRingCat.of Y)
        (Z := CommSemiRingCat.of Z) f g) =
    @DFunLike.coe (X →+* Z) X (fun _ ↦ Z) _ (RingHom.comp g f)
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem toReal_prod {ι : Type*} {s : Finset ι} {f : ι → ℝ≥0∞} :
    (∏ i ∈ s, f i).toReal = ∏ i ∈ s, (f i).toReal
-- Mathlib/Data/Set/Prod.lean
theorem _root_.Antitone.set_prod (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x => f x ×ˢ g x
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_lt_of_mul_lt_left [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α} (h : a * b < c)
    (hle : d ≤ b) :
    a * d < c
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_iInf (s : Finset β) (f : β → L.BoundedFormula α n)
    (v : α → M) (v' : Fin n → M) :
    (iInf s f).Realize v v' ↔ ∀ b ∈ s, (f b).Realize v v'
-- Mathlib/Data/Finset/Sigma.lean
theorem card_sigmaLift :
    (sigmaLift f a b).card = dite (a.1 = b.1) (fun h => (f (h ▸ a.2) b.2).card) fun _ => 0
-- Mathlib/GroupTheory/Subgroup/Centralizer.lean
@[to_additive]
theorem centralizer_le {s t : Set G} (h : s ⊆ t) : centralizer t ≤ centralizer s
-- Mathlib/Order/FixedPoints.lean
theorem lfp_induction {p : α → Prop} (step : ∀ a, p a → a ≤ lfp f → p (f a))
    (hSup : ∀ s, (∀ a ∈ s, p a) → p (sSup s)) : p (lfp f)
-- Mathlib/Algebra/Lie/Submodule.lean
theorem mem_map {x : L} (hx : x ∈ I) : f x ∈ map f I
-- Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean
lemma continuous_mul_log : Continuous fun x ↦ x * log x
-- Mathlib/SetTheory/Game/Ordinal.lean
theorem toPGame_injective : Function.Injective Ordinal.toPGame
-- Mathlib/Topology/Order/IntermediateValue.lean
/-- Suppose `f : [a, b] → δ` is continuous and injective. Then `f` is strictly monotone
or antitone (increasing or decreasing). -/
theorem ContinuousOn.strictMonoOn_of_injOn_Icc' {a b : α} {f : α → δ} (hab : a ≤ b)
    (hf_c : ContinuousOn f (Icc a b)) (hf_i : InjOn f (Icc a b)) :
    StrictMonoOn f (Icc a b) ∨ StrictAntiOn f (Icc a b)