ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/EqToHom.lean
@[simp]
theorem eqToHom_app {F G : C ⥤ D} (h : F = G) (X : C) :
    (eqToHom h : F ⟶ G).app X = eqToHom (Functor.congr_obj h X)
-- Mathlib/GroupTheory/CommutingProbability.lean
private lemma div_four_lt : {n : ℕ} → (h0 : n ≠ 0) → (h1 : n ≠ 1) → n / 4 + 1 < n
-- Mathlib/Topology/IsLocalHomeomorph.lean
/-- Proves that `f` satisfies `IsLocalHomeomorph f`. The condition `h` is weaker than the
definition of `IsLocalHomeomorph f`, since it only requires `e : PartialHomeomorph X Y` to
agree with `f` on its source `e.source`, as opposed to on the whole space `X`. -/
theorem mk (h : ∀ x : X, ∃ e : PartialHomeomorph X Y, x ∈ e.source ∧ Set.EqOn f e e.source) :
    IsLocalHomeomorph f
-- Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean
/-- The sum of two finite adèles is a finite adèle. -/
theorem add {x y : K_hat R K} (hx : x.IsFiniteAdele) (hy : y.IsFiniteAdele) :
    (x + y).IsFiniteAdele
-- Mathlib/Algebra/BigOperators/GroupWithZero/Finset.lean
lemma prod_boole : ∏ i, (ite (p i) 1 0 : M₀) = ite (∀ i, p i) 1 0
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_inf_sup (s : Finset ι) (t : Finset κ) (f : ι → α) (g : κ → α) :
    s.sup f ⊓ t.sup g = (s ×ˢ t).sup fun i => f i.1 ⊓ g i.2
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem extract : ∀ {s}, ValidFor l m r s → ValidFor ml mm mr ⟨⟨m⟩, b, e⟩ →
    ∃ l' r', ValidFor l' mm r' (s.extract b e)
-- Mathlib/Data/Finset/Piecewise.lean
@[simp]
lemma piecewise_empty [∀ i : ι, Decidable (i ∈ (∅ : Finset ι))] : piecewise ∅ f g = g
-- Mathlib/Data/Nat/Bitwise.lean
/-- Note that the LHS is the expression used within `Std.BitVec.append`, hence the name. -/
lemma append_lt {x y n m} (hx : x < 2 ^ n) (hy : y < 2 ^ m) : y <<< n ||| x < 2 ^ (n + m)
-- Mathlib/Data/NNReal/Basic.lean
nonrec theorem div_le_iff' {a b r : ℝ≥0} (hr : r ≠ 0) : a / r ≤ b ↔ a ≤ r * b
-- Mathlib/Analysis/Analytic/Basic.lean
theorem AnalyticAt.add (hf : AnalyticAt 𝕜 f x) (hg : AnalyticAt 𝕜 g x) : AnalyticAt 𝕜 (f + g) x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem_append (since := "2024-06-12")]
theorem get_append {l₁ l₂ : List α} (n : Nat) (h : n < l₁.length) :
    (l₁ ++ l₂).get ⟨n, length_append .. ▸ Nat.lt_add_right _ h⟩ = l₁.get ⟨n, h⟩
-- Mathlib/Topology/Order/Monotone.lean
/-- A monotone function `f` sending `bot` to `bot` and continuous at the supremum of a set sends
this supremum to the supremum of the image of this set. -/
theorem Monotone.map_sSup_of_continuousAt {f : α → β} {s : Set α} (Cf : ContinuousAt f (sSup s))
    (Mf : Monotone f) (fbot : f ⊥ = ⊥) : f (sSup s) = sSup (f '' s)
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem le_objs {S T : Subgroupoid C} (h : S ≤ T) : S.objs ⊆ T.objs
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem pow_mem_pow (ha : a ∈ s) : ∀ n : ℕ, a ^ n ∈ s ^ n
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma image_val_union : (↑(D ∪ E) : Set α) = ↑D ∪ ↑E
-- Mathlib/Data/Complex/Exponential.lean
@[simp]
theorem one_le_exp_iff {x : ℝ} : 1 ≤ exp x ↔ 0 ≤ x
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
@[simp]
theorem mul_lt_mul_left_of_neg [ExistsAddOfLE α] [PosMulStrictMono α]
    [CovariantClass α α (swap (· + ·)) (· < ·)] [ContravariantClass α α (swap (· + ·)) (· < ·)]
    {a b c : α} (h : c < 0) : c * a < c * b ↔ b < a
