ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Convex/Function.lean
/-- A strictly concave function on an open segment is strictly lower-bounded by the min of its
endpoints. -/
theorem StrictConcaveOn.lt_on_open_segment' (hf : StrictConcaveOn 𝕜 s f) {x y : E} (hx : x ∈ s)
    (hy : y ∈ s) (hxy : x ≠ y) {a b : 𝕜} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
    min (f x) (f y) < f (a • x + b • y)
-- Mathlib/AlgebraicGeometry/Properties.lean
/-- A scheme `X` is integral if its is nonempty,
and `𝒪ₓ(U)` is an integral domain for each `U ≠ ∅`. -/
class IsIntegral : Prop where
  nonempty : Nonempty X := by infer_instance
  component_integral : ∀ (U : X.Opens) [Nonempty U], IsDomain Γ(X, U) := by infer_instance
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem compl_inter_self (s : Set α) : sᶜ ∩ s = ∅
-- Mathlib/CategoryTheory/Monoidal/Free/Coherence.lean
@[simp]
theorem normalizeObj_unitor (n : NormalMonoidalObject C) : normalizeObj (𝟙_ (F C)) n = n
-- Mathlib/Data/Int/Defs.lean
@[simp, norm_cast] lemma cast_id {n : ℤ} : Int.cast n = n
-- Mathlib/MeasureTheory/Measure/Complex.lean
theorem absolutelyContinuous_ennreal_iff (c : ComplexMeasure α) (μ : VectorMeasure α ℝ≥0∞) :
    c ≪ᵥ μ ↔ ComplexMeasure.re c ≪ᵥ μ ∧ ComplexMeasure.im c ≪ᵥ μ
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem eqToHom_left {X : T} {U V : Over X} (e : U = V) :
    (eqToHom e).left = eqToHom (e ▸ rfl : U.left = V.left)
-- Mathlib/LinearAlgebra/Determinant.lean
/-- Multiplying a map by a scalar `c` multiplies its determinant by `c ^ dim M`. -/
@[simp]
theorem det_smul {𝕜 : Type*} [Field 𝕜] {M : Type*} [AddCommGroup M] [Module 𝕜 M] (c : 𝕜)
    (f : M →ₗ[𝕜] M) :
    LinearMap.det (c • f) = c ^ FiniteDimensional.finrank 𝕜 M * LinearMap.det f
