ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
/-- Uniform converence implies pointwise convergence. -/
theorem TendstoUniformlyOnFilter.tendsto_at (h : TendstoUniformlyOnFilter F f p p')
    (hx : 𝓟 {x} ≤ p') : Tendsto (fun n => F n x) p <| 𝓝 (f x)
-- Mathlib/LinearAlgebra/Span.lean
theorem span_singleton_sup_ker_eq_top (f : V →ₗ[K] K) {x : V} (hx : f x ≠ 0) :
    (K ∙ x) ⊔ ker f = ⊤
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictMono.mapsTo_Iio (h : StrictMono f) : MapsTo f (Iio b) (Iio (f b))
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem wittStructureInt_existsUnique (Φ : MvPolynomial idx ℤ) :
    ∃! φ : ℕ → MvPolynomial (idx × ℕ) ℤ,
      ∀ n : ℕ,
        bind₁ φ (wittPolynomial p ℤ n) = bind₁ (fun i : idx => rename (Prod.mk i) (W_ ℤ n)) Φ
-- Mathlib/Data/Seq/Seq.lean
@[ext]
protected theorem ext {s t : Seq α} (h : ∀ n : ℕ, s.get? n = t.get? n) : s = t
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem Measurable.nnreal_tsum {ι} [Countable ι] {f : ι → α → ℝ≥0} (h : ∀ i, Measurable (f i)) :
    Measurable fun x => ∑' i, f i x
-- Mathlib/Order/Basic.lean
lemma ltByCases_not_gt (h : ¬ y < x) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P}
    (p : ¬ x < y → x = y := fun h' => (le_antisymm (le_of_not_gt h) (le_of_not_gt h'))) :
    ltByCases x y h₁ h₂ h₃ = if h' : x < y then h₁ h' else h₂ (p h')
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma exists_smul_eq_of_comap_eq [Algebra k K] [IsGalois k K] {w w' : InfinitePlace K}
    (h : w.comap (algebraMap k K) = w'.comap (algebraMap k K)) : ∃ σ : K ≃ₐ[k] K, σ • w = w'
-- Mathlib/Topology/UniformSpace/Compact.lean
/-- A continuous family of functions `α → β → γ` tends uniformly to its value at `x`
if `α` is weakly locally compact and `β` is compact. -/
theorem Continuous.tendstoUniformly [WeaklyLocallyCompactSpace α] [CompactSpace β] [UniformSpace γ]
    (f : α → β → γ) (h : Continuous ↿f) (x : α) : TendstoUniformly f (f x) (𝓝 x)
-- Mathlib/FieldTheory/IsAlgClosed/Classification.lean
/-- Two uncountable algebraically closed fields are isomorphic
if they have the same cardinality and the same characteristic. -/
theorem ringEquivOfCardinalEqOfCharEq (p : ℕ) [CharP K p] [CharP L p] (hK : ℵ₀ < #K)
    (hKL : #K = #L) : Nonempty (K ≃+* L)
-- Mathlib/ModelTheory/Satisfiability.lean
/-- Any theory with an infinite model has arbitrarily large models. -/
theorem exists_large_model_of_infinite_model (T : L.Theory) (κ : Cardinal.{w}) (M : Type w')
    [L.Structure M] [M ⊨ T] [Infinite M] :
    ∃ N : ModelType.{_, _, max u v w} T, Cardinal.lift.{max u v w} κ ≤ #N
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
@[simp]
lemma opMap_id : opMap (𝟙 S) = 𝟙 S.op
-- Mathlib/Order/Filter/Basic.lean
theorem _root_.Function.Commute.filter_comap {f g : α → α} (h : Function.Commute f g) :
    Function.Commute (comap f) (comap g)
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem lex_wf (ha : WellFounded r) (hb : WellFounded s) : WellFounded (Lex r s)
-- Mathlib/Order/Filter/Pi.lean
@[simp]
theorem pi_inf_principal_pi_eq_bot [∀ i, NeBot (f i)] {I : Set ι} :
    pi f ⊓ 𝓟 (Set.pi I s) = ⊥ ↔ ∃ i ∈ I, f i ⊓ 𝓟 (s i) = ⊥
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- Mapping a set of reals along a line segment scales the measure by the length of a segment.

This is an auxiliary result used to prove `hausdorffMeasure_affineSegment`. -/
theorem hausdorffMeasure_lineMap_image (x y : P) (s : Set ℝ) :
    μH[1] (AffineMap.lineMap x y '' s) = nndist x y • μH[1] s
-- Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
compactly-supported function `u` on a normed space `E` of finite dimension `n ≥ 2`, equipped
with Haar measure. Then the `Lᵖ` norm of `u`, where `p := n / (n - 1)`, is bounded above by
a constant times the `L¹` norm of the Fréchet derivative of `u`. -/
theorem eLpNorm_le_eLpNorm_fderiv_one  {u : E → F} (hu : ContDiff ℝ 1 u) (h2u : HasCompactSupport u)
    {p : ℝ≥0} (hp : NNReal.IsConjExponent (finrank ℝ E) p) :
    eLpNorm u p μ ≤ eLpNormLESNormFDerivOneConst μ p * eLpNorm (fderiv ℝ u) 1 μ
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem eq_of_cmp_eq : ∀ {o₁ o₂}, cmp o₁ o₂ = Ordering.eq → o₁ = o₂
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem div_lt_floor {x : ℝ} (hx : 2 / (1 - 2 / exp 1) ≤ x) : x / exp 1 < (⌊x / 2⌋₊ : ℝ)
-- Mathlib/Probability/Process/PartitionFiltration.lean
lemma measurable_countableFiltration_countablePartitionSet (α : Type*)
    [MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
    Measurable[countableFiltration α n] (countablePartitionSet n)
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem domDomCongr_smul {S : Type*} [Monoid S] [DistribMulAction S N] [SMulCommClass R S N]
    (σ : ι ≃ ι') (c : S) (f : M [⋀^ι]→ₗ[R] N) :
    (c • f).domDomCongr σ = c • f.domDomCongr σ
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem castAdd_castLT (m : Nat) (i : Fin (n + m)) (hi : i.val < n) :
    castAdd m (castLT i hi) = i
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem fderiv_inner_apply (hf : DifferentiableAt ℝ f x) (hg : DifferentiableAt ℝ g x) (y : G) :
    fderiv ℝ (fun t => ⟪f t, g t⟫) x y = ⟪f x, fderiv ℝ g x y⟫ + ⟪fderiv ℝ f x y, g x⟫
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- See also `finprod_mem_finset_product'`. -/
@[to_additive "See also `finsum_mem_finset_product'`."]
theorem finprod_mem_finset_product (s : Finset (α × β)) (f : α × β → M) :
    (∏ᶠ (ab) (_ : ab ∈ s), f ab) = ∏ᶠ (a) (b) (_ : (a, b) ∈ s), f (a, b)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem eq_true_or_eq_false_self : ∀(b : Bool), (b = true ∨ b = false) ↔ True
-- Mathlib/Order/Max.lean
theorem NoMaxOrder.not_acc [LT α] [NoMaxOrder α] (a : α) : ¬Acc (· > ·) a
-- Mathlib/Topology/Separation.lean
/-- To prove a function to a `T1Space` is continuous at some point `x`, it suffices to prove that
`f` admits *some* limit at `x`. -/
theorem continuousAt_of_tendsto_nhds [TopologicalSpace Y] [T1Space Y] {f : X → Y} {x : X} {y : Y}
    (h : Tendsto f (𝓝 x) (𝓝 y)) : ContinuousAt f x
-- Mathlib/Topology/UnitInterval.lean
theorem fract_mem (x : ℝ) : fract x ∈ I
-- Mathlib/Algebra/Field/Power.lean
theorem Odd.neg_zpow (h : Odd n) (a : α) : (-a) ^ n = -a ^ n
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem mkOfCompact_neg [CompactSpace α] (f : C(α, β)) : mkOfCompact (-f) = -mkOfCompact f
-- Mathlib/RingTheory/Localization/Basic.lean
theorem map_unique (j : S →+* Q) (hj : ∀ x : R, j (algebraMap R S x) = algebraMap P Q (g x)) :
    map Q g hy = j
-- Mathlib/Order/Interval/Finset/Box.lean
@[simp] lemma box_succ_union_prod (n : ℕ) :
    box (n + 1) ∪ Icc (-n : α) n = Icc (-n.succ : α) n.succ
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
/--
The closure of a singleton `{a}` in the upper set topology is the right-closed left-infinite
interval (-∞,a].
-/
@[simp] lemma closure_singleton {a : α} : closure {a} = Iic a
-- Mathlib/Data/Fin/Basic.lean
lemma castAdd_injective (m n : ℕ) : Injective (@Fin.castAdd m n)
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem thickenedIndicator_mono {δ₁ δ₂ : ℝ} (δ₁_pos : 0 < δ₁) (δ₂_pos : 0 < δ₂) (hle : δ₁ ≤ δ₂)
    (E : Set α) : ⇑(thickenedIndicator δ₁_pos E) ≤ thickenedIndicator δ₂_pos E
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem false_of_true_eq_false  (h : True = False) : False
-- Mathlib/Data/Set/Basic.lean
@[simp, mfld_simps]
theorem univ_inter (a : Set α) : univ ∩ a = a
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem le_sum_apply (f : ι → Measure α) (s : Set α) : ∑' i, f i s ≤ sum f s
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
@[simp]
theorem transpose_mem_iff : Aᵀ ∈ symplecticGroup l R ↔ A ∈ symplecticGroup l R
-- Mathlib/Logic/Function/Basic.lean
lemma FactorsThrough.extend_comp {g : α → γ} (e' : β → γ) (hf : FactorsThrough g f) :
    extend f g e' ∘ f = g
-- Mathlib/RingTheory/Coalgebra/Hom.lean
protected theorem congr_arg (φ : A →ₗc[R] B) {x y : A} (h : x = y) : φ x = φ y
-- Mathlib/Data/Set/Countable.lean
theorem countable_pi {π : α → Type*} [Finite α] {s : ∀ a, Set (π a)} (hs : ∀ a, (s a).Countable) :
    { f : ∀ a, π a | ∀ a, f a ∈ s a }.Countable
-- Mathlib/NumberTheory/DiophantineApproximation.lean
/-- The `(n+1)`th convergent of `ξ` is the `n`th convergent of `1/(fract ξ)`. -/
@[simp]
theorem convergent_succ (ξ : ℝ) (n : ℕ) :
    ξ.convergent (n + 1) = ⌊ξ⌋ + ((fract ξ)⁻¹.convergent n)⁻¹
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem mem_coe_iff {a : α} {l : List α} : a ∈ (↑l : Cycle α) ↔ a ∈ l
-- Mathlib/LinearAlgebra/Matrix/Symmetric.lean
@[simp]
theorem IsSymm.transpose {A : Matrix n n α} (h : A.IsSymm) : Aᵀ.IsSymm
-- Mathlib/Algebra/Polynomial/Taylor.lean
@[simp]
theorem taylor_monomial (i : ℕ) (k : R) : taylor r (monomial i k) = C k * (X + C r) ^ i
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
theorem zero_addString_eq (s : String) : (0 : Pos) + s = ⟨s.utf8ByteSize⟩
-- Mathlib/Analysis/Analytic/Basic.lean
/-- The partial sums of a formal multilinear series are continuous. -/
theorem partialSum_continuous (p : FormalMultilinearSeries 𝕜 E F) (n : ℕ) :
    Continuous (p.partialSum n)
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem uniformEmbedding_subtype_val {p : α → Prop} :
    UniformEmbedding (Subtype.val : Subtype p → α)
-- Mathlib/Data/Nat/Digits.lean
theorem getLast_digit_ne_zero (b : ℕ) {m : ℕ} (hm : m ≠ 0) :
    (digits b m).getLast (digits_ne_nil_iff_ne_zero.mpr hm) ≠ 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem sin_add_two_pi (x : ℝ) : sin (x + 2 * π) = sin x
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem homothety_one (c : P1) : homothety c (1 : k) = id k P1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_eq_cons {f : α → β} {l : List α} :
    map f l = b :: l₂ ↔ l.head?.map f = some b ∧ l.tail?.map (map f) = some l₂
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
theorem ι_mul_ι_comm_of_isOrtho {a b : M} (h : Q.IsOrtho a b) :
    ι Q a * ι Q b = -(ι Q b * ι Q a)
-- Mathlib/Topology/Support.lean
@[to_additive]
theorem exists_compact_iff_hasCompactMulSupport [R1Space α] :
    (∃ K : Set α, IsCompact K ∧ ∀ x, x ∉ K → f x = 1) ↔ HasCompactMulSupport f
-- Mathlib/Algebra/CharP/MixedCharZero.lean
/-- A ring is a `ℚ`-algebra iff it has equal characteristic zero. -/
theorem nonempty_algebraRat_iff :
    Nonempty (Algebra ℚ R) ↔ ∀ I : Ideal R, I ≠ ⊤ → CharZero (R ⧸ I)
-- Mathlib/AlgebraicGeometry/Noetherian.lean
/-- `R` is a Noetherian ring if and only if `Spec R` is a Noetherian scheme. -/
theorem isNoetherian_Spec {R : CommRingCat} :
    IsNoetherian (Spec R) ↔ IsNoetherianRing R
-- Mathlib/Data/List/InsertNth.lean
theorem insertNth_eraseIdx_of_ge :
    ∀ n m as,
      n < length as → n ≤ m → insertNth m a (as.eraseIdx n) = (as.insertNth (m + 1) a).eraseIdx n
-- Mathlib/Data/Rat/Init.lean
@[simp] lemma cast_eq_id : Rat.cast = id
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem frontier_thickening_disjoint (A : Set α) :
    Pairwise (Disjoint on fun r : ℝ => frontier (thickening r A))
-- Mathlib/Computability/Primrec.lean
theorem unpair₂ {n f} (hf : @Primrec' n f) : @Primrec' n fun v => (f v).unpair.2
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem exists_of_findSome?_eq_some {l : List α} {f : α → Option β} (w : l.findSome? f = some b) :
    ∃ a, a ∈ l ∧ f a = b
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem smul_mem_smul_iff {a : A} {s : R} {r : Rˣ} : r • s ∈ σ (r • a) ↔ s ∈ σ a
-- Mathlib/CategoryTheory/Sites/Coverage.lean
/--
The main theorem of this file: Given a coverage `K` on `C`,
a `Type*`-valued presheaf on `C` is a sheaf for `K` if and only if it is a sheaf for
the associated Grothendieck topology.
-/
theorem isSheaf_coverage (K : Coverage C) (P : Cᵒᵖ ⥤ Type*) :
    Presieve.IsSheaf (toGrothendieck _ K) P ↔
    (∀ {X : C} (R : Presieve X), R ∈ K X → Presieve.IsSheafFor P R)
-- Mathlib/Algebra/BigOperators/NatAntidiagonal.lean
theorem prod_antidiagonal_succ' {n : ℕ} {f : ℕ × ℕ → M} : (∏ p ∈ antidiagonal (n + 1), f p) =
    f (n + 1, 0) * ∏ p ∈ antidiagonal n, f (p.1, p.2 + 1)
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
theorem prodIsoProd_hom_apply {X Y : TopCat.{u}} (x : ↑ (X ⨯ Y)) :
    (prodIsoProd X Y).hom x = ((Limits.prod.fst : X ⨯ Y ⟶ _) x,
    (Limits.prod.snd : X ⨯ Y ⟶ _) x)
-- Mathlib/Computability/Reduce.lean
@[simp]
theorem ULower.down_computable {α} [Primcodable α] : (ULower.equiv α).Computable
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem Trivialization.contMDiffOn_iff {f : M → TotalSpace F E} {s : Set M}
    (he : MapsTo f s e.source) :
    ContMDiffOn IM (IB.prod 𝓘(𝕜, F)) n f s ↔
      ContMDiffOn IM IB n (fun x => (f x).proj) s ∧
      ContMDiffOn IM 𝓘(𝕜, F) n (fun x ↦ (e (f x)).2) s
-- Mathlib/Data/Finite/Basic.lean
theorem prod_right (α) [Finite (α × β)] [Nonempty α] : Finite β
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem lift_comp_coe : ZMod.lift n f ∘ ((↑) : ℤ → _) = f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem hasDerivAt_tan {x : ℝ} (h : cos x ≠ 0) : HasDerivAt tan (1 / cos x ^ 2) x
-- Mathlib/Data/Finset/Lattice.lean
/-- A version of `Finset.sup'_mono` acceptable for `@[gcongr]`.
Instead of deducing `s₂.Nonempty` from `s₁.Nonempty` and `s₁ ⊆ s₂`,
this version takes it as an argument. -/
@[gcongr]
lemma _root_.GCongr.finset_sup'_le {s₁ s₂ : Finset β} (h : s₁ ⊆ s₂)
    {h₁ : s₁.Nonempty} {h₂ : s₂.Nonempty} : s₁.sup' h₁ f ≤ s₂.sup' h₂ f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem differentiableAt_cosh : DifferentiableAt ℝ cosh x
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
@[simp]
theorem _root_.Prefunctor.map_reverse (φ : U ⥤q V) [φ.MapReverse]
    {u v : U} (e : u ⟶ v) : φ.map (reverse e) = reverse (φ.map e)
-- Mathlib/Tactic/Rify.lean
@[rify_simps] lemma ratCast_eq (a b : ℚ) : a = b ↔ (a : ℝ) = (b : ℝ)
-- Mathlib/Data/Matrix/Basic.lean
theorem dotProduct_comm [AddCommMonoid α] [CommSemigroup α] (v w : m → α) : v ⬝ᵥ w = w ⬝ᵥ v
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma isIso_fromOpcycles (hS : S.Exact) [Epi S.g] [S.HasRightHomology] :
    IsIso S.fromOpcycles
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem det_ne_zero_of_right_inverse [Nontrivial α] (h : A * B = 1) : A.det ≠ 0
-- Mathlib/LinearAlgebra/Ray.lean
theorem exists_pos_left_iff_sameRay (hx : x ≠ 0) (hy : y ≠ 0) :
    (∃ r : R, 0 < r ∧ r • x = y) ↔ SameRay R x y
-- Mathlib/Data/Finset/Lattice.lean
@[simp] theorem inf_biUnion [DecidableEq β] (s : Finset γ) (t : γ → Finset β) :
    (s.biUnion t).inf f = s.inf fun x => (t x).inf f
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
@[simp]
theorem coeff_exp : coeff A n (exp A) = algebraMap ℚ A (1 / n !)
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
@[simp]
theorem pullbackIsoPullback_inv_snd_apply (x : (Types.pullbackCone f g).pt) :
    (pullback.snd f g) ((pullbackIsoPullback f g).inv x) = (fun p => (p.1 : X × Y).snd) x
-- Mathlib/MeasureTheory/Order/Lattice.lean
@[measurability]
theorem Measurable.const_inf (hf : Measurable f) (c : M) : Measurable fun x => c ⊓ f x
-- Mathlib/Data/Fintype/Sum.lean
theorem image_subtype_ne_univ_eq_image_erase [Fintype α] [DecidableEq β] (k : β) (b : α → β) :
    image (fun i : { a // b a ≠ k } => b ↑i) univ = (image b univ).erase k
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem removeZero_of_pos (p : FormalMultilinearSeries 𝕜 E F) {n : ℕ} (h : 0 < n) :
    p.removeZero n = p n
-- Mathlib/Data/Fintype/Card.lean
theorem card_le_of_surjective (f : α → β) (h : Function.Surjective f) : card β ≤ card α
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Basic.lean
/-- For `x : A` which is invertible in `A`, the inverse lies in any unital C⋆-subalgebra `S`
containing `x`. -/
theorem StarSubalgebra.isUnit_coe_inv_mem {S : StarSubalgebra ℂ A} (hS : IsClosed (S : Set A))
    {x : A} (h : IsUnit x) (hxS : x ∈ S) : ↑h.unit⁻¹ ∈ S
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
@[ext]
theorem ext {p q : MulRingSeminorm R} : (∀ x, p x = q x) → p = q
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem constantCoeff_X : constantCoeff R X = 0
-- Mathlib/Algebra/Homology/Embedding/Boundary.lean
lemma boundaryGE {i' : ι'} {j : ι} (hj : c'.Rel i' (e.f j)) (hi' : ∀ i, e.f i ≠ i') :
    e.BoundaryGE j
-- Mathlib/Algebra/Group/AddChar.lean
@[simp] lemma compAddMonoidHom_apply (ψ : AddChar B M) (f : A →+ B)
    (a : A) : ψ.compAddMonoidHom f a = ψ (f a)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.iSup_lintegral_eq_of_countably_generated [Nonempty ι] [l.NeBot]
    [l.IsCountablyGenerated] {φ : ι → Set α} (hφ : AECover μ l φ) {f : α → ℝ≥0∞}
    (hfm : AEMeasurable f μ) : ⨆ i : ι, ∫⁻ x in φ i, f x ∂μ = ∫⁻ x, f x ∂μ
-- Mathlib/Order/Hom/CompleteLattice.lean
theorem map_iInf₂ [InfSet α] [InfSet β] [sInfHomClass F α β] (f : F) (g : ∀ i, κ i → α) :
    f (⨅ (i) (j), g i j) = ⨅ (i) (j), f (g i j)
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem opow_pos {a : Ordinal} (b : Ordinal) (a0 : 0 < a) : 0 < a ^ b
-- Mathlib/Topology/ContinuousFunction/ContinuousMapZero.lean
@[simp] lemma coe_zero [Zero R] : ⇑(0 : C(X, R)₀) = 0
-- Mathlib/Algebra/Order/Floor.lean
@[gcongr]
theorem ceil_le_ceil : ∀ x y : α, x ≤ y → ⌈x⌉ ≤ ⌈y⌉
-- Mathlib/Data/FunLike/Embedding.lean
@[simp]
theorem comp_injective {F : Sort*} [FunLike F β γ] [EmbeddingLike F β γ] (f : α → β) (e : F) :
    Function.Injective (e ∘ f) ↔ Function.Injective f
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
lemma le_induce_top_verts : G' ≤ (⊤ : G.Subgraph).induce G'.verts
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem shiftRight_negSucc (m n : ℕ) : -[m+1] >>> (n : ℤ) = -[m >>> n+1]
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
@[csimp] theorem inits_eq_initsTR : @inits = @initsTR
-- Mathlib/Order/Heyting/Basic.lean
theorem LE.le.codisjoint_hnot_right (h : b ≤ a) : Codisjoint a (￢b)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem Smooth.fst {f : N → M × M'} (hf : Smooth J (I.prod I') f) : Smooth J I fun x => (f x).1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getLast_cons' {a : α} {l : List α} : ∀ (h₁ : a :: l ≠ nil) (h₂ : l ≠ nil),
  getLast (a :: l) h₁ = getLast l h₂
-- Mathlib/CategoryTheory/Sites/Adjunction.lean
@[simp]
theorem adjunctionToTypes_counit_app_val {G : Type max v₁ u₁ ⥤ D} (adj : G ⊣ forget D)
    (X : Sheaf J D) :
    ((adjunctionToTypes J adj).counit.app X).val =
      sheafifyLift J ((Functor.associator _ _ _).hom ≫ (adj.whiskerRight _).counit.app _) X.2
-- Mathlib/Data/List/Cycle.lean
theorem Nodup.nontrivial_iff {s : Cycle α} (h : Nodup s) : Nontrivial s ↔ ¬Subsingleton s
-- Mathlib/Algebra/Polynomial/Mirror.lean
theorem mirror_mul_of_domain : (p * q).mirror = p.mirror * q.mirror
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[simp] lemma ofEpiOfIsIsoOfMono'_ι : (ofEpiOfIsIsoOfMono' φ h).ι = h.ι
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem destruct_think (s : WSeq α) : destruct (think s) = (destruct s).think
-- Mathlib/CategoryTheory/Comma/Over.lean
@[simp]
theorem map_obj_right : ((map f).obj U).right = U.right
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_le_coe {x y : ℝ} : (x : ℝ*) ≤ y ↔ x ≤ y
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioc_subset_Ioo_union_Icc : Ioc a c ⊆ Ioo a b ∪ Icc b c
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
theorem BinaryCofan.IsColimit.hom_ext {W X Y : C} {s : BinaryCofan X Y} (h : IsColimit s)
    {f g : s.pt ⟶ W} (h₁ : s.inl ≫ f = s.inl ≫ g) (h₂ : s.inr ≫ f = s.inr ≫ g) : f = g
-- Mathlib/MeasureTheory/Function/UnifTight.lean
/-- Bulk of the proof under strengthened hypotheses. Invoked from `tendsto_Lp_of_tendsto_ae`. -/
private theorem tendsto_Lp_of_tendsto_ae_of_meas (hp : 1 ≤ p) (hp' : p ≠ ∞)
    {f : ℕ → α → β} {g : α → β} (hf : ∀ n, StronglyMeasurable (f n)) (hg : StronglyMeasurable g)
    (hg' : Memℒp g p μ) (hui : UnifIntegrable f p μ) (hut : UnifTight f p μ)
    (hfg : ∀ᵐ x ∂μ, Tendsto (fun n => f n x) atTop (𝓝 (g x))) :
    Tendsto (fun n => eLpNorm (f n - g) p μ) atTop (𝓝 0)
-- Mathlib/CategoryTheory/Monoidal/Preadditive.lean
theorem tensor_add {W X Y Z : C} (f : W ⟶ X) (g h : Y ⟶ Z) : f ⊗ (g + h) = f ⊗ g + f ⊗ h
-- Mathlib/Algebra/DualNumber.lean
@[simp]
theorem inr_eq_smul_eps [MulZeroOneClass R] (r : R) : inr r = (r • ε : R[ε])
-- Mathlib/LinearAlgebra/Prod.lean
theorem inl_eq_prod : inl R M M₂ = prod LinearMap.id 0
-- Mathlib/Algebra/Ring/Idempotents.lean
@[simp]
theorem iff_eq_one {p : G} : IsIdempotentElem p ↔ p = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem mem_cons_self (a : α) (l : List α) : a ∈ a :: l
-- Mathlib/Data/Finset/Grade.lean
lemma _root_.CovBy.exists_finset_erase (h : s ⋖ t) : ∃ a ∈ t, t.erase a = s
-- Mathlib/LinearAlgebra/Semisimple.lean
theorem IsSemisimple.of_mem_adjoin_pair {a : End K M} (ha : a ∈ Algebra.adjoin K {f, g}) :
    a.IsSemisimple
-- Mathlib/Algebra/Quaternion.lean
theorem eq_re_of_eq_coe {a : ℍ[R]} {x : R} (h : a = x) : a = a.re
-- Mathlib/Init/Logic.lean
theorem and_true_iff : p ∧ True ↔ p
-- Mathlib/Logic/Basic.lean
theorem or_congr_left' {c a b : Prop} (h : ¬c → (a ↔ b)) : a ∨ c ↔ b ∨ c
-- Mathlib/Topology/Connected/Basic.lean
theorem isConnected_range [TopologicalSpace β] [ConnectedSpace α] {f : α → β} (h : Continuous f) :
    IsConnected (range f)
-- Mathlib/Logic/Basic.lean
theorem not_beq_of_ne {α : Type*} [BEq α] [LawfulBEq α] {a b : α} (ne : a ≠ b) : ¬(a == b)
-- Mathlib/Data/Fintype/Sort.lean
@[simp]
theorem finSumEquivOfFinset_inr (hm : s.card = m) (hn : sᶜ.card = n) (i : Fin n) :
    finSumEquivOfFinset hm hn (Sum.inr i) = sᶜ.orderEmbOfFin hn i
-- Mathlib/Analysis/Convex/Strong.lean
lemma strongConvexOn_iff_convex :
    StrongConvexOn s m f ↔ ConvexOn ℝ s fun x ↦ f x - m / (2 : ℝ) * ‖x‖ ^ 2
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- In a pseudometric space, the extended distance is always finite-/
theorem edist_ne_top (x y : α) : edist x y ≠ ⊤
-- Mathlib/Data/Matroid/Dual.lean
theorem Coindep.exists_base_subset_compl (h : M.Coindep X) : ∃ B, M.Base B ∧ B ⊆ M.E \ X
-- Mathlib/Order/Minimal.lean
theorem maximals_antichain : IsAntichain r (maximals r s)
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- A standard Borel space is a measurable space arising as the Borel sets of some Polish topology.
This is useful in situations where a space has no natural topology or
the natural topology in a space is non-Polish.

To endow a standard Borel space `α` with a compatible Polish topology, use
`letI := upgradeStandardBorel α`. One can then use `eq_borel_upgradeStandardBorel α` to
rewrite the `MeasurableSpace α` instance to `borel α t`, where `t` is the new topology. -/
class StandardBorelSpace [MeasurableSpace α] : Prop where
  /-- There exists a compatible Polish topology. -/
  polish : ∃ _ : TopologicalSpace α, BorelSpace α ∧ PolishSpace α
-- Mathlib/Data/Finsupp/NeLocus.lean
@[simp]
theorem neLocus_neg_neg : neLocus (-f) (-g) = f.neLocus g
-- Mathlib/Algebra/Algebra/Operations.lean
theorem singleton_smul (a : A) (M : Submodule R A) :
    Set.up ({a} : Set A) • M = M.map (LinearMap.mulLeft R a)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem Tendsto.prod_atBot [SemilatticeInf α] [SemilatticeInf γ] {f g : α → γ}
    (hf : Tendsto f atBot atBot) (hg : Tendsto g atBot atBot) :
    Tendsto (Prod.map f g) atBot atBot
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
@[measurability]
protected theorem MeasurableSet.iUnion [Countable ι] ⦃f : ι → Set α⦄
    (h : ∀ b, MeasurableSet (f b)) : MeasurableSet (⋃ b, f b)
-- Mathlib/Topology/Order/LocalExtr.lean
theorem Filter.EventuallyEq.isLocalMin_iff {f g : α → β} {a : α} (heq : f =ᶠ[𝓝 a] g) :
    IsLocalMin f a ↔ IsLocalMin g a
-- Mathlib/LinearAlgebra/Orientation.lean
/-- A module `M` over a linearly ordered commutative ring has precisely two "orientations" with
respect to an empty index type. (Note that these are only orientations of `M` of in the conventional
mathematical sense if `M` is zero-dimensional.) -/
theorem eq_or_eq_neg_of_isEmpty [IsEmpty ι] (o : Orientation R M ι) :
    o = positiveOrientation ∨ o = -positiveOrientation