ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/Filter/IndicatorFunction.lean
@[to_additive]
theorem Monotone.tendsto_mulIndicator {ι} [Preorder ι] [One β] (s : ι → Set α) (hs : Monotone s)
    (f : α → β) (a : α) :
    Tendsto (fun i => mulIndicator (s i) f a) atTop (pure <| mulIndicator (⋃ i, s i) f a)
-- Mathlib/Topology/Basic.lean
theorem isClosed_iUnion_of_finite [Finite ι] {s : ι → Set X} (h : ∀ i, IsClosed (s i)) :
    IsClosed (⋃ i, s i)
-- Mathlib/Topology/DiscreteQuotient.lean
@[simp]
theorem ofLE_comp_proj (h : A ≤ B) : ofLE h ∘ A.proj = B.proj
-- Mathlib/RingTheory/Ideal/Cotangent.lean
lemma finrank_cotangentSpace_eq_zero (R) [Field R] :
    finrank (ResidueField R) (CotangentSpace R) = 0
-- Mathlib/MeasureTheory/Measure/HasOuterApproxClosed.lean
lemma indicator_le_apprSeq (n : ℕ) :
    indicator F (fun _ ↦ 1) ≤ hF.apprSeq n
-- Mathlib/Data/Finset/Lattice.lean
/-- Computing `inf` in a subtype (closed under `inf`) is the same as computing it in `α`. -/
theorem inf_coe {P : α → Prop} {Ptop : P ⊤} {Pinf : ∀ ⦃x y⦄, P x → P y → P (x ⊓ y)} (t : Finset β)
    (f : β → { x : α // P x }) :
    (@inf { x // P x } _ (Subtype.semilatticeInf Pinf) (Subtype.orderTop Ptop) t f : α) =
      t.inf fun x => ↑(f x)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem data_set (a : Array α) (i v) : (a.set i v).data = a.data.set i.1 v
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem not_lf {x y : PGame} : ¬x ⧏ y ↔ y ≤ x
-- Mathlib/Data/Finsupp/Basic.lean
@[to_additive (attr := simp)]
theorem prod_filter_mul_prod_filter_not [CommMonoid N] (g : α → M → N) :
    (f.filter p).prod g * (f.filter fun a => ¬p a).prod g = f.prod g
-- Mathlib/CategoryTheory/EqToHom.lean
/-- We can push `eqToHom` to the left through families of morphisms. -/
-- The simpNF linter incorrectly claims that this will never apply.
-- https://github.com/leanprover-community/mathlib4/issues/5049
@[reassoc (attr := simp, nolint simpNF)]
theorem eqToHom_naturality {f g : β → C} (z : ∀ b, f b ⟶ g b) {j j' : β} (w : j = j') :
    z j ≫ eqToHom (by simp [w]) = eqToHom (by simp [w]) ≫ z j'
-- Mathlib/Order/Filter/Ultrafilter.lean
theorem _root_.Nat.hyperfilter_le_atTop : (hyperfilter ℕ).toFilter ≤ atTop
-- Mathlib/Algebra/Module/Torsion.lean
theorem isTorsionBySet_span_singleton_iff : IsTorsionBySet R M (R ∙ a) ↔ IsTorsionBy R M a
-- Mathlib/Analysis/Analytic/Meromorphic.lean
lemma zpow (n : ℤ) : MeromorphicOn (s ^ n) U
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.congr (hf : ConvexOn 𝕜 s f) (hfg : EqOn f g s) : ConvexOn 𝕜 s g
-- Mathlib/NumberTheory/ModularForms/SlashActions.lean
/-- A function `f : ℍ → ℂ` is slash-invariant, of weight `k ∈ ℤ` and level `Γ`,
  if for every matrix `γ ∈ Γ` we have `f(γ • z)= (c*z+d)^k f(z)` where `γ= ![![a, b], ![c, d]]`,
  and it acts on `ℍ` via Möbius transformations. -/
theorem slash_action_eq'_iff (k : ℤ) (Γ : Subgroup SL(2, ℤ)) (f : ℍ → ℂ) (γ : Γ) (z : ℍ) :
    (f ∣[k] γ) z = f z ↔ f (γ • z) = ((↑ₘ[ℤ] γ 1 0 : ℂ) * z + (↑ₘ[ℤ] γ 1 1 : ℂ)) ^ k * f z
-- Mathlib/Data/List/Chain.lean
@[simp]
theorem chain'_nil : Chain' R []
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem CompleteLattice.Independent.subtype_ne_bot_le_finrank_aux
    {p : ι → Submodule R M} (hp : CompleteLattice.Independent p) :
    #{ i // p i ≠ ⊥ } ≤ (finrank R M : Cardinal.{w})
-- Mathlib/Algebra/Order/Sub/Canonical.lean
theorem tsub_add_min : a - b + min a b = a
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[reassoc (attr := simp)]
lemma stalkMap_inv_hom (e : X ≅ Y) (x : X) :
    e.inv.stalkMap (e.hom.val.base x) ≫ e.hom.stalkMap x =
      X.presheaf.stalkSpecializes (specializes_of_eq <| by simp)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
lemma domDomRestrict_aux_right [DecidableEq ι] (P : ι → Prop) [DecidablePred P]
    [DecidableEq {a // ¬ P a}]
    (x : (i : {a // P a}) → M₁ i) (z : (i : {a // ¬ P a}) → M₁ i) (i : {a : ι // ¬ P a})
    (c : M₁ i) : (fun j ↦ if h : P j then x ⟨j, h⟩ else Function.update z i c ⟨j, h⟩) =
    Function.update (fun j => if h : P j then x ⟨j, h⟩ else z ⟨j, h⟩) i c
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
@[simp]
lemma ofNat_arg {n : ℕ} [n.AtLeastTwo] : arg (no_index (OfNat.ofNat n)) = 0
-- Mathlib/Algebra/Module/Defs.lean
theorem smul_right_injective [NoZeroSMulDivisors R M] {c : R} (hc : c ≠ 0) :
    Function.Injective (c • · : M → M)
-- Mathlib/Order/CompleteLattice.lean
theorem biInf_congr {p : ι → Prop} (h : ∀ i, p i → f i = g i) :
    ⨅ (i) (_ : p i), f i = ⨅ (i) (_ : p i), g i
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem Memℒp.aestronglyMeasurable {f : α → E} {p : ℝ≥0∞} (h : Memℒp f p μ) :
    AEStronglyMeasurable f μ
-- Mathlib/Topology/Connected/Clopen.lean
theorem coe_ne_coe {x y : α} :
    (x : ConnectedComponents α) ≠ y ↔ connectedComponent x ≠ connectedComponent y
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem IciExtend_self (f : Ici a → β) : IciExtend f a = f ⟨a, le_rfl⟩
-- Mathlib/Topology/Algebra/Ring/Basic.lean
@[simp]
theorem Subsemiring.topologicalClosure_coe (s : Subsemiring α) :
    (s.topologicalClosure : Set α) = _root_.closure (s : Set α)
-- Mathlib/Data/List/AList.lean
@[simp]
theorem mem_erase {a a' : α} {s : AList β} : a' ∈ erase a s ↔ a' ≠ a ∧ a' ∈ s
-- Mathlib/Data/List/Rotate.lean
theorem isRotated_concat (hd : α) (tl : List α) : (tl ++ [hd]) ~r (hd :: tl)
-- Mathlib/Algebra/DirectLimit.lean
protected theorem inv_mul_cancel {p : Ring.DirectLimit G f} (hp : p ≠ 0) : inv G f p * p = 1
-- Mathlib/Algebra/Ring/CentroidHom.lean
theorem intCast_apply (z : ℤ) (m : α) : (z : CentroidHom α) m = z • m
-- Mathlib/Order/Closure.lean
theorem closure_union_closure (x y : α) : l (l x ∪ l y) = l (x ∪ y)
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
theorem unop_closure (s : Set Rᵐᵒᵖ) : (closure s).unop = closure (MulOpposite.op ⁻¹' s)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- An angle in a right-angled triangle expressed using `arcsin`. -/
theorem angle_eq_arcsin_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2)
    (h0 : p₁ ≠ p₂ ∨ p₃ ≠ p₂) : ∠ p₂ p₃ p₁ = Real.arcsin (dist p₁ p₂ / dist p₁ p₃)
-- Mathlib/Topology/ContinuousOn.lean
theorem continuousOn_iff {f : α → β} {s : Set α} :
    ContinuousOn f s ↔
      ∀ x ∈ s, ∀ t : Set β, IsOpen t → f x ∈ t → ∃ u, IsOpen u ∧ x ∈ u ∧ u ∩ s ⊆ f ⁻¹' t
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem neg_apply (m : ∀ i, M₁ i) : (-f) m = -f m
-- Mathlib/Algebra/Star/Module.lean
theorem IsSelfAdjoint.skewAdjointPart_apply {x : A} (hx : IsSelfAdjoint x) :
    skewAdjointPart R x = 0
-- Mathlib/RingTheory/Algebraic.lean
@[simp]
theorem Polynomial.algebraMap_pi_eq_aeval :
    (algebraMap R'[X] (S' → T') : R'[X] → S' → T') = fun p z => algebraMap _ _ (aeval z p)
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem toFun_inducedStructureEquiv (e : M ≃ N) :
    DFunLike.coe (@inducedStructureEquiv L M N _ e) = e
-- Mathlib/Analysis/NormedSpace/AddTorsorBases.lean
@[continuity]
theorem continuous_barycentric_coord (i : ι) : Continuous (b.coord i)
-- Mathlib/Analysis/Convex/Between.lean
theorem Function.Injective.sbtw_map_iff {x y z : P} {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
private theorem gosper_trick {n i : ℕ} (h : i ≤ n) :
    gosperCatalan (n + 1) (i + 1) - gosperCatalan (n + 1) i =
      Nat.centralBinom i / (i + 1) * Nat.centralBinom (n - i) / (n - i + 1)
-- Mathlib/Computability/TuringMachine.lean
theorem tr_respects_aux₃ {q v} {L : ListBlank (∀ k, Option (Γ k))} (n) : Reaches₀ (TM1.step (tr M))
    ⟨some (ret q), v, (Tape.move Dir.right)^[n] (Tape.mk' ∅ (addBottom L))⟩
    ⟨some (ret q), v, Tape.mk' ∅ (addBottom L)⟩
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
theorem orbit.pairwiseDisjoint :
    (Set.range fun x : X => orbit G x).PairwiseDisjoint id
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem map_bot (f : F) : (⊥ : NonUnitalStarSubalgebra R A).map f = ⊥
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Subperm.count_le [DecidableEq α] {l₁ l₂ : List α} (s : l₁ <+~ l₂) (a) :
    count a l₁ ≤ count a l₂
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp, norm_cast]
theorem coe_toOrderRingHom (f : α ≃+*o β) : ⇑(f : α →+*o β) = f
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean
@[measurability]
theorem Measurable.sin : Measurable fun x => Real.sin (f x)
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean
theorem tensor_id (X₁ X₂ : C) : tensorHom ℬ (𝟙 X₁) (𝟙 X₂) = 𝟙 (tensorObj ℬ X₁ X₂)
-- Mathlib/Order/Heyting/Regular.lean
theorem isRegular_of_boolean : ∀ a : α, IsRegular a
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem lcm_apply_mul_gcd_apply [CommMonoidWithZero R] {f : ArithmeticFunction R}
    (hf : f.IsMultiplicative) {x y : ℕ} :
    f (x.lcm y) * f (x.gcd y) = f x * f y
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
/-- A morphism that is injective on pseudoelements only maps the zero element to zero. -/
theorem zero_of_map_zero {P Q : C} (f : P ⟶ Q) : Function.Injective f → ∀ a, f a = 0 → a = 0
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[simp] theorem endofunctorMonoidalCategory_rightUnitor_inv_app (F : C ⥤ C) (X : C) :
  (ρ_ F).inv.app X = 𝟙 _
-- Mathlib/RingTheory/EssentialFiniteness.lean
lemma EssFiniteType.algHom_ext [EssFiniteType R S]
    (f g : S →ₐ[R] T) (H : ∀ s ∈ finset R S, f s = g s) : f = g
-- Mathlib/FieldTheory/SeparableClosure.lean
/-- If `K / E / F` is a field extension tower, then `separableClosure F K` is contained in
`separableClosure E K`. -/
theorem separableClosure.le_restrictScalars [Algebra E K] [IsScalarTower F E K] :
    separableClosure F K ≤ (separableClosure E K).restrictScalars F
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_image_left : ⋃ a ∈ s, f a '' t = image2 f s t
-- Mathlib/Data/NNReal/Basic.lean
theorem mul_iSup_le {a : ℝ≥0} {g : ℝ≥0} {h : ι → ℝ≥0} (H : ∀ j, g * h j ≤ a) : g * iSup h ≤ a
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
/-- Post-composition with a continuous star algebra homomorphism is a star algebra homomorphism
between spaces of continuous maps. -/
@[simps]
def compStarAlgHom (φ : A →⋆ₐ[𝕜] B) (hφ : Continuous φ) :
    C(X, A) →⋆ₐ[𝕜] C(X, B)
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.not_prime_pow' {x n : ℕ} (hn : n ≠ 1) : ¬(x ^ n).Prime
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma homologyMap_add : homologyMap (φ + φ') = homologyMap φ + homologyMap φ'
-- Mathlib/Data/Seq/Computation.lean
theorem LiftRel.equiv (R : α → α → Prop) : Equivalence R → Equivalence (LiftRel R)
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Defs.lean
@[simp]
theorem map_id : map (RingHom.id R) = MonoidHom.id (GL n R)
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
protected lemma IsClopen.upperClosure_pi (hs : IsClopen s) (hs' : BddBelow s) :
    IsClopen (upperClosure s : Set (ι → ℝ))
-- Mathlib/NumberTheory/FLT/Basic.lean
lemma FermatLastTheoremWith.mono (hmn : m ∣ n) (hm : FermatLastTheoremWith α m) :
    FermatLastTheoremWith α n
-- Mathlib/Data/Finsupp/WellFounded.lean
theorem Lex.wellFounded (hbot : ∀ ⦃n⦄, ¬s n 0) (hs : WellFounded s)
    (hr : WellFounded <| rᶜ ⊓ (· ≠ ·)) : WellFounded (Finsupp.Lex r s)
-- Mathlib/Logic/Basic.lean
theorem ExistsUnique.unique₂ {α : Sort*} {p : α → Sort*} [∀ x, Subsingleton (p x)]
    {q : ∀ (x : α) (_ : p x), Prop} (h : ∃! x, ∃! hx : p x, q x hx) {y₁ y₂ : α}
    (hpy₁ : p y₁) (hqy₁ : q y₁ hpy₁) (hpy₂ : p y₂) (hqy₂ : q y₂ hpy₂) : y₁ = y₂
-- Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean
lemma exp_llr (μ ν : Measure α) [SigmaFinite μ] :
    (fun x ↦ exp (llr μ ν x))
      =ᵐ[ν] fun x ↦ if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
-- Mathlib/Probability/Moments.lean
@[simp]
theorem centralMoment_zero (hp : p ≠ 0) : centralMoment 0 p μ = 0
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
/-- A sphere in a product space is a union of spheres on each component restricted to the closed
ball. -/
lemma sphere_pi (x : ∀ b, π b) {r : ℝ} (h : 0 < r ∨ Nonempty β) :
    sphere x r = (⋃ i : β, Function.eval i ⁻¹' sphere (x i) r) ∩ closedBall x r
-- Mathlib/Topology/Basic.lean
/-- See note [comp_of_eq lemmas] -/
theorem ContinuousAt.comp_of_eq {g : Y → Z} (hg : ContinuousAt g y)
    (hf : ContinuousAt f x) (hy : f x = y) : ContinuousAt (g ∘ f) x
-- Mathlib/Topology/Order/ScottTopology.lean
lemma dirSupClosed_iff_forall_sSup :
    DirSupClosed s ↔ ∀ ⦃d⦄, d.Nonempty → DirectedOn (· ≤ ·) d → d ⊆ s → sSup d ∈ s
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (pkg.map₂ pkg' pkg'' f)
-- Mathlib/Data/Set/Pairwise/Basic.lean
/-- See also `Set.Pairwise.image`. -/
theorem InjOn.pairwise_image {s : Set ι} (h : s.InjOn f) :
    (f '' s).Pairwise r ↔ s.Pairwise (r on f)
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_trans (e : P₁ ≃ᵃ[k] P₂) (e' : P₂ ≃ᵃ[k] P₃) : ⇑(e.trans e') = e' ∘ e
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
protected theorem insert [MeasurableSingletonClass (NullMeasurableSpace α μ)]
    (hs : NullMeasurableSet s μ) (a : α) : NullMeasurableSet (insert a s) μ
-- Mathlib/Analysis/Analytic/Linear.lean
/-- `fst` is entire -/
theorem analyticOn_fst {s : Set (E × F)} : AnalyticOn 𝕜 (fun p : E × F ↦ p.fst) s
-- Mathlib/Algebra/Polynomial/Eval.lean
/-- Polynomial evaluation commutes with `Multiset.prod`
-/
theorem eval_multiset_prod (s : Multiset R[X]) (x : R) : eval x s.prod = (s.map (eval x)).prod
-- Mathlib/Algebra/Group/Fin/Basic.lean
@[simp] lemma le_sub_one_iff {k : Fin (n + 1)} : k ≤ k - 1 ↔ k = 0
-- Mathlib/Data/Finset/Lattice.lean
theorem toDual_min' {s : Finset α} (hs : s.Nonempty) :
    toDual (min' s hs) = max' (s.image toDual) (hs.image _)
-- Mathlib/CategoryTheory/Comma/Basic.lean
/-- We can interpret the commutative square constituting a morphism in the comma category as a
    natural transformation between the functors `fst ⋙ L` and `snd ⋙ R` from the comma category
    to `T`, where the components are given by the morphism that constitutes an object of the comma
    category. -/
@[simps]
def natTrans : fst L R ⋙ L ⟶ snd L R ⋙ R
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem val_eq_zero {s : Finset α} : s.1 = 0 ↔ s = ∅
-- Mathlib/Analysis/Complex/CauchyIntegral.lean
/-- Suppose that a function `f : ℂ → E` is continuous on a closed rectangle with opposite corners at
`z w : ℂ`, is *real* differentiable at all but countably many points of the corresponding open
rectangle, and $\frac{\partial f}{\partial \bar z}$ is integrable on this rectangle. Then the
integral of `f` over the boundary of the rectangle is equal to the integral of
$2i\frac{\partial f}{\partial \bar z}=i\frac{\partial f}{\partial x}-\frac{\partial f}{\partial y}$
over the rectangle. -/
theorem integral_boundary_rect_of_hasFDerivAt_real_off_countable (f : ℂ → E) (f' : ℂ → ℂ →L[ℝ] E)
    (z w : ℂ) (s : Set ℂ) (hs : s.Countable)
    (Hc : ContinuousOn f ([[z.re, w.re]] ×ℂ [[z.im, w.im]]))
    (Hd : ∀ x ∈ Ioo (min z.re w.re) (max z.re w.re) ×ℂ Ioo (min z.im w.im) (max z.im w.im) \ s,
      HasFDerivAt f (f' x) x)
    (Hi : IntegrableOn (fun z => I • f' z 1 - f' z I) ([[z.re, w.re]] ×ℂ [[z.im, w.im]])) :
    (∫ x : ℝ in z.re..w.re, f (x + z.im * I)) - (∫ x : ℝ in z.re..w.re, f (x + w.im * I)) +
      I • (∫ y : ℝ in z.im..w.im, f (re w + y * I)) -
      I • ∫ y : ℝ in z.im..w.im, f (re z + y * I) =
      ∫ x : ℝ in z.re..w.re, ∫ y : ℝ in z.im..w.im, I • f' (x + y * I) 1 - f' (x + y * I) I
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
theorem algebraMap_surjective_of_isIntegral' {k K : Type*} [Field k] [CommRing K] [IsDomain K]
    [IsAlgClosed k] (f : k →+* K) (hf : f.IsIntegral) : Function.Surjective f
-- Mathlib/CategoryTheory/FintypeCat.lean
theorem is_skeletal : Skeletal Skeleton.{u}
-- Mathlib/Algebra/Order/Group/Abs.lean
@[simp]
theorem abs_eq_neg_self : |a| = -a ↔ a ≤ 0
-- Mathlib/Computability/Halting.lean
theorem cond {c : α → Bool} {f : α →. σ} {g : α →. σ} (hc : Computable c) (hf : Partrec f)
    (hg : Partrec g) : Partrec fun a => cond (c a) (f a) (g a)
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The angle between a negative multiple of a vector and a vector. -/
@[simp]
theorem angle_smul_left_of_neg (x y : V) {r : ℝ} (hr : r < 0) : angle (r • x) y = angle (-x) y
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Icc_coe_top : Icc (a : WithTop α) ⊤ = insertNone (Ici a)
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem X_pow_mul_assoc {n : ℕ} : p * X ^ n * q = p * q * X ^ n
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean
lemma isBigO_exp_neg_mul_of_le {c d : ℝ} (hcd : c ≤ d) :
    (fun t ↦ exp (-d * t)) =O[atTop] fun t ↦ exp (-c * t)
-- Mathlib/Data/Multiset/Antidiagonal.lean
@[simp]
theorem antidiagonal_map_fst (s : Multiset α) : (antidiagonal s).map Prod.fst = powerset s
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_eq_head_iff_eq_getLast (x y : α) :
    formPerm (y :: l) x = y ↔ x = getLast (y :: l) (cons_ne_nil _ _)
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
@[simp]
theorem splitUpper_eq_bot {i x} : I.splitUpper i x = ⊥ ↔ I.upper i ≤ x
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp, norm_cast]
theorem star_val_eq {x : skewAdjoint R} : star (x : R) = -x
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem erase_ne (p : R[X]) (n i : ℕ) (h : i ≠ n) : coeff (p.erase n) i = coeff p i
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- The topological closure of a closed submodule `s` is equal to `s`. -/
theorem IsClosed.submodule_topologicalClosure_eq {s : Submodule R M} (hs : IsClosed (s : Set M)) :
    s.topologicalClosure = s
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem le_sup {ι : Type u} (f : ι → Ordinal.{max u v}) : ∀ i, f i ≤ sup.{_, v} f
-- Mathlib/Algebra/Ring/Semiconj.lean
theorem neg_one_right (a : R) : SemiconjBy a (-1) (-1)
-- Mathlib/Order/LiminfLimsup.lean
theorem isBoundedUnder_ge_finset_inf [LinearOrder β] [OrderTop β] {f : Filter α} {F : ι → α → β}
    {s : Finset ι} (h : ∀ i ∈ s, f.IsBoundedUnder (· ≥ ·) (F i)) :
    f.IsBoundedUnder (· ≥ ·) (fun a ↦ inf s (fun i ↦ F i a))
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_lt_iff_eq_or_lt_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a = b ∨ a < b
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem Perm.extendDomain_apply_image (a : α') : e.extendDomain f (f a) = f (e a)
-- Mathlib/Probability/Kernel/WithDensity.lean
@[simp]
lemma withDensity_one' (κ : Kernel α β) [IsSFiniteKernel κ] :
    Kernel.withDensity κ (fun _ _ ↦ 1) = κ
-- Mathlib/CategoryTheory/Comma/Over.lean
/-- To give a morphism in the under category, it suffices to give a morphism fitting in a
    commutative triangle. -/
@[simps!]
def homMk {U V : Under X} (f : U.right ⟶ V.right) (w : U.hom ≫ f = V.hom := by aesop_cat) : U ⟶ V
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.node' {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H : BalancedSz (size l) (size r)) : Valid' o₁ (@node' α l x r) o₂
-- Mathlib/Algebra/Polynomial/Taylor.lean
@[simp]
theorem taylor_coeff_zero : (taylor r f).coeff 0 = f.eval r
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem natAbs_norm_mod_lt (x : ℤ[i]) {y : ℤ[i]} (hy : y ≠ 0) :
    (x % y).norm.natAbs < y.norm.natAbs
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem ContinuousOn.intervalIntegrable {u : ℝ → E} {a b : ℝ} (hu : ContinuousOn u (uIcc a b)) :
    IntervalIntegrable u μ a b
-- Mathlib/Data/Ordering/Lemmas.lean
@[simp]
theorem cmpUsing_eq_lt (a b : α) : (cmpUsing lt a b = Ordering.lt) = lt a b
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
theorem closure_singleton_eq (x : A) :
    closure ({x} : Set A) = AddMonoidHom.mrange (multiplesHom A x)
-- Mathlib/Data/Set/Prod.lean
theorem sumPiEquivProdPi_symm_preimage_univ_pi (π : ι ⊕ ι' → Type*) (t : ∀ i, Set (π i)) :
    (sumPiEquivProdPi π).symm ⁻¹' univ.pi t =
    univ.pi (fun i => t (.inl i)) ×ˢ univ.pi fun i => t (.inr i)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pred_max_pred : ∀ (x y), max (pred x) (pred y) = pred (max x y)
-- Mathlib/Data/NNRat/Defs.lean
@[simp, norm_cast] lemma den_natCast (n : ℕ) : den n = 1
-- Mathlib/Algebra/Module/FinitePresentation.lean
lemma Module.finitePresentation_of_surjective [h : Module.FinitePresentation R M] (l : M →ₗ[R] N)
    (hl : Function.Surjective l) (hl' : (LinearMap.ker l).FG) :
    Module.FinitePresentation R N
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem mono_of_cofan_isVanKampen [HasInitial C] {ι : Type*} {F : Discrete ι ⥤ C}
    {c : Cocone F} (hc : IsVanKampenColimit c) (i : Discrete ι) : Mono (c.ι.app i)
-- Mathlib/Tactic/NormNum/Pow.lean
theorem natPow_zero : Nat.pow a (nat_lit 0) = nat_lit 1
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem dual_id : CompleteLatticeHom.dual (CompleteLatticeHom.id α) = CompleteLatticeHom.id _
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] theorem coe_ringHom_id {X : RingCat} :
    @DFunLike.coe (X →+* X) X (fun _ ↦ X) _ (𝟙 X) = id
-- Mathlib/NumberTheory/ModularForms/Basic.lean
/-- These are `SlashInvariantForm`'s that are holomorphic and bounded at infinity. -/
structure ModularForm extends SlashInvariantForm Γ k where
  holo' : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (toSlashInvariantForm : ℍ → ℂ)
  bdd_at_infty' : ∀ A : SL(2, ℤ), IsBoundedAtImInfty (toSlashInvariantForm ∣[k] A)
-- Mathlib/Tactic/NormNum/Pow.lean
theorem zero_natPow : Nat.pow (nat_lit 0) (Nat.succ b) = nat_lit 0
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem pow_equiv_pow {f1 f2 : CauSeq β abv} (hf : f1 ≈ f2) (n : ℕ) : f1 ^ n ≈ f2 ^ n
-- Mathlib/Topology/Order/Hom/Esakia.lean
@[simp]
theorem cancel_left {g : EsakiaHom β γ} {f₁ f₂ : EsakiaHom α β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Order/Hom/Order.lean
@[simps]
instance instTopOrderHom [Preorder β] [OrderTop β] : Top (α →o β)
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem image_swap_prod (s : Set α) (t : Set β) : Prod.swap '' s ×ˢ t = t ×ˢ s
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[refl]
theorem SameCycle.refl (f : Perm α) (x : α) : SameCycle f x x
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem incidence_other_prop {v : V} {e : Sym2 V} (h : e ∈ G.incidenceSet v) :
    G.otherVertexOfIncident h ∈ G.neighborSet v
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem isColimit_iff_bijective_desc : Nonempty (IsColimit c) ↔ (Quot.desc c).Bijective
-- Mathlib/Order/WithBot.lean
@[simp, norm_cast]
theorem coe_min [LinearOrder α] (x y : α) : ((min x y : α) : WithBot α) = min (x : WithBot α) y
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
lemma counitForward_val_fst (s : CostructuredArrow yoneda A) (x : F.obj (op s)) :
    (counitForward F s x).val.fst = s.hom
-- Mathlib/RingTheory/LocalRing/Basic.lean
theorem of_isUnit_or_isUnit_one_sub_self [Nontrivial R] (h : ∀ a : R, IsUnit a ∨ IsUnit (1 - a)) :
    LocalRing R
-- Mathlib/CategoryTheory/Monad/Monadicity.lean
theorem comparisonAdjunction_unit_f_aux
    [∀ A : adj.toMonad.Algebra, HasCoequalizer (F.map A.a)
      (adj.counit.app (F.obj A.A))]
    (A : adj.toMonad.Algebra) :
    ((comparisonAdjunction adj).unit.app A).f =
      adj.homEquiv A.A _
        (coequalizer.π (F.map A.a) (adj.counit.app (F.obj A.A)))
-- Mathlib/Data/Finset/Grade.lean
@[simp] lemma grade_multiset_eq (s : Finset α) : grade (Multiset α) s = s.1
-- Mathlib/Topology/Sheaves/Stalks.lean
theorem app_injective_iff_stalkFunctor_map_injective {F : Sheaf C X} {G : Presheaf C X}
    (f : F.1 ⟶ G) :
    (∀ x : X, Function.Injective ((stalkFunctor C x).map f)) ↔
      ∀ U : Opens X, Function.Injective (f.app (op U))
-- Mathlib/Topology/Instances/EReal.lean
theorem nhds_coe {r : ℝ} : 𝓝 (r : EReal) = (𝓝 r).map (↑)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem le_iff : v ≤ w ↔ ∀ i, MeasurableSet i → v i ≤ w i
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem span_singleton_mul_left_injective [IsDomain R] {x : R} (hx : x ≠ 0) :
    Function.Injective fun I : Ideal R => I * span {x}
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_neg_right (x y : F) : ⟪x, -y⟫ = -⟪x, y⟫
-- Mathlib/Data/PNat/Xgcd.lean
theorem qp_eq (hr : u.r = 0) : u.q = u.qp + 1