-- Mathlib/NumberTheory/FunctionField.lean
@[simp]
theorem inftyValuation.polynomial {p : Fq[X]} (hp : p ≠ 0) :
    inftyValuationDef Fq (algebraMap Fq[X] (RatFunc Fq) p) =
      Multiplicative.ofAdd (p.natDegree : ℤ)
-- Mathlib/Topology/MetricSpace/Contracting.lean
/-- If a map `f` is `ContractingWith K`, and `s` is a forward-invariant set, then
restriction of `f` to `s` is `ContractingWith K` as well. -/
theorem restrict (hf : ContractingWith K f) {s : Set α} (hs : MapsTo f s s) :
    ContractingWith K (hs.restrict f s s)
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp, norm_cast] lemma coe_mk (f : α → β) (hf) : ⇑(mk f hf) = f
-- Mathlib/Topology/Basic.lean
@[continuity, fun_prop]
theorem continuous_const : Continuous fun _ : X => y
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
@[simp] theorem map_inv_of_isOneCocycle {f : G → A} (hf : IsOneCocycle f) (g : G) :
    g • f g⁻¹ = - f g
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
lemma Measurable.not (hp : Measurable p) : Measurable (¬ p ·)
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem polar_sub_left (x x' y : M) : polar Q (x - x') y = polar Q x y - polar Q x' y
-- Mathlib/Data/Real/ConjExponents.lean
theorem inv_add_inv_conj_ennreal : (ENNReal.ofReal p)⁻¹ + (ENNReal.ofReal q)⁻¹ = 1
-- Mathlib/Data/Finset/Card.lean
theorem two_lt_card : 2 < s.card ↔ ∃ a ∈ s, ∃ b ∈ s, ∃ c ∈ s, a ≠ b ∧ a ≠ c ∧ b ≠ c
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem ofEq_rfl : ofEq p p rfl = LinearIsometryEquiv.refl R' p
-- Mathlib/Analysis/RCLike/Basic.lean
theorem normSq_sub (z w : K) : normSq (z - w) = normSq z + normSq w - 2 * re (z * conj w)
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp]
theorem coeff_comp_monomial (n : σ →₀ ℕ) : (coeff R n).comp (monomial R n) = LinearMap.id
-- Mathlib/Data/Finset/Lattice.lean
theorem le_max' (x) (H2 : x ∈ s) : x ≤ s.max' ⟨x, H2⟩
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem Filter.HasBasis.cauchySeq_iff {γ} [Nonempty β] [SemilatticeSup β] {u : β → α} {p : γ → Prop}
    {s : γ → Set (α × α)} (h : (𝓤 α).HasBasis p s) :
    CauchySeq u ↔ ∀ i, p i → ∃ N, ∀ m, N ≤ m → ∀ n, N ≤ n → (u m, u n) ∈ s i
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
@[simp]
theorem image_const_add_Icc : (fun x => a + x) '' Icc b c = Icc (a + b) (a + c)
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
/-- We say that a type has `MeasurableInv` if `x ↦ x⁻¹` is a measurable function. -/
@[to_additive]
class MeasurableInv (G : Type*) [Inv G] [MeasurableSpace G] : Prop where
  measurable_inv : Measurable (Inv.inv : G → G)
-- Mathlib/Algebra/Category/ModuleCat/Sheaf.lean
/-- The forget functor `SheafOfModules R ⥤ PresheafOfModules R.val` is fully faithful. -/
@[simps]
def fullyFaithfulForget : (forget.{v} R).FullyFaithful
-- Mathlib/Data/Rat/Floor.lean
@[simp, norm_cast]
theorem floor_cast (x : ℚ) : ⌊(x : α)⌋ = ⌊x⌋
-- Mathlib/RingTheory/Noetherian.lean
/-- Any surjective endomorphism of a Noetherian module is bijective. -/
theorem IsNoetherian.bijective_of_surjective_endomorphism (f : M →ₗ[R] M)
    (s : Surjective f) : Bijective f
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
/-- If the input vectors of `gramSchmidt` are linearly independent,
then the output vectors are non-zero. -/
theorem gramSchmidt_ne_zero {f : ι → E} (n : ι) (h₀ : LinearIndependent 𝕜 f) :
    gramSchmidt 𝕜 f n ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