-- Mathlib/Data/List/NodupEquivFin.lean
/-- If there is `f`, an order-preserving embedding of `ℕ` into `ℕ` such that
any element of `l` found at index `ix` can be found at index `f ix` in `l'`,
then `Sublist l l'`.
-/
theorem sublist_of_orderEmbedding_get?_eq {l l' : List α} (f : ℕ ↪o ℕ)
    (hf : ∀ ix : ℕ, l.get? ix = l'.get? (f ix)) : l <+ l'
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem contDiffOn_congr (h₁ : ∀ x ∈ s, f₁ x = f x) : ContDiffOn 𝕜 n f₁ s ↔ ContDiffOn 𝕜 n f s
-- Mathlib/Algebra/Field/Basic.lean
theorem inv_add_inv (ha : a ≠ 0) (hb : b ≠ 0) : a⁻¹ + b⁻¹ = (a + b) / (a * b)
-- Mathlib/Algebra/Group/Nat.lean
lemma even_mul_succ_self (n : ℕ) : Even (n * (n + 1))
-- Mathlib/Analysis/Normed/Module/Ray.lean
theorem norm_injOn_ray_left (hx : x ≠ 0) : { y | SameRay ℝ x y }.InjOn norm
-- Mathlib/Topology/Instances/ENNReal.lean
@[continuity]
theorem continuous_pow (n : ℕ) : Continuous fun a : ℝ≥0∞ => a ^ n
-- Mathlib/Topology/Compactness/Compact.lean
/-- If `s : Set X` belongs to `𝓝 x ⊓ l` for all `x` from a compact set `K`,
then it belongs to `(𝓝ˢ K) ⊓ l`,
i.e., there exist an open `U ⊇ K` and `T ∈ l` such that `U ∩ T ⊆ s`. -/
theorem IsCompact.mem_nhdsSet_inf_of_forall {K : Set X} {l : Filter X} {s : Set X}
    (hK : IsCompact K) (hs : ∀ x ∈ K, s ∈ 𝓝 x ⊓ l) : s ∈ (𝓝ˢ K) ⊓ l
-- Mathlib/Data/Multiset/Basic.lean
theorem rel_flip {s t} : Rel (flip r) s t ↔ Rel r t s
-- Mathlib/Data/List/Sigma.lean
theorem lookupAll_eq_nil {a : α} :
    ∀ {l : List (Sigma β)}, lookupAll a l = [] ↔ ∀ b : β a, Sigma.mk a b ∉ l
-- Mathlib/RingTheory/Localization/Submodule.lean
@[mono]
theorem coeSubmodule_strictMono (h : M ≤ nonZeroDivisors R) :
    StrictMono (coeSubmodule S : Ideal R → Submodule R S)
-- Mathlib/Data/Nat/Cast/Synonym.lean
@[simp]
theorem ofLex_ofNat [NatCast α] (n : ℕ) [n.AtLeastTwo] :
    (ofLex (no_index (OfNat.ofNat n : Lex α))) = OfNat.ofNat n
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
theorem gcd_dvd_right (a b : R) : gcd a b ∣ b
-- Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean
@[simp]
theorem map_div₀ : f (a / b) = f a / f b
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem adj_getVert_succ {u v} (w : G.Walk u v) {i : ℕ} (hi : i < w.length) :
    G.Adj (w.getVert i) (w.getVert (i + 1))
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem Coloring.valid {v w : V} (h : G.Adj v w) : C v ≠ C w
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
/-- `∧` distributes over `∨` (on the left). -/
theorem and_or_left : a ∧ (b ∨ c) ↔ (a ∧ b) ∨ (a ∧ c)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pow_div {x m n : Nat} (h : n ≤ m) (hx : 0 < x) : x ^ m / x ^ n = x ^ (m - n)
-- Mathlib/Topology/Separation.lean
lemma compatible {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [T2Space Y]
    {f : X → Y} (hf : Continuous f) : letI _ := t2Setoid X
    ∀ (a b : X), a ≈ b → f a = f b
-- Mathlib/Data/Nat/Defs.lean
protected lemma pow_le_pow_iff_left {n : ℕ} (hn : n ≠ 0) : a ^ n ≤ b ^ n ↔ a ≤ b
-- Mathlib/AlgebraicGeometry/Gluing.lean
theorem hom_ext {Y : Scheme} (f₁ f₂ : X ⟶ Y) (h : ∀ x, 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂) : f₁ = f₂
-- Mathlib/SetTheory/Game/Basic.lean
/-- `x * y` is equivalent to `y * x`. -/
theorem mul_comm_equiv (x y : PGame) : x * y ≈ y * x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem and_lt_two_pow (x : Nat) {y n : Nat} (right : y < 2^n) : (x &&& y) < 2^n
-- Mathlib/RingTheory/Valuation/ValuationRing.lean
theorem iff_ideal_total : ValuationRing R ↔ IsTotal (Ideal R) (· ≤ ·)
-- Mathlib/Data/Num/Lemmas.lean
@[simp high, norm_cast]
theorem of_to_nat : ∀ n : PosNum, ((n : ℕ) : Num) = Num.pos n
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem infix_of_mem_join : ∀ {L : List (List α)}, l ∈ L → l <:+: join L
-- Mathlib/Topology/Constructions.lean
theorem closedEmbedding_inl : ClosedEmbedding (inl : X → X ⊕ Y)
-- Mathlib/RingTheory/Ideal/Pointwise.lean
theorem smul_sup (a : M) (S T : Ideal R) : a • (S ⊔ T) = a • S ⊔ a • T
-- Mathlib/Order/SemiconjSup.lean
theorem semiconj_of_isLUB [PartialOrder α] [Group G] (f₁ f₂ : G →* α ≃o α) {h : α → α}
    (H : ∀ x, IsLUB (range fun g' => (f₁ g')⁻¹ (f₂ g' x)) (h x)) (g : G) :
    Function.Semiconj h (f₂ g) (f₁ g)
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
protected theorem measurableSet_u {p : α × Set α} (hp : p ∈ h.index) :
    MeasurableSet (h.covering p)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_comp_star (hf : ContinuousOn f (star '' (σₙ R a)) := by cfc_cont_tac)
    (hf0 : f 0 = 0 := by cfc_zero_tac) (ha : p a := by cfc_tac) :
    cfcₙ (f <| star ·) a = cfcₙ f (star a)
-- Mathlib/LinearAlgebra/UnitaryGroup.lean
@[simp]
theorem toGL_mul (A B : unitaryGroup n α) : toGL (A * B) = toGL A * toGL B
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
theorem zero_of_nonpos (h : x ≤ 0) : smoothTransition x = 0
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The pigeonhole principle for finitely many pigeons of different weights, strict inequality
version: there is a pigeonhole with the total weight of pigeons in it greater than `b` provided that
the total number of pigeonholes times `b` is less than the total weight of all pigeons. -/
theorem exists_lt_sum_fiber_of_nsmul_lt_sum (hb : card β • b < ∑ x, w x) :
    ∃ y, b < ∑ x ∈ univ.filter fun x => f x = y, w x
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp] theorem coe_toOrderHom : ⇑f.toOrderHom = f
-- Mathlib/Algebra/Homology/ShortComplex/ShortExact.lean
lemma isIso₂_of_shortExact_of_isIso₁₃' [Balanced C] {S₁ S₂ : ShortComplex C} (φ : S₁ ⟶ S₂)
    (h₁ : S₁.ShortExact) (h₂ : S₂.ShortExact) (_ : IsIso φ.τ₁) (_ : IsIso φ.τ₃) : IsIso φ.τ₂
-- Mathlib/Data/NNRat/Defs.lean
@[simp, norm_cast, nolint simpNF]
theorem coe_max (x y : ℚ≥0) : ((max x y : ℚ≥0) : ℚ) = max (x : ℚ) (y : ℚ)
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem IsClosed.isLindelof [LindelofSpace X] (h : IsClosed s) : IsLindelof s
-- Mathlib/Data/ENNReal/Basic.lean
theorem exists_ne_top {p : ℝ≥0∞ → Prop} : (∃ a ≠ ∞, p a) ↔ ∃ r : ℝ≥0, p r
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem coLindelof_le_cofinite : coLindelof X ≤ cofinite
-- Mathlib/LinearAlgebra/Basis.lean
protected theorem noZeroSMulDivisors [NoZeroDivisors R] (b : Basis ι R M) :
    NoZeroSMulDivisors R M
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem tendsto_floor_right' (n : ℤ) : Tendsto (fun x => floor x : α → α) (𝓝[≥] n) (𝓝 n)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_dirac {a : α} (f : α → ℝ≥0∞) (s : Set α) [MeasurableSingletonClass α]
    [Decidable (a ∈ s)] : ∫⁻ x in s, f x ∂Measure.dirac a = if a ∈ s then f a else 0
-- Mathlib/Probability/Kernel/Composition.lean
/-- Lebesgue integral against the composition-product of two kernels. -/
theorem lintegral_compProd₀ (κ : Kernel α β) [IsSFiniteKernel κ] (η : Kernel (α × β) γ)
    [IsSFiniteKernel η] (a : α) {f : β × γ → ℝ≥0∞} (hf : AEMeasurable f ((κ ⊗ₖ η) a)) :
    ∫⁻ z, f z ∂(κ ⊗ₖ η) a = ∫⁻ x, ∫⁻ y, f (x, y) ∂η (a, x) ∂κ a
-- Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean
lemma isSheaf_coherent_of_hasPullbacks_comp [Preregular C] [FinitaryExtensive C]
    [h : ∀ {Y X : C} (f : Y ⟶ X) [EffectiveEpi f], HasPullback f f] [PreservesFiniteLimits s]
    (hF : IsSheaf (coherentTopology C) F) : IsSheaf (coherentTopology C) (F ⋙ s)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem IsZero.obj [HasZeroObject D] {F : C ⥤ D} (hF : IsZero F) (X : C) : IsZero (F.obj X)
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.inf_right' (h : Disjoint a b) : Disjoint a (c ⊓ b)
-- Mathlib/Algebra/Order/Pointwise.lean
theorem smul_Ico : r • Ico a b = Ico (r • a) (r • b)
-- Mathlib/Algebra/Homology/DerivedCategory/HomologySequence.lean
lemma exact₁ : (ShortComplex.mk _ _ (δ_comp T hT n₀ n₁ h)).Exact
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
/-- A version of `exists_ne_zero_mem_ideal_lt` for the ring of integers of `K`. -/
theorem exists_ne_zero_mem_ringOfIntegers_lt (h : minkowskiBound K ↑1 < volume (convexBodyLT K f)) :
    ∃ a : 𝓞 K, a ≠ 0 ∧ ∀ w : InfinitePlace K, w a < f w
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Increment.lean
theorem increment_isEquipartition : (increment hP G ε).IsEquipartition
-- Mathlib/Data/List/Nodup.lean
theorem nodup_iff_count_eq_one [DecidableEq α] : Nodup l ↔ ∀ a ∈ l, count a l = 1
-- Mathlib/Analysis/Fourier/AddCircle.lean
theorem fourierCoeff_toLp (n : ℤ) :
    fourierCoeff (toLp (E := ℂ) 2 haarAddCircle ℂ f) n = fourierCoeff f n
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
/-- If a topology `t'` is coarser than `t`, then any set `s` that is bounded with respect to
`t` is bounded with respect to `t'`. -/
theorem IsVonNBounded.of_topologicalSpace_le {t t' : TopologicalSpace E} (h : t ≤ t') {s : Set E}
    (hs : @IsVonNBounded 𝕜 E _ _ _ t s) : @IsVonNBounded 𝕜 E _ _ _ t' s
-- Mathlib/Analysis/Normed/Module/Complemented.lean
@[simp]
theorem coe_prodEquivOfClosedCompl_symm (h : IsCompl p q) (hp : IsClosed (p : Set E))
    (hq : IsClosed (q : Set E)) :
    ⇑(p.prodEquivOfClosedCompl q h hp hq).symm = (p.prodEquivOfIsCompl q h).symm
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem embedding_coeFn [UniformSpace F] [UniformAddGroup F] (𝔖 : Set (Set E)) :
    Embedding (X := UniformConvergenceCLM σ F 𝔖) (Y := E →ᵤ[𝔖] F)
      (UniformOnFun.ofFun 𝔖 ∘ DFunLike.coe)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_neg : cfc (fun x ↦ - (f x)) a = - (cfc f a)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioc_union_Icc_eq_Ioc (h₁ : a < b) (h₂ : b ≤ c) : Ioc a b ∪ Icc b c = Ioc a c
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_subtype_le_of_subset {α : Type u} {p q : α → Prop} (h : ∀ ⦃x⦄, p x → q x) :
    #(Subtype p) ≤ #(Subtype q)
-- Mathlib/Combinatorics/Colex.lean
/-- If `s ⊂ t`, then `s < t` in the colex order. Note the converse does not hold, as inclusion does
not form a linear order. -/
lemma toColex_strictMono : StrictMono (toColex : Finset α → Colex α)
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Iff.of_eq (h : a = b) : a ↔ b
-- Mathlib/Topology/Constructions.lean
/-- The composition of `Quotient.mk'` and a function with dense range has dense range. -/
theorem DenseRange.quotient [Setoid X] [TopologicalSpace X] {f : Y → X} (hf : DenseRange f) :
    DenseRange (Quotient.mk' ∘ f)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp, norm_cast]
theorem coe_sum {ι : Type*} (t : Finset ι) (f : ι → M₁ →SL[σ₁₂] M₂) :
    ↑(∑ d ∈ t, f d) = (∑ d ∈ t, f d : M₁ →ₛₗ[σ₁₂] M₂)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem baseChange_add : (f + g).baseChange A = f.baseChange A + g.baseChange A
-- Mathlib/Algebra/Group/Hom/End.lean
theorem AddMonoidHom.mul_apply (x y : R) : AddMonoidHom.mul x y = x * y
-- Mathlib/Data/ENNReal/Basic.lean
theorem range_coe : range ofNNReal = {∞}ᶜ
-- Mathlib/RingTheory/Ideal/Operations.lean
@[simp]
theorem sup_mul_left_self : I ⊔ J * I = I
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem mul_omega_opow_opow {a b : Ordinal} (a0 : 0 < a) (h : a < (omega^omega^b)) :
    a * (omega^omega^b) = (omega^omega^b)
-- Mathlib/Algebra/Polynomial/HasseDeriv.lean
theorem hasseDeriv_coeff (n : ℕ) :
    (hasseDeriv k f).coeff n = (n + k).choose k * f.coeff (n + k)
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem range_inr_union_range_inl : range (Sum.inr : β → α ⊕ β) ∪ range Sum.inl = univ
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- A uniform limit on a set of functions which are continuous on this set is itself continuous
on this set. -/
protected theorem TendstoUniformlyOn.continuousOn (h : TendstoUniformlyOn F f p s)
    (hc : ∀ᶠ n in p, ContinuousOn (F n) s) [NeBot p] : ContinuousOn f s
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem eq_zero_of_dvd_of_degree_lt {p q : R[X]} (h₁ : p ∣ q) (h₂ : degree q < degree p) :
    q = 0
-- Mathlib/Algebra/Order/Ring/Abs.lean
@[simp]
theorem dvd_abs (a b : α) : a ∣ |b| ↔ a ∣ b
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_one_nmul : ∀ a b, (a ♯ 1) ⨳ b = a ⨳ b ♯ b
-- Mathlib/Algebra/Algebra/Operations.lean
theorem map_unop_pow (n : ℕ) (M : Submodule R Aᵐᵒᵖ) :
    map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) (M ^ n) =
      map (↑(opLinearEquiv R : A ≃ₗ[R] Aᵐᵒᵖ).symm : Aᵐᵒᵖ →ₗ[R] A) M ^ n
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem coe_erase (l : List α) (a : α) : erase (l : Multiset α) a = l.erase a
-- Mathlib/Order/SuccPred/Basic.lean
theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a
-- Mathlib/GroupTheory/CosetCover.lean
@[to_additive]
theorem exists_finiteIndex_of_leftCoset_cover_aux [DecidableEq (Subgroup G)]
    (j : ι) (hj : j ∈ s) (hcovers' : ⋃ i ∈ s.filter (H · = H j), g i • (H i : Set G) ≠ Set.univ) :
    ∃ i ∈ s, H i ≠ H j ∧ (H i).FiniteIndex
-- Mathlib/Order/Monotone/Monovary.lean
@[simp]
theorem antivaryOn_univ : AntivaryOn f g univ ↔ Antivary f g
-- Mathlib/FieldTheory/Adjoin.lean
theorem exists_finset_of_mem_adjoin {S : Set E} {x : E} (hx : x ∈ adjoin F S) :
    ∃ T : Finset E, (T : Set E) ⊆ S ∧ x ∈ adjoin F (T : Set E)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_involution {s : Finset α} {f : α → β} :
    ∀ (g : ∀ a ∈ s, α) (_ : ∀ a ha, f a * f (g a ha) = 1) (_ : ∀ a ha, f a ≠ 1 → g a ha ≠ a)
      (g_mem : ∀ a ha, g a ha ∈ s) (_ : ∀ a ha, g (g a ha) (g_mem a ha) = a),
      ∏ x ∈ s, f x = 1
-- Mathlib/Analysis/Convex/Side.lean
theorem wOppSide_lineMap_right {s : AffineSubspace R P} {x : P} (y : P) (h : x ∈ s) {t : R}
    (ht : t ≤ 0) : s.WOppSide y (lineMap x y t)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.const_mul_right' {g : α → R} {u : Rˣ} {c' : ℝ} (hc' : 0 ≤ c')
    (h : IsBigOWith c' l f g) : IsBigOWith (c' * ‖(↑u⁻¹ : R)‖) l f fun x => ↑u * g x
-- Mathlib/Topology/UniformSpace/Cauchy.lean
@[simp]
theorem totallyBounded_empty : TotallyBounded (∅ : Set α)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformSpace.isOpen_ball (x : α) {V : Set (α × α)} (hV : IsOpen V) : IsOpen (ball x V)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma equiv_of_Z_eq_zero {P Q : Fin 3 → F} (hP : W.Nonsingular P) (hQ : W.Nonsingular Q)
    (hPz : P z = 0) (hQz : Q z = 0) : P ≈ Q
-- Mathlib/Analysis/Analytic/Basic.lean
theorem AnalyticAt.exists_mem_nhds_analyticOn {f : E → F} {x : E} (h : AnalyticAt 𝕜 f x) :
    ∃ s ∈ 𝓝 x, AnalyticOn 𝕜 f s
-- Mathlib/Order/BoundedOrder.lean
theorem eq_bot_mono (h : a ≤ b) (h₂ : b = ⊥) : a = ⊥
-- Mathlib/Topology/Category/TopCat/OpenNhds.lean
@[simp]
theorem map_obj (x : X) (U) (q) : (map f x).obj ⟨U, q⟩ = ⟨(Opens.map f).obj U, q⟩
-- Mathlib/Order/Filter/CardinalInter.lean
/-- Every filter is a CardinalInterFilter with c = aleph0 -/
theorem _root_.Filter.cardinalInterFilter_aleph0 (l : Filter α) : CardinalInterFilter l aleph0
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem tangentMapWithin_comp_at (p : TangentBundle I M)
    (hg : MDifferentiableWithinAt I' I'' g u (f p.1)) (hf : MDifferentiableWithinAt I I' f s p.1)
    (h : s ⊆ f ⁻¹' u) (hps : UniqueMDiffWithinAt I s p.1) :
    tangentMapWithin I I'' (g ∘ f) s p =
      tangentMapWithin I' I'' g u (tangentMapWithin I I' f s p)
-- Mathlib/Combinatorics/Additive/Corner/Roth.lean
/-- The **corners theorem** for `ℕ`.

The maximum density of a corner-free set in `{1, ..., n} × {1, ..., n}` goes to zero as `n` tends to
infinity. -/
theorem corners_theorem_nat (hε : 0 < ε) (hn : cornersTheoremBound (ε / 9) ≤ n)
    (A : Finset (ℕ × ℕ)) (hAn : A ⊆ range n ×ˢ range n) (hAε : ε * n ^ 2 ≤ A.card) :
    ¬ IsCornerFree (A : Set (ℕ × ℕ))
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_congr_set (h : s =ᵐ[μ] t) : μ.restrict s = μ.restrict t
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- `direction_of_nonempty` gives the same submodule as `direction`. -/
theorem directionOfNonempty_eq_direction {s : AffineSubspace k P} (h : (s : Set P).Nonempty) :
    directionOfNonempty h = s.direction
-- Mathlib/Algebra/Ring/Int.lean
lemma odd_add' : Odd (m + n) ↔ (Odd n ↔ Even m)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem sin_eq_neg_one_iff {x : ℝ} : sin x = -1 ↔ ∃ k : ℤ, -(π / 2) + k * (2 * π) = x
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem map_top (f : A →ₙₐ[R] B) : (⊤ : NonUnitalSubalgebra R A).map f = NonUnitalAlgHom.range f
-- Mathlib/Topology/Inseparable.lean
/-- The map `(x, y) ↦ (mk x, mk y)` is a quotient map. -/
theorem quotientMap_prodMap_mk : QuotientMap (Prod.map mk mk : X × Y → _)
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem smul_nil {i : Int} : i * ([] : IntList) = []
-- Mathlib/Algebra/SMulWithZero.lean
lemma Pi.single_apply_smul {ι : Type*} [DecidableEq ι] (x : M) (i j : ι) :
    (Pi.single i 1 : ι → R) j • x = (Pi.single i x : ι → M) j
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
@[simp]
theorem coe_add (f g : SlashInvariantForm Γ k) : ⇑(f + g) = f + g
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- The product of a function `g` defined only on a set `s` is equal to
the product of a function `f` defined everywhere,
as long as `f` and `g` agree on `s`, and `f = 1` off `s`. -/
@[to_additive "The sum of a function `g` defined only on a set `s` is equal to
the sum of a function `f` defined everywhere,
as long as `f` and `g` agree on `s`, and `f = 0` off `s`."]
theorem prod_congr_set {α : Type*} [CommMonoid α] {β : Type*} [Fintype β] (s : Set β)
    [DecidablePred (· ∈ s)] (f : β → α) (g : s → α) (w : ∀ (x : β) (h : x ∈ s), f x = g ⟨x, h⟩)
    (w' : ∀ x : β, x ∉ s → f x = 1) : Finset.univ.prod f = Finset.univ.prod g
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivComm_quotQuotMk (x : R) :
    quotQuotEquivComm I J (quotQuotMk I J x) = quotQuotMk J I x
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
theorem BinaryFan.IsLimit.hom_ext {W X Y : C} {s : BinaryFan X Y} (h : IsLimit s) {f g : W ⟶ s.pt}
    (h₁ : f ≫ s.fst = g ≫ s.fst) (h₂ : f ≫ s.snd = g ≫ s.snd) : f = g
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_left_comm : s ○ (t ○ u) = t ○ (s ○ u)
-- Mathlib/Tactic/Sat/FromLRAT.lean
/-- The reification of a negative literal `¬⟦¬a⟧_v ≡ a`. -/
theorem Literal.reify_neg {a : Prop} {n : ℕ} (h : v n ↔ a) : (Literal.neg n).reify v a
-- Mathlib/Data/Seq/Computation.lean
@[simp] lemma liftRelAux_inl_inr {a : α} {cb} :
    LiftRelAux R C (Sum.inl a) (Sum.inr cb) = ∃ b, b ∈ cb ∧ R a b
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt16.toNat_sub (x y : UInt16) :
    (x - y).toNat = (UInt16.size - y.toNat + x.toNat) % UInt16.size
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem dropWhile_replicate (p : α → Bool) :
    (replicate n a).dropWhile p = if p a then [] else replicate n a
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem colimit_sound {j j' : J} {x : F.obj j} {x' : F.obj j'} (f : j ⟶ j')
    (w : F.map f x = x') : colimit.ι F j x = colimit.ι F j' x'
-- Mathlib/Data/Int/Defs.lean
lemma pred_nat_succ (n : ℕ) : pred (Nat.succ n) = n
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.to_image_id' (h : l.HasBasis p s) : l.HasBasis (fun t ↦ ∃ i, p i ∧ s i = t) id
-- Mathlib/Topology/UniformSpace/Cauchy.lean
lemma CompleteSpace.fst_of_prod [UniformSpace β] [CompleteSpace (α × β)] [h : Nonempty β] :
    CompleteSpace α
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[reassoc (attr := simp)]
theorem cokernel.condition : f ≫ cokernel.π f = 0
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_nonneg_iff : 0 ≤ a / b ↔ 0 ≤ a ∧ 0 ≤ b ∨ a ≤ 0 ∧ b ≤ 0
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem StrictMono.div_const {β : Type*} [Preorder β] {f : β → α} (hf : StrictMono f) {c : α}
    (hc : 0 < c) : StrictMono fun x => f x / c
-- Mathlib/Data/Nat/Defs.lean
lemma not_pos_pow_dvd : ∀ {a n : ℕ} (_ : 1 < a) (_ : 1 < n), ¬ a ^ n ∣ a
-- Mathlib/Algebra/TrivSqZeroExt.lean
/-- The canonical inclusion of rings `R → TrivSqZeroExt R M`. -/
@[simps apply]
def inlHom [Semiring R] [AddCommMonoid M] [Module R M] [Module Rᵐᵒᵖ M] : R →+* tsze R M
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem IsBaseChange.algHom_ext' [Module R Q] [IsScalarTower R S Q] (g₁ g₂ : N →ₗ[S] Q)
    (e : (g₁.restrictScalars R).comp f = (g₂.restrictScalars R).comp f) : g₁ = g₂
-- Mathlib/RingTheory/Idempotents.lean
theorem exists_isIdempotentElem_mul_eq_zero_of_ker_isNilpotent_aux
    (h : ∀ x ∈ RingHom.ker f, IsNilpotent x)
    (e₁ : S) (he : e₁ ∈ f.range) (he₁ : IsIdempotentElem e₁)
    (e₂ : R) (he₂ : IsIdempotentElem e₂) (he₁e₂ : e₁ * f e₂ = 0) :
    ∃ e' : R, IsIdempotentElem e' ∧ f e' = e₁ ∧ e' * e₂ = 0
-- Mathlib/Algebra/Category/Ring/Basic.lean
theorem CommRingCat.ringHom_comp_eq_comp {R S T : Type _} [CommRing R] [CommRing S] [CommRing T]
    (f : R →+* S) (g : S →+* T) : g.comp f = CommRingCat.ofHom f ≫ CommRingCat.ofHom g
-- Mathlib/Data/Sym/Basic.lean
theorem cons_swap (a b : α) (s : Sym α n) : a ::ₛ b ::ₛ s = b ::ₛ a ::ₛ s
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem le_ωSup_of_le {c : Chain α} {x : α} (i : ℕ) (h : x ≤ c i) : x ≤ ωSup c
-- Mathlib/Data/Ordmap/Ordset.lean
theorem all_balanceR {P l x r} (hl : Balanced l) (hr : Balanced r) (sl : Sized l) (sr : Sized r)
    (H :
      (∃ l', Raised (size l) l' ∧ BalancedSz l' (size r)) ∨
        ∃ r', Raised r' (size r) ∧ BalancedSz (size l) r') :
    All P (@balanceR α l x r) ↔ All P l ∧ P x ∧ All P r
-- Mathlib/Order/Interval/Set/Monotone.lean
theorem iUnion_Ioo_of_mono_of_isGLB_of_isLUB (hf : Antitone f) (hg : Monotone g)
    (ha : IsGLB (range f) a) (hb : IsLUB (range g) b) : ⋃ x, Ioo (f x) (g x) = Ioo a b
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem integrable_of_forall_fin_meas_le [SigmaFinite μ] (C : ℝ≥0∞) (hC : C < ∞) {f : α → E}
    (hf_meas : AEStronglyMeasurable f μ)
    (hf : ∀ s : Set α, MeasurableSet[m] s → μ s ≠ ∞ → (∫⁻ x in s, ‖f x‖₊ ∂μ) ≤ C) :
    Integrable f μ
-- Mathlib/Combinatorics/SimpleGraph/Operations.lean
theorem edgeSet_replaceVertex_of_not_adj (hn : ¬G.Adj s t) : (G.replaceVertex s t).edgeSet =
    G.edgeSet \ G.incidenceSet t ∪ (s(·, t)) '' (G.neighborSet s)
-- Mathlib/Topology/Sets/Order.lean
/-- The type of clopen upper sets of a topological space. -/
structure ClopenUpperSet (α : Type*) [TopologicalSpace α] [LE α] extends Clopens α where
  upper' : IsUpperSet carrier
-- Mathlib/CategoryTheory/Sites/Whiskering.lean
/-- Composing a functor which `HasSheafCompose`, yields a functor between sheaf categories. -/
@[simps]
def sheafCompose : Sheaf J A ⥤ Sheaf J B