ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_approx_end' {n} {x a b : ℝ} (m : ℕ) (e₁ : n + 1 = m) (rm : ℝ) (er : ↑m = rm)
    (h : |x| ≤ 1) (e : |1 - a| ≤ b - |x| / rm * ((rm + 1) / rm)) :
    |exp x - expNear n x a| ≤ |x| ^ n / n.factorial * b
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem get'_eq (s : String) (p : Pos) (h) : get' s p h = get s p
-- Mathlib/InformationTheory/Hamming.lean
/-- Corresponds to `dist_nonneg`. -/
theorem hammingDist_nonneg {x y : ∀ i, β i} : 0 ≤ hammingDist x y
-- Mathlib/Analysis/Convex/Function.lean
/-- Left translation preserves strict convexity. -/
theorem StrictConvexOn.translate_left (hf : StrictConvexOn 𝕜 s f) (c : E) :
    StrictConvexOn 𝕜 ((fun z => c + z) ⁻¹' s) (f ∘ fun z => z + c)
-- Mathlib/Topology/DenseEmbedding.lean
theorem isClosed_property [TopologicalSpace β] {e : α → β} {p : β → Prop} (he : DenseRange e)
    (hp : IsClosed { x | p x }) (h : ∀ a, p (e a)) : ∀ b, p b
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc]
theorem associator_naturality_middle (X : C) {Y Y' : C} (f : Y ⟶ Y') (Z : C) :
    (X ◁ f) ▷ Z ≫ (α_ X Y' Z).hom = (α_ X Y Z).hom ≫ X ◁ f ▷ Z
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive (attr := simp)]
theorem coe_comp (f : β →*o γ) (g : α →*o β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/Topology/Algebra/ContinuousMonoidHom.lean
@[to_additive]
theorem locallyCompactSpace_of_equicontinuousAt (U : Set X) (V : Set Y)
    (hU : IsCompact U) (hV : V ∈ nhds (1 : Y))
    (h : EquicontinuousAt (fun f : {f : X →* Y | Set.MapsTo f U V} ↦ (f : X → Y)) 1) :
    LocallyCompactSpace (ContinuousMonoidHom X Y)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem max_self (a : Nat) : max a a = a
-- Mathlib/Analysis/Convex/Basic.lean
protected theorem starConvex (K : Submodule 𝕜 E) : StarConvex 𝕜 (0 : E) K
-- Mathlib/Algebra/Opposites.lean
@[to_additive (attr := simp, nolint simpComm)]
theorem unop_inj {x y : αᵐᵒᵖ} : unop x = unop y ↔ x = y
-- Mathlib/MeasureTheory/Measure/Dirac.lean
theorem mem_ae_dirac_iff {a : α} (hs : MeasurableSet s) : s ∈ ae (dirac a) ↔ a ∈ s
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem dist_eq_iSup : dist f g = ⨆ x : α, dist (f x) (g x)
-- Mathlib/Data/Set/Basic.lean
theorem setOf_or {p q : α → Prop} : { a | p a ∨ q a } = { a | p a } ∪ { a | q a }
-- Mathlib/Order/Heyting/Basic.lean
theorem hnot_le_hnot (h : a ≤ b) : ￢b ≤ ￢a
-- Mathlib/MeasureTheory/Order/Lattice.lean
/-- We say that a type has `MeasurableInf₂` if `uncurry (· ⊓ ·)` is a measurable functions.
For a typeclass assuming measurability of `(c ⊓ ·)` and `(· ⊓ c)` see `MeasurableInf`. -/
class MeasurableInf₂ (M : Type*) [MeasurableSpace M] [Inf M] : Prop where
  measurable_inf : Measurable fun p : M × M => p.1 ⊓ p.2
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
@[simp]
theorem map_id : pkg.map pkg id = id
-- Mathlib/CategoryTheory/GuitartExact/Basic.lean
@[ext]
lemma ext (w w' : TwoSquare T L R B) (h : ∀ (X : C₁), w.app X = w'.app X) :
    w = w'
-- Mathlib/Algebra/Homology/Additive.lean
theorem map_chain_complex_of (F : W₁ ⥤ W₂) [F.PreservesZeroMorphisms] (X : α → W₁)
    (d : ∀ n, X (n + 1) ⟶ X n) (sq : ∀ n, d (n + 1) ≫ d n = 0) :
    (F.mapHomologicalComplex _).obj (ChainComplex.of X d sq) =
      ChainComplex.of (fun n => F.obj (X n)) (fun n => F.map (d n)) fun n => by
        rw [← F.map_comp, sq n, Functor.map_zero]
-- Mathlib/Analysis/NormedSpace/Exponential.lean
/-- In a Banach-algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`, if `x` and `y` commute, then
`exp 𝕂 (x+y) = (exp 𝕂 x) * (exp 𝕂 y)`. -/
theorem exp_add_of_commute {x y : 𝔸} (hxy : Commute x y) : exp 𝕂 (x + y) = exp 𝕂 x * exp 𝕂 y
-- Mathlib/Order/RelIso/Basic.lean
@[simp]
theorem coe_trans (f : r ↪r s) (g : s ↪r t) : (f.trans g) = g ∘ f
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem AntitoneOn.monovaryOn (hf : AntitoneOn f s) (hg : AntitoneOn g s) :
    MonovaryOn f g s
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[mono]
theorem toSubmonoid_mono : Monotone (fun s : Subring R => s.toSubmonoid)
-- Mathlib/Analysis/Calculus/FDeriv/Symmetric.lean
/-- Assume that `f` is differentiable inside a convex set `s`, and that its derivative `f'` is
differentiable at a point `x`. Then, given two vectors `v` and `w` pointing inside `s`, one can
Taylor-expand to order two the function `f` on the segment `[x + h v, x + h (v + w)]`, giving a
bilinear estimate for `f (x + hv + hw) - f (x + hv)` in terms of `f' w` and of `f'' ⬝ w`, up to
`o(h^2)`.

This is a technical statement used to show that the second derivative is symmetric. -/
theorem Convex.taylor_approx_two_segment {v w : E} (hv : x + v ∈ interior s)
    (hw : x + v + w ∈ interior s) :
    (fun h : ℝ => f (x + h • v + h • w)
        - f (x + h • v) - h • f' x w - h ^ 2 • f'' v w - (h ^ 2 / 2) • f'' w w) =o[𝓝[>] 0]
      fun h => h ^ 2
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[ext]
theorem BinaryBiconeMorphism.ext {P Q : C} {c c' : BinaryBicone P Q}
    (f g : c ⟶ c') (w : f.hom = g.hom) : f = g
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- A coequalizer of an idempotent morphism and the identity is split epi. -/
@[simps]
def splitEpiOfIdempotentOfIsColimitCofork {X : C} {f : X ⟶ X} (hf : f ≫ f = f) {c : Cofork (𝟙 X) f}
    (i : IsColimit c) : SplitEpi c.π
-- Mathlib/CategoryTheory/Category/RelCat.lean
@[simp] theorem graphFunctor_map {X Y : Type u} (f : X ⟶ Y) (x : X) (y : Y) :
    graphFunctor.map f x y ↔ f x = y
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem inf_le_left {A : C} (f g : Subobject A) : (inf.obj f).obj g ≤ f
-- Mathlib/Data/List/Sublists.lean
theorem Pairwise.sublists' {R} :
    ∀ {l : List α}, Pairwise R l → Pairwise (Lex (swap R)) (sublists' l)
-- Mathlib/Data/Set/Card.lean
theorem Finite.encard_eq_coe (h : s.Finite) : s.encard = ENat.toNat s.encard
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem true_or (p : Prop) : (True ∨ p) = True
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
private lemma natDegree_coeff_preΨ' (n : ℕ) :
    (W.preΨ' n).natDegree ≤ expDegree n ∧ (W.preΨ' n).coeff (expDegree n) = expCoeff n
-- Mathlib/Algebra/Module/Equiv/Defs.lean
theorem symm_bijective [Module R M] [Module S M₂] [RingHomInvPair σ' σ] [RingHomInvPair σ σ'] :
    Function.Bijective (symm : (M ≃ₛₗ[σ] M₂) → M₂ ≃ₛₗ[σ'] M)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem mul_div_cancel (a) {b : Ordinal} (b0 : b ≠ 0) : b * a / b = a
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
/-- `CliffordAlgebra.involute` is analogous to `Complex.conj`. -/
@[simp]
theorem toComplex_involute (c : CliffordAlgebra Q) :
    toComplex (involute c) = conj (toComplex c)
-- Mathlib/CategoryTheory/Monoidal/Center.lean
/-- The functor lifting a braided category to its center, using the braiding as the half-braiding.
-/
@[simps]
def ofBraided : MonoidalFunctor C (Center C)
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem card_eq_nrRealPlaces_add_nrComplexPlaces :
    Fintype.card (InfinitePlace K) = NrRealPlaces K + NrComplexPlaces K
-- Mathlib/Data/List/InsertNth.lean
@[deprecated get_insertNth_of_lt (since := "2023-01-05")]
theorem nthLe_insertNth_of_lt : ∀ (l : List α) (x : α) (n k : ℕ), k < n → ∀ (hk : k < l.length)
    (hk' : k < (insertNth n x l).length := hk.trans_le (length_le_length_insertNth _ _ _)),
    (insertNth n x l).nthLe k hk' = l.nthLe k hk
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem lineMap_vadd (v v' : V₁) (p : P₁) (c : k) :
    lineMap v v' c +ᵥ p = lineMap (v +ᵥ p) (v' +ᵥ p) c
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem mapEmbedding_apply : mapEmbedding f s = map f s
-- Mathlib/Data/Matroid/IndepAxioms.lean
@[simp] theorem ofBdd_indep (E : Set α) Indep indep_empty indep_subset indep_aug
    subset_ground h_bdd : (IndepMatroid.ofBdd
      E Indep indep_empty indep_subset indep_aug subset_ground h_bdd).Indep = Indep
-- Mathlib/Analysis/Normed/Lp/LpEquiv.lean
theorem coe_algEquiv_lpBCF_symm (f : α →ᵇ A) : ((AlgEquiv.lpBCF α A 𝕜).symm f : α → A) = f
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem norm_lt_iff_of_nonempty [Nonempty α] {M : ℝ} : ‖f‖ < M ↔ ∀ x, ‖f x‖ < M
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp] theorem toZeroAtInfty_toBCF (f : 𝓢(E, F)) :
    f.toZeroAtInfty.toBCF = f.toBoundedContinuousFunction
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_iff_infinite_of_pos {x : ℝ*} (hp : 0 < x) : InfinitePos x ↔ Infinite x
-- Mathlib/Computability/Primrec.lean
theorem PrimrecPred.comp {p : β → Prop} [DecidablePred p] {f : α → β} :
    PrimrecPred p → Primrec f → PrimrecPred fun a => p (f a)
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_and {p q : Prop} {s : p ∧ q → α} : iInf s = ⨅ (h₁) (h₂), s ⟨h₁, h₂⟩
-- Mathlib/Topology/LocallyClosed.lean
lemma coborder_preimage (hf : IsOpenMap f) (hf' : Continuous f) (s : Set Y) :
    coborder (f ⁻¹' s) = f ⁻¹' (coborder s)
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma ofUnits_iSup {ι : Sort*} {f : ι → Subgroup Mˣ} :
    (iSup f).ofUnits = ⨆ (i : ι), (f i).ofUnits
-- Mathlib/Data/Finset/Grade.lean
@[simp] lemma val_covBy_val : s.1 ⋖ t.1 ↔ s ⋖ t
-- Mathlib/Analysis/SpecialFunctions/Stirling.lean
/-- **Stirling's Formula** -/
theorem tendsto_stirlingSeq_sqrt_pi : Tendsto stirlingSeq atTop (𝓝 (√π))
-- Mathlib/ModelTheory/Substructures.lean
/-- The preimage of a substructure along a homomorphism is a substructure. -/
@[simps]
def comap (φ : M →[L] N) (S : L.Substructure N) : L.Substructure M
-- Mathlib/Topology/Hom/Open.lean
theorem toFun_eq_coe {f : α →CO β} : f.toFun = (f : α → β)
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
theorem transReflReparamAux_one : transReflReparamAux 1 = 1
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive (attr := simp)]
lemma smul_assoc {M N} [SMul M N] [SMul N α] [SMul M α] [IsScalarTower M N α] (x : M) (y : N)
    (z : α) : (x • y) • z = x • y • z
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean
@[reassoc]
theorem hom_comp_map_image_ι {X Y : A} (f : X ⟶ Y) :
    (iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f)
-- Mathlib/LinearAlgebra/BilinearMap.lean
@[simp]
theorem lflip_apply (m : M) (n : N) : lflip f n m = f m n
-- Mathlib/Data/SetLike/Basic.lean
@[simp, norm_cast]
theorem coe_eq_coe {x y : p} : (x : B) = y ↔ x = y
-- Mathlib/Data/Nat/Log.lean
@[simp]
theorem clog_one_left (n : ℕ) : clog 1 n = 0
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
@[simp]
theorem walkingParallelPairHom_id (X : WalkingParallelPair) : WalkingParallelPairHom.id X = 𝟙 X
-- Mathlib/RingTheory/DedekindDomain/IntegralClosure.lean
/-- If `L` is a finite separable extension of `K = Frac(A)`, where `A` is a principal ring
and `L` has no zero smul divisors by `A`, the `A`-rank of the integral closure `C` of `A` in `L`
is equal to the `K`-rank of `L`. -/
theorem IsIntegralClosure.rank [IsPrincipalIdealRing A] [NoZeroSMulDivisors A L] :
    FiniteDimensional.finrank A C = FiniteDimensional.finrank K L
-- Mathlib/ModelTheory/Types.lean
theorem nonempty_iff : Nonempty (T.CompleteType α) ↔ T.IsSatisfiable
-- Mathlib/Analysis/Calculus/Implicit.lean
theorem implicitToPartialHomeomorphOfComplemented_apply (hf : HasStrictFDerivAt f f' a)
    (hf' : range f' = ⊤) (hker : (ker f').ClosedComplemented) (y : E) :
    hf.implicitToPartialHomeomorphOfComplemented f f' hf' hker y =
      (f y, Classical.choose hker (y - a))
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem coe_toConvexCone (S : Submodule 𝕜 E) : ↑S.toConvexCone = (S : Set E)
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
theorem coe_powers (x : M) : ↑(powers x) = Set.range fun n : ℕ => x ^ n
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem Coprime.pow_left (n : Nat) (H1 : Coprime m k) : Coprime (m ^ n) k
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem model_union_iff {T' : L.Theory} : M ⊨ T ∪ T' ↔ M ⊨ T ∧ M ⊨ T'
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem trans_one : e.trans (1 : E₂ ≃ₗᵢ[R₂] E₂) = e
-- Mathlib/Algebra/Module/Injective.lean
private theorem extensionOfMax_adjoin.aux1 {y : N} (x : supExtensionOfMaxSingleton i f y) :
    ∃ (a : (extensionOfMax i f).domain) (b : R), x.1 = a.1 + b • y
-- Mathlib/Data/Real/Hyperreal.lean
theorem InfiniteNeg.lt_zero {x : ℝ*} : InfiniteNeg x → x < 0
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
theorem finrank_eq_zero_of_not_exists_basis_finset (h : ¬∃ s : Finset M, Nonempty (Basis s R M)) :
    finrank R M = 0
-- Mathlib/CategoryTheory/Types.lean
@[simp]
theorem toIso_hom {e : X ≃ Y} : e.toIso.hom = e
-- Mathlib/Topology/Order/Hom/Basic.lean
@[simp]
theorem comp_apply (f : β →Co γ) (g : α →Co β) (a : α) : (f.comp g) a = f (g a)
-- Mathlib/Topology/FiberBundle/Constructions.lean
theorem Prod.right_inv {x : B × F₁ × F₂}
    (h : x ∈ (e₁.baseSet ∩ e₂.baseSet) ×ˢ (univ : Set (F₁ × F₂))) :
    Prod.toFun' e₁ e₂ (Prod.invFun' e₁ e₂ x) = x
-- Mathlib/Data/List/OfFn.lean
/-- This breaks a list of `m*n` items into `n` groups each containing `m` elements. -/
theorem ofFn_mul' {m n} (f : Fin (m * n) → α) :
    List.ofFn f = List.join (List.ofFn fun i : Fin n => List.ofFn fun j : Fin m => f ⟨m * i + j,
    calc
      m * i + j < m * (i + 1) :=
        (Nat.add_lt_add_left j.prop _).trans_eq (by rw [Nat.mul_add, Nat.mul_one])
      _ ≤ _ := Nat.mul_le_mul_left _ i.prop⟩)
-- Mathlib/Analysis/Normed/Group/Basic.lean
/-- A normed group is an additive group endowed with a norm for which `dist x y = ‖x - y‖` defines a
metric space structure. -/
class NormedAddGroup (E : Type*) extends Norm E, AddGroup E, MetricSpace E where
  dist := fun x y => ‖x - y‖
  /-- The distance function is induced by the norm. -/
  dist_eq : ∀ x y, dist x y = ‖x - y‖ := by aesop
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem const_apply (b : β) (a : α) : const α b a = b
-- Mathlib/GroupTheory/Submonoid/Inverses.lean
@[to_additive]
theorem leftInv_le_isUnit : S.leftInv ≤ IsUnit.submonoid M
-- Mathlib/Algebra/Order/Floor.lean
theorem lt_succ_floor (a : α) : a < ⌊a⌋.succ
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
@[simp]
theorem nondegenerate_congr_iff {B : BilinForm R M} (e : M ≃ₗ[R] M') :
    (congr e B).Nondegenerate ↔ B.Nondegenerate
-- Mathlib/Logic/Basic.lean
theorem xor_not_not : Xor' (¬a) (¬b) ↔ Xor' a b
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem lapply_comp_lsingle_same (a : α) : lapply a ∘ₗ lsingle a = (.id : M →ₗ[R] M)
-- Mathlib/Data/PEquiv.lean
theorem trans_single_of_eq_none {b : β} (c : γ) {f : δ ≃. β} (h : f.symm b = none) :
    f.trans (single b c) = ⊥
-- Mathlib/Topology/Homeomorph.lean
theorem image_frontier (h : X ≃ₜ Y) (s : Set X) : h '' frontier s = frontier (h '' s)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem aleph_pos (o : Ordinal) : 0 < aleph o
-- Mathlib/Topology/AlexandrovDiscrete.lean
lemma isClopen_iUnion (hf : ∀ i, IsClopen (f i)) : IsClopen (⋃ i, f i)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biprod.inr_map {W X Y Z : C} [HasBinaryBiproduct W X] [HasBinaryBiproduct Y Z] (f : W ⟶ Y)
    (g : X ⟶ Z) : biprod.inr ≫ biprod.map f g = g ≫ biprod.inr
-- Mathlib/CategoryTheory/Whiskering.lean
@[simp]
theorem whiskerRight_id' {G : C ⥤ D} (F : D ⥤ E) : whiskerRight (𝟙 G) F = 𝟙 (G.comp F)
-- Mathlib/CategoryTheory/Filtered/Basic.lean
/-- A category `IsCofiltered` if
1. for every pair of objects there exists another object "to the left",
2. for every pair of parallel morphisms there exists a morphism to the left so the compositions
   are equal, and
3. there exists some object.

See <https://stacks.math.columbia.edu/tag/04AZ>.
-/
class IsCofiltered extends IsCofilteredOrEmpty C : Prop where
  /-- a cofiltered category must be non empty -/
  [nonempty : Nonempty C]
-- Mathlib/RingTheory/Noetherian.lean
theorem isNoetherian_submodule_left {N : Submodule R M} :
    IsNoetherian R N ↔ ∀ s : Submodule R M, (N ⊓ s).FG
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem count_map_roots [IsDomain A] [DecidableEq B] {p : A[X]} {f : A →+* B} (hmap : map f p ≠ 0)
    (b : B) :
    (p.roots.map f).count b ≤ rootMultiplicity b (p.map f)
-- Mathlib/Algebra/Order/Floor.lean
theorem lt_of_lt_floor (h : n < ⌊a⌋₊) : ↑n < a
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem isIntegral_of_submodule_noetherian (S : Subalgebra R B)
    (H : IsNoetherian R (Subalgebra.toSubmodule S)) (x : B) (hx : x ∈ S) : IsIntegral R x
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Hard part of FTC-2 for integrable derivatives, real-valued functions: one has
`g b - g a ≤ ∫ y in a..b, g' y` when `g'` is integrable.
Auxiliary lemma in the proof of `integral_eq_sub_of_hasDeriv_right_of_le`.
We give the slightly more general version that `g b - g a ≤ ∫ y in a..b, φ y` when `g' ≤ φ` and
`φ` is integrable (even if `g'` is not known to be integrable).
Version assuming that `g` is differentiable on `(a, b)`. -/
theorem sub_le_integral_of_hasDeriv_right_of_le (hab : a ≤ b) (hcont : ContinuousOn g (Icc a b))
    (hderiv : ∀ x ∈ Ioo a b, HasDerivWithinAt g (g' x) (Ioi x) x) (φint : IntegrableOn φ (Icc a b))
    (hφg : ∀ x ∈ Ioo a b, g' x ≤ φ x) : g b - g a ≤ ∫ y in a..b, φ y
-- Mathlib/SetTheory/Game/Impartial.lean
theorem impartial_def {G : PGame} :
    G.Impartial ↔ (G ≈ -G) ∧ (∀ i, Impartial (G.moveLeft i)) ∧ ∀ j, Impartial (G.moveRight j)
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem Convex.quasiconcaveOn_of_convex_ge (hs : Convex 𝕜 s) (h : ∀ r, Convex 𝕜 { x | r ≤ f x }) :
    QuasiconcaveOn 𝕜 s f
-- Mathlib/Geometry/RingedSpace/PresheafedSpace.lean
@[simp]
theorem mapPresheaf_map_f (F : C ⥤ D) {X Y : PresheafedSpace C} (f : X ⟶ Y) :
    (F.mapPresheaf.map f).base = f.base
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem dropLast_nil : ([] : List α).dropLast = []
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem tan_add {x y : ℝ}
    (h : ((∀ k : ℤ, x ≠ (2 * k + 1) * π / 2) ∧ ∀ l : ℤ, y ≠ (2 * l + 1) * π / 2) ∨
      (∃ k : ℤ, x = (2 * k + 1) * π / 2) ∧ ∃ l : ℤ, y = (2 * l + 1) * π / 2) :
    tan (x + y) = (tan x + tan y) / (1 - tan x * tan y)
-- Mathlib/RingTheory/AdicCompletion/Exactness.lean
/-- Adic completion preserves injectivity of finite modules over a Noetherian ring. -/
theorem map_injective {f : M →ₗ[R] N} (hf : Function.Injective f) :
    Function.Injective (map I f)
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem iSup_apply {ι} (f : ι → OuterMeasure α) (s : Set α) : (⨆ i : ι, f i) s = ⨆ i, f i s
-- Mathlib/Computability/Language.lean
lemma reverse_involutive : Function.Involutive (reverse : Language α → _)
-- Mathlib/CategoryTheory/Monoidal/OfChosenFiniteProducts/Basic.lean
theorem tensor_comp {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁)
    (g₂ : Y₂ ⟶ Z₂) : tensorHom ℬ (f₁ ≫ g₁) (f₂ ≫ g₂) = tensorHom ℬ f₁ f₂ ≫ tensorHom ℬ g₁ g₂
-- Mathlib/Algebra/Star/SelfAdjoint.lean
/-- An element of a star monoid is normal if it commutes with its adjoint. -/
@[mk_iff]
class IsStarNormal [Mul R] [Star R] (x : R) : Prop where
  /-- A normal element of a star monoid commutes with its adjoint. -/
  star_comm_self : Commute (star x) x
-- Mathlib/Algebra/DirectSum/Ring.lean
/-- A graded version of `Semiring`. -/
class GSemiring [AddMonoid ι] [∀ i, AddCommMonoid (A i)] extends GNonUnitalNonAssocSemiring A,
  GradedMonoid.GMonoid A where
  /-- The canonical map from ℕ to the zeroth component of a graded semiring. -/
  natCast : ℕ → A 0
  /-- The canonical map from ℕ to a graded semiring respects zero. -/
  natCast_zero : natCast 0 = 0
  /-- The canonical map from ℕ to a graded semiring respects successors. -/
  natCast_succ : ∀ n : ℕ, natCast (n + 1) = natCast n + GradedMonoid.GOne.one
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioo_subset_Iic_self : Ioo a b ⊆ Iic b
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[to_additive]
theorem smul_opposite_image_mul_preimage' (g : G) (h : Gᵐᵒᵖ) (s : Set G) :
    (fun y => h • y) '' ((g * ·) ⁻¹' s) = (g * ·) ⁻¹' ((fun y => h • y) '' s)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem mem_sup : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x
-- Mathlib/Data/Finset/Powerset.lean
lemma powersetCard_empty_subsingleton (n : ℕ) :
    (powersetCard n (∅ : Finset α) : Set $ Finset α).Subsingleton
-- Mathlib/Data/Finset/Lattice.lean
theorem inf'_sup_inf' (f : ι → α) (g : κ → α) :
    s.inf' hs f ⊔ t.inf' ht g = (s ×ˢ t).inf' (hs.product ht) fun i => f i.1 ⊔ g i.2
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem ker_eq_bot_of_injective {f : F} (hf : Injective f) : ker f = ⊥
-- Mathlib/Analysis/Normed/Operator/Compact.lean
theorem isCompactOperator_iff_exists_mem_nhds_image_subset_compact (f : M₁ → M₂) :
    IsCompactOperator f ↔ ∃ V ∈ (𝓝 0 : Filter M₁), ∃ K : Set M₂, IsCompact K ∧ f '' V ⊆ K
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
theorem contractRight_algebraMap_mul (r : R) (b : CliffordAlgebra Q) :
    algebraMap _ _ r * b⌊d = algebraMap _ _ r * (b⌊d)
-- Mathlib/Order/Bounded.lean
theorem bounded_le_Iic [Preorder α] (a : α) : Bounded (· ≤ ·) (Iic a)
-- Mathlib/Analysis/Convex/Function.lean
theorem concaveOn_id {s : Set β} (hs : Convex 𝕜 s) : ConcaveOn 𝕜 s _root_.id
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_union_add_mk_inter {α : Type u} {S T : Set α} :
    #(S ∪ T : Set α) + #(S ∩ T : Set α) = #S + #T
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem localTrivAt_apply_mk (b : B) (a : F) : Z.localTrivAt b ⟨b, a⟩ = ⟨b, a⟩
-- Mathlib/RingTheory/Localization/Basic.lean
theorem neg_mk (a b) : -(mk a b : Localization M) = mk (-a) b
-- Mathlib/Dynamics/BirkhoffSum/NormedSpace.lean
/-- If `f : X → X` is a non-strictly contracting map (i.e., it is Lipschitz with constant `1`),
`g : X → E` is a uniformly continuous, and `l : X → E` is a continuous function,
then the set of points `x`
such that the Birkhoff average of `g` along the orbit of `x` tends to `l x`
is a closed set. -/
theorem isClosed_setOf_tendsto_birkhoffAverage
    (hf : LipschitzWith 1 f) (hg : UniformContinuous g) (hl : Continuous l) :
    IsClosed {x | Tendsto (birkhoffAverage 𝕜 f g · x) atTop (𝓝 (l x))}
-- Mathlib/Analysis/Normed/Group/Pointwise.lean
@[to_additive]
theorem ball_one_div_singleton : ball 1 δ / {x} = ball x⁻¹ δ
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_sq_eq_abs (x : ℝ) : √(x ^ 2) = |x|
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- Uniform convergence to a constant function is equivalent to convergence in `p ×ˢ ⊤`. -/
theorem tendsto_prod_top_iff {c : β} :
    Tendsto (↿F) (p ×ˢ ⊤) (𝓝 c) ↔ TendstoUniformly F (fun _ => c) p
-- Mathlib/Algebra/Module/LinearMap/End.lean
/-- See also `Module.End.intCast_def`. -/
@[simp]
theorem _root_.Module.End.intCast_apply (z : ℤ) (m : N₁) : (z : Module.End R N₁) m = z • m
-- Mathlib/Order/Monotone/Basic.lean
theorem Subtype.strictMono_coe [Preorder α] (t : Set α) :
    StrictMono ((↑) : Subtype t → α)
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
/-- The right_inv direction of the equivalence -/
theorem rowLens_ofRowLens_eq_self {w : List ℕ} {hw : w.Sorted (· ≥ ·)} (hpos : ∀ x ∈ w, 0 < x) :
    (ofRowLens w hw).rowLens = w
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- Given three points not equal to `p`, the angle between the second and the third at `p` plus
the angle between the first and the second equals the angle between the first and the third. -/
@[simp]
theorem oangle_add_swap {p p₁ p₂ p₃ : P} (hp₁ : p₁ ≠ p) (hp₂ : p₂ ≠ p) (hp₃ : p₃ ≠ p) :
    ∡ p₂ p p₃ + ∡ p₁ p p₂ = ∡ p₁ p p₃
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
@[simp]
theorem comp_val {X Y Z : LocallyRingedSpace.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).val = f.val ≫ g.val
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem mul_le_mul_of_mul_div_le (h : a * (b / c) ≤ d) (hc : 0 < c) : b * a ≤ d * c
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem insertNth_apply_above {i j : Fin (n + 1)} (h : i < j) (x : α i)
    (p : ∀ k, α (i.succAbove k)) :
    i.insertNth x p j = @Eq.recOn _ _ (fun x _ ↦ α x) _
    (succAbove_pred_of_lt _ _ h) (p <| j.pred _)
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
theorem c_eq_algebraMap : C σ R = algebraMap R (MvPowerSeries σ R)
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
theorem inf_apply [Inf β] (f g : α →ₛ β) (a : α) : (f ⊓ g) a = f a ⊓ g a