@[simp]
theorem Real.Angle.expMapCircle_coe (x : ℝ) : Real.Angle.expMapCircle x = _root_.expMapCircle x
-- Mathlib/Data/Finset/Basic.lean
theorem disjoint_filter {s : Finset α} {p q : α → Prop} [DecidablePred p] [DecidablePred q] :
    Disjoint (s.filter p) (s.filter q) ↔ ∀ x ∈ s, p x → ¬q x
-- Mathlib/NumberTheory/Padics/Hensel.lean
private theorem soln_spec {ε : ℝ} (hε : ε > 0) :
    ∃ N : ℕ, ∀ {i : ℕ}, i ≥ N → ‖soln - newton_cau_seq hnorm i‖ < ε
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma rnDerivAux_le_one [IsFiniteKernel η] (hκη : κ ≤ η) {a : α} :
    rnDerivAux κ η a ≤ᵐ[η a] 1
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_zero_left (x : F) : ⟪0, x⟫ = 0
-- Mathlib/CategoryTheory/Limits/Constructions/Over/Products.lean
/-- Given all finite wide pullbacks in `C`, construct finite products in `C/B`. -/
theorem over_finiteProducts_of_finiteWidePullbacks [HasFiniteWidePullbacks C] {B : C} :
    HasFiniteProducts (Over B)
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
/-- Generalized eigenrange and generalized eigenspace for exponent `finrank K V` are disjoint. -/
theorem generalized_eigenvec_disjoint_range_ker [FiniteDimensional K V] (f : End K V) (μ : K) :
    Disjoint (f.genEigenrange μ (finrank K V))
      (f.genEigenspace μ (finrank K V))
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp, norm_cast] lemma coe_natCast (n : ℕ) : ((n : α) : WithTop α) = n
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem support_ofFintype : (ofFintype f h).support = Function.support f
-- Mathlib/Data/Set/Function.lean
theorem SurjOn.mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) (hf : SurjOn f s₁ t₂) : SurjOn f s₂ t₁
-- Mathlib/Topology/Compactness/Compact.lean
theorem finite_cover_nhds_interior [CompactSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
    ∃ t : Finset X, ⋃ x ∈ t, interior (U x) = univ
-- Mathlib/Order/Disjoint.lean
protected theorem isCompl_iff [BoundedOrder α] [BoundedOrder β] {x y : α × β} :
    IsCompl x y ↔ IsCompl x.1 y.1 ∧ IsCompl x.2 y.2
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivWithinAt.congr_mono (h : HasDerivWithinAt f f' s x) (ht : ∀ x ∈ t, f₁ x = f x)
    (hx : f₁ x = f x) (h₁ : t ⊆ s) : HasDerivWithinAt f₁ f' t x
-- Mathlib/Data/Finset/Sym.lean
@[simp]
theorem sym2_eq_empty : s.sym2 = ∅ ↔ s = ∅
-- .lake/packages/lean4/src/lean/Init/Classical.lean
@[simp] theorem not_imp : ¬(a → b) ↔ a ∧ ¬b
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The edist to a set and to its closure coincide -/
theorem infEdist_closure : infEdist x (closure s) = infEdist x s
-- Mathlib/Order/WellFounded.lean
/-- Let `r` be a relation on `α`, let `f : α → β` be a function, let `C : β → Prop`, and
let `bot : α`. This induction principle shows that `C (f bot)` holds, given that
* some `a` that is accessible by `r` satisfies `C (f a)`, and
* for each `b` such that `f b ≠ f bot` and `C (f b)` holds, there is `c`
  satisfying `r c b` and `C (f c)`. -/
theorem Acc.induction_bot' {α β} {r : α → α → Prop} {a bot : α} (ha : Acc r a) {C : β → Prop}
    {f : α → β} (ih : ∀ b, f b ≠ f bot → C (f b) → ∃ c, r c b ∧ C (f c)) : C (f a) → C (f bot)
-- Mathlib/CategoryTheory/Limits/IndYoneda.lean
@[reassoc (attr := simp)]
lemma coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π (i : I) :
    (coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ limit.π (F.op.comp coyoneda) ⟨i⟩
      = coyoneda.map (colimit.ι F i).op
-- Mathlib/Algebra/Ring/Defs.lean
@[to_additive]
theorem ite_mul {α} [Mul α] (P : Prop) [Decidable P] (a b c : α) :
    (if P then a else b) * c = if P then a * c else b * c
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean
theorem condexp_of_stronglyMeasurable (hm : m ≤ m0) [hμm : SigmaFinite (μ.trim hm)] {f : α → F'}
    (hf : StronglyMeasurable[m] f) (hfi : Integrable f μ) : μ[f|m] = f
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
theorem measurableSet_limsup {s : ℕ → Set α} (hs : ∀ n, MeasurableSet <| s n) :
    MeasurableSet <| Filter.limsup s Filter.atTop
-- Mathlib/Topology/Inseparable.lean
theorem IsClosed.continuous_piecewise_of_specializes [DecidablePred (· ∈ s)] (hs : IsClosed s)
    (hf : Continuous f) (hg : Continuous g) (hspec : ∀ x, g x ⤳ f x) :
    Continuous (s.piecewise f g)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/-- When `r < w`, we give a formula for `(x.rotateRight r).getLsb i`. -/
theorem getLsb_rotateLeft_of_le {x : BitVec w} {r i : Nat} (hr: r < w) :
    (x.rotateLeft r).getLsb i =
      cond (i < r)
      (x.getLsb (w - r + i))
      (decide (i < w) && x.getLsb (i - r))
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
theorem iSup_monotone' {α : Type*} (f : ℕ → α → ℝ≥0∞) (x : α) :
    Monotone fun n ↦ ⨆ (k) (_ : k ≤ n), f k x
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem map_map (S : NonUnitalSubalgebra R A) (g : B →ₙₐ[R] C) (f : A →ₙₐ[R] B) :
    (S.map f).map g = S.map (g.comp f)
-- Mathlib/MeasureTheory/Group/Action.lean
@[to_additive]
theorem NullMeasurableSet.smul {s} (hs : NullMeasurableSet s μ) (c : G) :
    NullMeasurableSet (c • s) μ
-- Mathlib/MeasureTheory/Function/AEMeasurableSequence.lean
theorem fun_prop_of_mem_aeSeqSet (hf : ∀ i, AEMeasurable (f i) μ) {x : α} (hx : x ∈ aeSeqSet hf p) :
    p x fun n => f n x
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_tProd_mk (l : List δ) : Measurable (@TProd.mk δ π l)
-- Mathlib/NumberTheory/FLT/Three.lean
/-- We have that `S.Solution'_descent.multiplicity < S.multiplicity`. -/
lemma Solution'_descent_multiplicity_lt :
    (Solution'_descent S).multiplicity < S.multiplicity
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. The minimum of an integrable function is smaller than its mean, while
avoiding a null set. -/
theorem exists_not_mem_null_le_average (hμ : μ ≠ 0) (hf : Integrable f μ) (hN : μ N = 0) :
    ∃ x, x ∉ N ∧ f x ≤ ⨍ a, f a ∂μ
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive]
theorem mul_assoc : ∀ a b c : G, a * b * c = a * (b * c)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- A function is `C^∞` on an open domain if and only if it is differentiable
there, and its derivative (formulated with `deriv`) is `C^∞`. -/
theorem contDiffOn_top_iff_deriv_of_isOpen (hs : IsOpen s₂) :
    ContDiffOn 𝕜 ∞ f₂ s₂ ↔ DifferentiableOn 𝕜 f₂ s₂ ∧ ContDiffOn 𝕜 ∞ (deriv f₂) s₂
-- Mathlib/Data/Rat/Lemmas.lean
@[simp]
theorem pnatDen_zero : (0 : ℚ).pnatDen = 1
-- Mathlib/Deprecated/Subring.lean
theorem exists_list_of_mem_closure {a : R} (h : a ∈ closure s) :
    ∃ L : List (List R), (∀ l ∈ L, ∀ x ∈ l, x ∈ s ∨ x = (-1 : R)) ∧ (L.map List.prod).sum = a
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem comp_left {X Y Z : CostructuredArrow S T} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).left = f.left ≫ g.left
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_eq_prod_plift_of_mulSupport_subset {f : α → M} {s : Finset (PLift α)}
    (hs : mulSupport (f ∘ PLift.down) ⊆ s) : ∏ᶠ i, f i = ∏ i ∈ s, f i.down
-- Mathlib/MeasureTheory/Integral/Bochner.lean
@[continuity]
theorem continuous_integral : Continuous fun f : α →₁[μ] E => integral f
-- Mathlib/Order/IsWellOrderLimitElement.lean
lemma IsWellOrderLimitElement.wellOrderSucc_lt {b : α} (hb : b < a) :
    wellOrderSucc b < a
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem eval_image_univ_pi (ht : (pi univ t).Nonempty) :
    (fun f : ∀ i, α i => f i) '' pi univ t = t i
-- Mathlib/Algebra/Group/Subgroup/MulOpposite.lean
@[to_additive]
theorem le_op_iff {S₁ : Subgroup Gᵐᵒᵖ} {S₂ : Subgroup G} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_lt_of_lt_div {a b c : Ordinal} : a < b / c → c * a < b
-- Mathlib/Order/Interval/Set/Monotone.lean
theorem antitone_Ioi : Antitone (Ioi : α → Set α)
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
theorem isBounded_range (f : C₀(α, β)) : IsBounded (range f)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem zero {m : MeasurableSpace α} (μ : Measure α) (hC : 0 ≤ C) :
    DominatedFinMeasAdditive μ (0 : Set α → β) C
-- Mathlib/Order/Interval/Set/OrdConnected.lean
@[simp]
lemma image_subtype_val_Icc {s : Set α} [OrdConnected s] (x y : s) :
    Subtype.val '' Icc x y = Icc x.1 y
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem isRelPrime_iff_no_prime_factors {a b : R} (ha : a ≠ 0) :
    IsRelPrime a b ↔ ∀ ⦃d⦄, d ∣ a → d ∣ b → ¬Prime d
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
theorem norm_subtypeL (K : Submodule 𝕜 E) [Nontrivial K] : ‖K.subtypeL‖ = 1
-- Mathlib/Analysis/Convex/Body.lean
@[simp, norm_cast]
theorem hausdorffEdist_coe : EMetric.hausdorffEdist (K : Set V) L = edist K L
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
@[simp]
theorem π_app_right (c : PullbackCone f g) : c.π.app WalkingCospan.right = c.snd
-- Mathlib/Algebra/Order/Floor.lean
theorem map_floor (f : F) (hf : StrictMono f) (a : α) : ⌊f a⌋₊ = ⌊a⌋₊
-- Mathlib/Data/Set/Functor.lean
@[simp]
theorem bind_def : s >>= f = ⋃ i ∈ s, f i
-- Mathlib/NumberTheory/Divisors.lean
theorem pos_of_mem_divisors {m : ℕ} (h : m ∈ n.divisors) : 0 < m
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- Postcomposing a cone by the composite natural transformation `α ≫ β` is the same as
postcomposing by `α` and then by `β`. -/
@[simps!]
def postcomposeComp {G H : J ⥤ C} (α : F ⟶ G) (β : G ⟶ H) :
    postcompose (α ≫ β) ≅ postcompose α ⋙ postcompose β
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem self_le_factorial : ∀ n : ℕ, n ≤ n !
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem toList_none (α : Type _) : (none : Option α).toList = []
-- Mathlib/Order/Filter/Prod.lean
theorem prod_pure_pure {a : α} {b : β} :
    (pure a : Filter α) ×ˢ (pure b : Filter β) = pure (a, b)
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
/-- The set of differentiability points of a function, with derivative in a given complete set,
is Borel-measurable. -/
theorem measurableSet_of_differentiableAt_of_isComplete {K : Set (E →L[𝕜] F)} (hK : IsComplete K) :
    MeasurableSet { x | DifferentiableAt 𝕜 f x ∧ fderiv 𝕜 f x ∈ K }
-- Mathlib/Topology/Basic.lean
theorem mem_closure_of_mem_closure_union (h : x ∈ closure (s₁ ∪ s₂))
    (h₁ : s₁ᶜ ∈ 𝓝 x) : x ∈ closure s₂
-- Mathlib/Data/Real/Pointwise.lean
theorem Real.iSup_mul_of_nonneg (ha : 0 ≤ r) (f : ι → ℝ) : (⨆ i, f i) * r = ⨆ i, f i * r
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.neg_part {f : α → ℝ} (hf : Integrable f μ) :
    Integrable (fun a => max (-f a) 0) μ
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem IsBaseChange.ofEquiv (e : M ≃ₗ[R] N) : IsBaseChange R e.toLinearMap
-- Mathlib/Order/Iterate.lean
theorem iterate_comp_le_of_le (hf : Monotone f) (H : f ∘ h ≤ h ∘ g) (n : ℕ) :
    f^[n] ∘ h ≤ h ∘ g^[n]
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
@[reassoc (attr := simp)]
theorem prodIsoProd_hom_fst (X Y : TopCat.{u}) :
    (prodIsoProd X Y).hom ≫ prodFst = Limits.prod.fst
-- Mathlib/Data/Int/ModEq.lean
@[simp]
theorem modEq_neg : a ≡ b [ZMOD -n] ↔ a ≡ b [ZMOD n]
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma homologyMap_neg : homologyMap (-φ) = -homologyMap φ
-- Mathlib/Analysis/Complex/LocallyUniformLimit.lean
theorem cderiv_eq_deriv (hU : IsOpen U) (hf : DifferentiableOn ℂ f U) (hr : 0 < r)
    (hzr : closedBall z r ⊆ U) : cderiv r f z = deriv f z
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
/-- The image presheaf of a morphism, whose components are the set-theoretic images. -/
@[simps]
def imagePresheaf (f : F' ⟶ F) : Subpresheaf F
-- Mathlib/LinearAlgebra/BilinearMap.lean
@[simp]
theorem compl₂_apply (g : Q →ₛₗ[σ₄₂] N) (m : M) (q : Q) : f.compl₂ g m q = f m (g q)
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
@[simp]
theorem seq_add (f : FreeAbelianGroup (α → β)) (x y : FreeAbelianGroup α) :
    f <*> x + y = (f <*> x) + (f <*> y)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem projRestricts_eq_id : ProjRestricts C (fun i (h : J i) ↦ h) = id
-- Mathlib/Topology/Instances/ENNReal.lean
lemma limsup_const_sub (F : Filter ι) [NeBot F] (f : ι → ℝ≥0∞)
    {c : ℝ≥0∞} (c_ne_top : c ≠ ∞) :
    Filter.limsup (fun i ↦ c - f i) F = c - Filter.liminf f F
-- Mathlib/Data/Sym/Basic.lean
theorem attach_map_coe (s : Sym α n) : s.attach.map (↑) = s
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem coe_zpow [DivInvMonoid β] (f : α →ₛ β) (z : ℤ) : ⇑(f ^ z) = (⇑f) ^ z
-- Mathlib/Topology/Algebra/InfiniteSum/GroupCompletion.lean
/-- A function `f` is summable in a uniform additive group `α` if and only if it is summable in
`Completion α` and its sum in `Completion α` lies in the range of `toCompl : α →+ Completion α`. -/
theorem summable_iff_summable_compl_and_tsum_mem (f : β → α) :
    Summable f ↔ Summable (toCompl ∘ f) ∧ ∑' i, toCompl (f i) ∈ Set.range toCompl
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem of_mem_support_derivative {p : R[X]} {n : ℕ} (h : n ∈ p.derivative.support) :
    n + 1 ∈ p.support
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasDerivAt.cpow (hf : HasDerivAt f f' x) (hg : HasDerivAt g g' x)
    (h0 : f x ∈ slitPlane) : HasDerivAt (fun x => f x ^ g x)
      (g x * f x ^ (g x - 1) * f' + f x ^ g x * Complex.log (f x) * g') x
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean
/-- A version of `exists_ne_zero_mem_ideal_lt` where the absolute value of the real part of `a` is
smaller than `1` at some fixed complex place. This is useful to ensure that `a` is not real. -/
theorem exists_ne_zero_mem_ideal_lt' (w₀ : {w : InfinitePlace K // IsComplex w})
    (h : minkowskiBound K I < volume (convexBodyLT' K f w₀)) :
    ∃ a ∈ (I : FractionalIdeal (𝓞 K)⁰ K), a ≠ 0 ∧ (∀ w : InfinitePlace K, w ≠ w₀ → w a < f w) ∧
      |(w₀.val.embedding a).re| < 1 ∧ |(w₀.val.embedding a).im| < (f w₀ : ℝ) ^ 2
-- Mathlib/Topology/Inseparable.lean
@[simp] theorem continuousWithinAt_lift₂ {f : X → Y → Z}
    {hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d}
    {s : Set (SeparationQuotient X × SeparationQuotient Y)} {x : X} {y : Y} :
    ContinuousWithinAt (uncurry <| lift₂ f hf) s (mk x, mk y) ↔
      ContinuousWithinAt (uncurry f) (Prod.map mk mk ⁻¹' s) (x, y)
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
theorem mem_map_of_mem (g : α → β) (h : a ∈ x) : g a ∈ Option.map g x
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem mul_continuousOn {f g : ℝ → A} (hf : IntervalIntegrable f μ a b)
    (hg : ContinuousOn g [[a, b]]) : IntervalIntegrable (fun x => f x * g x) μ a b
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@[fun_prop]
lemma continuous_toNNReal : Continuous (toNNReal (X := X))
-- Mathlib/Analysis/Analytic/Uniqueness.lean
/-- The *identity principle* for analytic functions: If two analytic functions on a normed space
coincide in a neighborhood of a point `z₀`, then they coincide everywhere.
For a one-dimensional version assuming only that the functions coincide at some points
arbitrarily close to `z₀`, see `eq_of_frequently_eq`. -/
theorem eq_of_eventuallyEq {f g : E → F} [PreconnectedSpace E] (hf : AnalyticOn 𝕜 f univ)
    (hg : AnalyticOn 𝕜 g univ) {z₀ : E} (hfg : f =ᶠ[𝓝 z₀] g) : f = g
-- Mathlib/Data/Matroid/Dual.lean
theorem Indep.ssubset_ground [h : RkPos M✶] (hI : M.Indep I) : I ⊂ M.E
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem mkOfClosure_sets {s : Set (Set α)} {hs : { t | MeasurableSet[generateFrom s] t } = s} :
    MeasurableSpace.mkOfClosure s hs = generateFrom s
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
theorem exists_root [IsAlgClosed k] (p : k[X]) (hp : p.degree ≠ 0) : ∃ x, IsRoot p x
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
lemma δ_shape (hnm : ¬ n + 1 = m) (z : Cochain F G n) : δ n m z = 0
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioc_union_Ioi (h : c ≤ max a b) : Ioc a b ∪ Ioi c = Ioi (min a c)
-- Mathlib/Analysis/Convex/Side.lean
theorem _root_.Function.Injective.sOppSide_map_iff {s : AffineSubspace R P} {x y : P}
    {f : P →ᵃ[R] P'} (hf : Function.Injective f) :
    (s.map f).SOppSide (f x) (f y) ↔ s.SOppSide x y
-- Mathlib/Data/List/Destutter.lean
@[simp]
theorem destutter_eq_self_iff : ∀ l : List α, l.destutter R = l ↔ l.Chain' R
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem val_add (a b : Fin n) : (a + b).val = (a.val + b.val) % n
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_restrict_of_ae {s : Set α} {p : α → Prop} (h : ∀ᵐ x ∂μ, p x) : ∀ᵐ x ∂μ.restrict s, p x
-- Mathlib/Order/Cover.lean
theorem WCovBy.le_of_lt (hab : a ⩿ b) (hcb : c < b) : c ≤ a
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
/-- The generalized index of the lattice generated by `I` in the lattice generated by
`𝓞 K` is equal to the norm of the ideal `I`. The result is stated in terms of base change
determinant and is the translation of `NumberField.det_basisOfFractionalIdeal_eq_absNorm` in
`ℝ^r₁ × ℂ^r₂`. This is useful, in particular, to prove that the family obtained from
the `ℤ`-basis of `I` is actually an `ℝ`-basis of `ℝ^r₁ × ℂ^r₂`, see
`fractionalIdealLatticeBasis`. -/
theorem det_basisOfFractionalIdeal_eq_norm
    (e : (ChooseBasisIndex ℤ (𝓞 K)) ≃ (ChooseBasisIndex ℤ I)) :
    |Basis.det (latticeBasis K) ((mixedEmbedding K ∘ (basisOfFractionalIdeal K I) ∘ e))| =
      FractionalIdeal.absNorm I.1