ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/LinearAlgebra/RootSystem/Basic.lean
/-- The bijection on the indexing set induced by reflection. -/
@[simps]
protected def equiv_of_mapsTo :
    ι ≃ ι
-- Mathlib/Order/Filter/Basic.lean
lemma compl_mem_comk {p : Set α → Prop} {he hmono hunion s} :
    sᶜ ∈ comk p he hmono hunion ↔ p s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Mod.lean
protected theorem lt_of_mul_lt_mul_left {a b c : Nat} (h : a * b < a * c) : b < c
-- Mathlib/Combinatorics/HalesJewett.lean
@[simp]
theorem horizontal_apply {α ι ι'} (l : Line α ι) (v : ι' → α) (x : α) :
    l.horizontal v x = Sum.elim (l x) v
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive]
theorem le_iff_exists_mul' : a ≤ b ↔ ∃ c, b = c * a
-- Mathlib/Algebra/Lie/Abelian.lean
@[norm_cast, simp]
theorem coe_maxTrivEquiv_apply (e : M ≃ₗ⁅R,L⁆ N) (m : maxTrivSubmodule R L M) :
    (maxTrivEquiv e m : N) = e ↑m
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem tsub_tsub_tsub_le_tsub : c - a - (c - b) ≤ b - a
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- The algebra of sets generated by `𝒜` contains `𝒜`. -/
theorem self_subset_generateSetAlgebra : 𝒜 ⊆ generateSetAlgebra 𝒜
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.imp_or [h : Decidable a] : (a → b ∨ c) ↔ (a → b) ∨ (a → c)
-- Mathlib/Order/Filter/Pointwise.lean
theorem pure_vsub_pure : (pure a : Filter β) -ᵥ pure b = (pure (a -ᵥ b) : Filter α)
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma mem_of_mem_val_ofUnits (S : Subgroup Mˣ) {y : Mˣ} (hy : (y : M) ∈ S.ofUnits) : y ∈ S
-- Mathlib/Order/Bounds/Basic.lean
theorem IsGLB.inter_Iic_of_mem [LinearOrder γ] {s : Set γ} {a b : γ} (ha : IsGLB s a) (hb : b ∈ s) :
    IsGLB (s ∩ Iic b) a
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
lemma contDiffOn_restrContDiff_target (f : PartialHomeomorph E F) (n : ℕ) :
    ContDiffOn 𝕜 n f.symm (f.restrContDiff 𝕜 n).target
-- Mathlib/Data/List/Indexes.lean
theorem foldrIdxSpec_cons (f : ℕ → α → β → β) (b a as start) :
    foldrIdxSpec f b (a :: as) start = f start a (foldrIdxSpec f b as (start + 1))
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
theorem exists_mem_closure_infDist_eq_dist [ProperSpace α] (hne : s.Nonempty) (x : α) :
    ∃ y ∈ closure s, infDist x s = dist x y
-- Mathlib/Data/Bool/Basic.lean
theorem exists_bool' {p : Bool → Prop} (b : Bool) : (∃ x, p x) ↔ p b ∨ p !b
-- Mathlib/Topology/MetricSpace/PiNat.lean
/-- If two points `x, y` coincide up to length `n`, and the longest common prefix of `x` with `s`
is strictly shorter than `n`, then the longest common prefix of `y` with `s` is the same, and both
cylinders of this length based at `x` and `y` coincide. -/
theorem cylinder_longestPrefix_eq_of_longestPrefix_lt_firstDiff {x y : ∀ n, E n}
    {s : Set (∀ n, E n)} (hs : IsClosed s) (hne : s.Nonempty)
    (H : longestPrefix x s < firstDiff x y) (xs : x ∉ s) (ys : y ∉ s) :
    cylinder x (longestPrefix x s) = cylinder y (longestPrefix y s)
-- Mathlib/Probability/Process/Adapted.lean
protected theorem smul [SMul ℝ β] [ContinuousSMul ℝ β] (c : ℝ) (hu : Adapted f u) :
    Adapted f (c • u)
-- Mathlib/RingTheory/DedekindDomain/Factorization.lean
/-- The multiplicity of `v` in `∏_v v^(val_v(I))` equals `val_v(I)`. -/
theorem finprod_count (I : Ideal R) (hI : I ≠ 0) : (Associates.mk v.asIdeal).count
    (Associates.mk (∏ᶠ v : HeightOneSpectrum R, v.maxPowDividing I)).factors =
    (Associates.mk v.asIdeal).count (Associates.mk I).factors
-- Mathlib/Data/List/Chain.lean
theorem Chain'.prefix (h : Chain' R l) (h' : l₁ <+: l) : Chain' R l₁
-- Mathlib/Algebra/Order/Interval/Multiset.lean
lemma map_add_left_Icc (a b c : α) : (Icc a b).map (c + ·) = Icc (c + a) (c + b)
-- Mathlib/Analysis/Fourier/FourierTransform.lean
/-- The uniform norm of the Fourier transform of `f` is bounded by the `L¹` norm of `f`. -/
theorem norm_fourierIntegral_le_integral_norm (e : AddChar 𝕜 𝕊) (μ : Measure 𝕜)
    (f : 𝕜 → E) (w : 𝕜) : ‖fourierIntegral e μ f w‖ ≤ ∫ x : 𝕜, ‖f x‖ ∂μ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] theorem succ_eq_add_one (n : Nat) : succ n = n + 1
-- Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean
@[simp]
theorem dirac_caratheodory (a : α) : (dirac a).caratheodory = ⊤
-- Mathlib/Data/List/AList.lean
protected theorem ext_iff {s t : AList β} : s = t ↔ s.entries = t.entries
-- Mathlib/Order/Sublattice.lean
@[simp] lemma mem_top (a : α) : a ∈ (⊤ : Sublattice α)
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
@[simp]
theorem mem_maxGenEigenspace (f : End R M) (μ : R) (m : M) :
    m ∈ f.maxGenEigenspace μ ↔ ∃ k : ℕ, ((f - μ • (1 : End R M)) ^ k) m = 0
-- Mathlib/Analysis/Normed/Operator/ContinuousLinearMap.lean
theorem ContinuousLinearEquiv.homothety_inverse (a : ℝ) (ha : 0 < a) (f : E ≃ₛₗ[σ] F) :
    (∀ x : E, ‖f x‖ = a * ‖x‖) → ∀ y : F, ‖f.symm y‖ = a⁻¹ * ‖y‖
-- Mathlib/Algebra/Module/Injective.lean
/-- If we view `M` as a submodule of `N` via the injective linear map `i : M ↪ N`, then a submodule
between `M` and `N` is a submodule `N'` of `N`. To prove Baer's criterion, we need to consider
pairs of `(N', f')` such that `M ≤ N' ≤ N` and `f'` extends `f`. -/
structure ExtensionOf extends LinearPMap R N Q where
  le : LinearMap.range i ≤ domain
  is_extension : ∀ m : M, f m = toLinearPMap ⟨i m, le ⟨m, rfl⟩⟩
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp]
lemma ι_appLE (V W e) :
    U.ι.appLE V W e =
      X.presheaf.map (homOfLE (x := U.ι ''ᵁ W) (Set.image_subset_iff.mpr ‹_›)).op
-- Mathlib/Data/Fin/Tuple/Curry.lean
@[simp low]
theorem curry_apply_succ {n : ℕ} {p : Fin (n + 1) → Type u} {τ : Type u}
    (f : ((i : Fin (n + 1)) → p i) → τ) (a : p 0) :
    curry f a = curry (f ∘ Fin.cons a)
-- Mathlib/Order/Ideal.lean
theorem isMaximal_iff_isCoatom : IsMaximal I ↔ IsCoatom I
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- Construct an augmented cosimplicial object in the opposite
category from an augmented simplicial object. -/
@[simps!]
def SimplicialObject.Augmented.rightOp (X : SimplicialObject.Augmented C) :
    CosimplicialObject.Augmented Cᵒᵖ
-- Mathlib/Topology/Algebra/UniformConvergence.lean
@[to_additive (attr := simp)]
lemma UniformFun.toFun_one [One β] : toFun (1 : α →ᵤ β) = 1
-- Mathlib/Topology/MetricSpace/MetricSeparated.lean
@[simp]
theorem finset_iUnion_right_iff {ι : Type*} {I : Finset ι} {s : Set X} {t : ι → Set X} :
    IsMetricSeparated s (⋃ i ∈ I, t i) ↔ ∀ i ∈ I, IsMetricSeparated s (t i)
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem eq_of_mem_support_single {b : Γ} (h : b ∈ support (single a r)) : b = a
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem mem_extChartAt_target (x : M) : extChartAt I x x ∈ (extChartAt I x).target
-- Mathlib/Algebra/Homology/ShortComplex/Ab.lean
lemma ab_exact_iff_ker_le_range : S.Exact ↔ S.g.ker ≤ S.f.range
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem coe_coeHom : (coeHom : NonemptyInterval α → Set α) = ((↑) : NonemptyInterval α → Set α)
-- Mathlib/Probability/Martingale/Basic.lean
theorem supermartingale_of_condexp_sub_nonneg_nat [IsFiniteMeasure μ] {f : ℕ → Ω → ℝ}
    (hadp : Adapted 𝒢 f) (hint : ∀ i, Integrable (f i) μ)
    (hf : ∀ i, 0 ≤ᵐ[μ] μ[f i - f (i + 1)|𝒢 i]) : Supermartingale f 𝒢 μ
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma toMvPolynomial_add (M N : Matrix m n R) :
    (M + N).toMvPolynomial = M.toMvPolynomial + N.toMvPolynomial
-- Mathlib/Algebra/Field/Basic.lean
theorem one_div_mul_add_mul_one_div_eq_one_div_add_one_div (ha : a ≠ 0) (hb : b ≠ 0) :
    1 / a * (a + b) * (1 / b) = 1 / a + 1 / b
-- Mathlib/Algebra/Algebra/Defs.lean
theorem algebraMap_eq_smul_one (r : R) : algebraMap R A r = r • (1 : A)
-- Mathlib/Data/List/OfFn.lean
/-- Lists are equivalent to the sigma type of tuples of a given length. -/
@[simps]
def equivSigmaTuple : List α ≃ Σn, Fin n → α
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
/-- The symbol `J(1 | b)` has the value `1`. -/
@[simp]
theorem one_left (b : ℕ) : J(1 | b) = 1
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/-- If a presieve `R` on `X` has a subsieve `S` such that:

* `P` is a sheaf for `S`.
* For every `f` in `R`, `P` is separated for the pullback of `S` along `f`,

then `P` is a sheaf for `R`.

This is closely related to [Elephant] C2.1.6(i).
-/
theorem isSheafFor_subsieve_aux (P : Cᵒᵖ ⥤ Type w) {S : Sieve X} {R : Presieve X}
    (h : (S : Presieve X) ≤ R) (hS : IsSheafFor P (S : Presieve X))
    (trans : ∀ ⦃Y⦄ ⦃f : Y ⟶ X⦄, R f → IsSeparatedFor P (S.pullback f : Presieve Y)) :
    IsSheafFor P R
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem and_self_left  : a ∧ (a ∧ b) ↔ a ∧ b
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
/-- Being integrally closed is preserved under algebra isomorphisms. -/
theorem AlgEquiv.isIntegrallyClosedIn (e : A ≃ₐ[R] B) :
    IsIntegrallyClosedIn R A ↔ IsIntegrallyClosedIn R B
-- Mathlib/CategoryTheory/Limits/Fubini.lean
@[simp, reassoc]
theorem limitUncurryIsoLimitCompLim_inv_π {j} {k} :
    (limitUncurryIsoLimitCompLim F).inv ≫ limit.π _ (j, k) =
      (limit.π _ j ≫ limit.π _ k : limit (_ ⋙ lim) ⟶ _)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
/-- `sinh` is strictly monotone. -/
theorem sinh_strictMono : StrictMono sinh
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem twoCoboundariesOfMemRange_apply {f : G × G → A} (h : f ∈ LinearMap.range (dOne A)) :
    (twoCoboundariesOfMemRange h).1.1 = f
-- Mathlib/AlgebraicGeometry/Limits.lean
@[simp]
lemma sigmaMk_mk (i) (x : f i) :
    sigmaMk f (.mk i x) = (Sigma.ι f i).1.base x
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive nndist_nnnorm_nnnorm_le]
theorem nndist_nnnorm_nnnorm_le' (a b : E) : nndist ‖a‖₊ ‖b‖₊ ≤ ‖a / b‖₊
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
protected theorem mul_dvd_mul {a b c d : Nat} : a ∣ b → c ∣ d → a * c ∣ b * d
-- Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean
/-- For maps between vector spaces, `mfderivWithin` and `fderivWithin` coincide -/
@[simp]
theorem mfderivWithin_eq_fderivWithin :
    mfderivWithin 𝓘(𝕜, E) 𝓘(𝕜, E') f s x = fderivWithin 𝕜 f s x
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[simp]
theorem aemeasurable_inv_iff₀ {G₀ : Type*} [GroupWithZero G₀] [MeasurableSpace G₀]
    [MeasurableInv G₀] {f : α → G₀} : AEMeasurable (fun x => (f x)⁻¹) μ ↔ AEMeasurable f μ
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem mem_filterAt_iff {x : α} {s : Set (Set α)} :
    s ∈ v.filterAt x ↔ ∃ ε > (0 : ℝ), ∀ a ∈ v.setsAt x, a ⊆ closedBall x ε → a ∈ s
-- Mathlib/Topology/ContinuousFunction/Basic.lean
/--
The obvious triangle induced by `QuotientMap.lift` commutes:
```
     g
  X --→ Z
  |   ↗
f |  / hf.lift g h
  v /
  Y
```
-/
@[simp]
theorem lift_comp : (hf.lift g h).comp f = g
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
@[reassoc]
theorem biproduct.map_matrix {f : J → C} {g : J → C} {h : K → C} (m : ∀ k, f k ⟶ g k)
    (n : ∀ j k, g j ⟶ h k) :
    biproduct.map m ≫ biproduct.matrix n = biproduct.matrix fun j k => m j ≫ n j k
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive Nat.Coprime.nsmul_right_bijective]
lemma Nat.Coprime.pow_left_bijective (hn : (Nat.card G).Coprime n) : Bijective (· ^ n : G → G)
-- Mathlib/Data/Sum/Order.lean
theorem inr_strictMono : StrictMono (toLex ∘ inr : β → α ⊕ₗ β)
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt16.val_val_eq_toNat (x : UInt16) : x.val.val = x.toNat
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_nonneg_of_neg_pi_div_two_le_of_le {x : ℝ} (hl : -(π / 2) ≤ x) (hu : x ≤ π / 2) :
    0 ≤ cos x
-- Mathlib/Data/Real/GoldenRatio.lean
theorem goldConj_ne_zero : ψ ≠ 0
-- Mathlib/Order/Monotone/Basic.lean
theorem antitone_iff_forall_lt : Antitone f ↔ ∀ ⦃a b⦄, a < b → f b ≤ f a
-- Mathlib/CategoryTheory/Comma/Arrow.lean
/-- The natural transformation from `leftFunc` to `rightFunc`, given by the arrow itself. -/
@[simps]
def leftToRight : (leftFunc : Arrow C ⥤ C) ⟶ rightFunc
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNormEssSup_le_of_ae_nnnorm_bound {f : α → F} {C : ℝ≥0} (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) :
    eLpNormEssSup f μ ≤ C
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
/-- Taking the multiequalizer over the multicospan index is equivalent to taking the equalizer over
the two morphisms `∏ᶜ I.left ⇉ ∏ᶜ I.right`. This is the diagram of the latter.
-/
@[simps!]
protected noncomputable def parallelPairDiagram
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem fst_one [One M] [One N] : (1 : M × N).1 = 1
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem Measurable.ennreal_ofReal {f : α → ℝ} (hf : Measurable f) :
    Measurable fun x => ENNReal.ofReal (f x)
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[to_additive Ici_add_Ioi_subset]
theorem Ici_mul_Ioi_subset' (a b : α) : Ici a * Ioi b ⊆ Ioi (a * b)
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem map_vsub (p1 p2 : P) : f.linearIsometry (p1 -ᵥ p2) = f p1 -ᵥ f p2
-- Mathlib/Data/Finsupp/Defs.lean
@[simp, norm_cast] lemma coe_add (f g : α →₀ M) : ⇑(f + g) = f + g
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma Y_eq_of_Y_ne {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q)
    (hx : P x * Q z ^ 2 = Q x * P z ^ 2) (hy : P y * Q z ^ 3 ≠ Q y * P z ^ 3) :
    P y * Q z ^ 3 = W.negY Q * P z ^ 3
-- Mathlib/CategoryTheory/CatCommSq.lean
/-- Vertical composition of 2-commutative squares -/
@[simps! iso'_hom_app iso'_inv_app]
def vComp (L₁ : C₁ ⥤ C₂) (L₂ : C₂ ⥤ C₃) (H₁ : C₁ ⥤ C₄) (H₂ : C₂ ⥤ C₅) (H₃ : C₃ ⥤ C₆)
    (R₁ : C₄ ⥤ C₅) (R₂ : C₅ ⥤ C₆) [CatCommSq H₁ L₁ R₁ H₂] [CatCommSq H₂ L₂ R₂ H₃] :
    CatCommSq H₁ (L₁ ⋙ L₂) (R₁ ⋙ R₂) H₃
-- Mathlib/CategoryTheory/Monoidal/Conv.lean
theorem one_eq : (1 : Conv M N) = M.counit ≫ N.one
-- Mathlib/Algebra/Group/Pi/Basic.lean
/-- On non-dependent functions, `Pi.mulSingle` can be expressed as an `ite` -/
@[to_additive "On non-dependent functions, `Pi.single` can be expressed as an `ite`"]
theorem mulSingle_apply [One β] (i : I) (x : β) (i' : I) :
    (mulSingle i x : I → β) i' = if i' = i then x else 1
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
theorem AEMeasurable.restrict (hfm : AEMeasurable f μ) {s} : AEMeasurable f (μ.restrict s)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem toSignedMeasure_smul (μ : Measure α) [IsFiniteMeasure μ] (r : ℝ≥0) :
    (r • μ).toSignedMeasure = r • μ.toSignedMeasure
-- Mathlib/Algebra/Polynomial/Derivation.lean
@[simp] lemma mkDerivationEquiv_symm_apply (D : Derivation R R[X] A) :
    (mkDerivationEquiv R).symm D = D X
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive (attr := simp)]
theorem mem_inf {p p' : Subsemigroup M} {x : M} : x ∈ p ⊓ p' ↔ x ∈ p ∧ x ∈ p'
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
@[simp]
theorem circleMap_zero_radius (c : ℂ) : circleMap c 0 = const ℝ c
-- Mathlib/Data/Set/Basic.lean
@[gcongr]
theorem diff_subset_diff_left {s₁ s₂ t : Set α} (h : s₁ ⊆ s₂) : s₁ \ t ⊆ s₂ \ t
-- Mathlib/Data/Set/Image.lean
@[simp]
theorem preimage_eq_univ_iff {f : α → β} {s} : f ⁻¹' s = univ ↔ range f ⊆ s
-- Mathlib/Algebra/Group/Units.lean
@[to_additive (attr := simp)]
theorem Units.val_mkOfMulEqOne [CommMonoid α] {a b : α} (h : a * b = 1) :
    (Units.mkOfMulEqOne a b h : α) = a
-- Mathlib/Analysis/Calculus/SmoothSeries.lean
/-- Consider a series of smooth functions, with summable uniform bounds on the successive
derivatives. Then the iterated derivative of the sum is the sum of the iterated derivative. -/
theorem iteratedFDeriv_tsum (hf : ∀ i, ContDiff 𝕜 N (f i))
    (hv : ∀ k : ℕ, (k : ℕ∞) ≤ N → Summable (v k))
    (h'f : ∀ (k : ℕ) (i : α) (x : E), (k : ℕ∞) ≤ N → ‖iteratedFDeriv 𝕜 k (f i) x‖ ≤ v k i) {k : ℕ}
    (hk : (k : ℕ∞) ≤ N) :
    (iteratedFDeriv 𝕜 k fun y => ∑' n, f n y) = fun x => ∑' n, iteratedFDeriv 𝕜 k (f n) x
-- Mathlib/Order/Partition/Finpartition.lean
lemma card_mod_card_parts_le : s.card % P.parts.card ≤ P.parts.card
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem nndist_div_right [DivInvMonoid M] [PseudoMetricSpace M] [IsometricSMul Mᵐᵒᵖ M]
    (a b c : M) : nndist (a / c) (b / c) = nndist a b
-- Mathlib/Data/Multiset/Basic.lean
theorem mem_map_of_mem (f : α → β) {a : α} {s : Multiset α} (h : a ∈ s) : f a ∈ map f s
-- Mathlib/Data/Real/EReal.lean
lemma div_lt_div_right_of_pos {a a' b : EReal} (h₁ : 0 < b) (h₂ : b ≠ ⊤)
    (h₃ : a < a') : a / b < a' / b
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean
lemma F_int_eq_of_mem_Icc (k : ℕ) {a : ℝ} (ha : a ∈ Icc 0 1) {t : ℝ} (ht : 0 < t) :
    F_int k a t = (F_nat k a t) + (F_nat k (1 - a) t)
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
/-- Naturality of the coprod_comparison morphism in both arguments. -/
@[reassoc]
theorem coprodComparison_natural (f : A ⟶ A') (g : B ⟶ B') :
    coprodComparison F A B ≫ F.map (coprod.map f g) =
      coprod.map (F.map f) (F.map g) ≫ coprodComparison F A' B'
-- .lake/packages/lean4/src/lean/lake/Lake/Util/Name.lean
@[simp] theorem isPrefixOf_self {n : Name} : n.isPrefixOf n
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem balanced_iUnion₂ {f : ∀ i, κ i → Set E} (h : ∀ i j, Balanced 𝕜 (f i j)) :
    Balanced 𝕜 (⋃ (i) (j), f i j)
-- Mathlib/Geometry/Manifold/Algebra/Monoid.lean
@[to_additive]
theorem contMDiffWithinAt_finset_prod' (h : ∀ i ∈ t, ContMDiffWithinAt I' I n (f i) s x) :
    ContMDiffWithinAt I' I n (∏ i ∈ t, f i) s x
-- Mathlib/Data/Stream/Init.lean
theorem cons_injective2 : Function.Injective2 (cons : α → Stream' α → Stream' α)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_predicate_algebraMap (r : R) : p (algebraMap R A r)
-- Mathlib/Data/Finset/Basic.lean
theorem union_comm (s₁ s₂ : Finset α) : s₁ ∪ s₂ = s₂ ∪ s₁
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
lemma groupCohomologyπ_comp_isoH1_hom  :
    groupCohomologyπ A 1 ≫ (isoH1 A).hom =
      (isoOneCocycles A).hom ≫ (shortComplexH1 A).moduleCatHomologyπ
-- Mathlib/Algebra/Star/Module.lean
/-- The decomposition of elements of a star module into their self- and skew-adjoint parts,
as a linear equivalence. -/
-- Porting note: This attribute causes a `timeout at 'whnf'`.
@[simps!]
def StarModule.decomposeProdAdjoint : A ≃ₗ[R] selfAdjoint A × skewAdjoint A
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem iInter_div_subset (s : ι → Set α) (t : Set α) : (⋂ i, s i) / t ⊆ ⋂ i, s i / t
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem intCast_apply [TopologicalAddGroup M] (z : ℤ) (m : M) : (↑z : M →L[R] M) m = z • m
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s
-- Mathlib/LinearAlgebra/Projectivization/Basic.lean
@[simp]
theorem mk'_eq_mk (v : { v : V // v ≠ 0 }) : mk' K v = mk K ↑v v.2
-- Mathlib/Order/Filter/EventuallyConst.lean
lemma comp₂ {g : α → γ} (hf : EventuallyConst f l) (op : β → γ → δ) (hg : EventuallyConst g l) :
    EventuallyConst (fun x ↦ op (f x) (g x)) l
-- Mathlib/SetTheory/Ordinal/Principal.lean
theorem add_absorp {a b c : Ordinal} (h₁ : a < (omega^b)) (h₂ : (omega^b) ≤ c) : a + c = c
-- Mathlib/Topology/DiscreteQuotient.lean
@[simp]
theorem map_proj (cond : LEComap f A B) (x : X) : map f cond (A.proj x) = B.proj (f x)
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
@[reassoc (attr := simp)]
lemma inrX_π (i : ι) :
    inrX K i ≫ (π K).f i = (biprod.desc (𝟙 _) (𝟙 K)).f i
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem op_inf (S₁ S₂ : Subring R) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op
-- Mathlib/Data/List/Permutation.lean
@[simp]
theorem permutationsAux_nil (is : List α) : permutationsAux [] is = []
-- Mathlib/Analysis/Convex/Segment.lean
theorem openSegment_subset_segment (x y : E) : openSegment 𝕜 x y ⊆ [x -[𝕜] y]
-- Mathlib/Analysis/Convex/Segment.lean
theorem mem_segment_iff_div :
    x ∈ [y -[𝕜] z] ↔
      ∃ a b : 𝕜, 0 ≤ a ∧ 0 ≤ b ∧ 0 < a + b ∧ (a / (a + b)) • y + (b / (a + b)) • z = x
-- Mathlib/CategoryTheory/Limits/EpiMono.lean
lemma epi_iff_isIso_inr (hc : IsColimit c) : Epi f ↔ IsIso c.inr
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurableSet_swap_iff {s : Set (α × β)} :
    MeasurableSet (Prod.swap ⁻¹' s) ↔ MeasurableSet s
-- Mathlib/Logic/Equiv/Fin.lean
theorem finRotate_last : finRotate (n + 1) (Fin.last _) = 0
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem msb_or {x y : BitVec w} : (x ||| y).msb = (x.msb || y.msb)
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem ae_le_trim_iff [LinearOrder γ] [TopologicalSpace γ] [OrderClosedTopology γ]
    [PseudoMetrizableSpace γ] (hm : m ≤ m0) {f g : β → γ} (hf : StronglyMeasurable[m] f)
    (hg : StronglyMeasurable[m] g) : f ≤ᵐ[μ.trim hm] g ↔ f ≤ᵐ[μ] g
-- Mathlib/RepresentationTheory/Action/Basic.lean
/-- Auxiliary definition for `functorCategoryEquivalence`. -/
@[simps!]
def unitIso : 𝟭 (Action V G) ≅ functor ⋙ inverse
-- Mathlib/RingTheory/PolynomialAlgebra.lean
theorem matPolyEquiv_coeff_apply_aux_1 (i j : n) (k : ℕ) (x : R) :
    matPolyEquiv (stdBasisMatrix i j <| monomial k x) = monomial k (stdBasisMatrix i j x)
-- Mathlib/GroupTheory/SchurZassenhaus.lean
/-- Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` -/
private theorem step0 : N ≠ ⊥
-- Mathlib/Topology/Bornology/Constructions.lean
theorem isBounded_prod_self : IsBounded (s ×ˢ s) ↔ IsBounded s
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuousOn_tsum {f : ι → α → ℝ≥0∞} (h : ∀ i, LowerSemicontinuousOn (f i) s) :
    LowerSemicontinuousOn (fun x' => ∑' i, f i x') s
-- Mathlib/Data/Matroid/Constructions.lean
theorem uniqueBaseOn_inter_basis (hI : I ⊆ E) (hX : X ⊆ E) :
    (uniqueBaseOn I E).Basis (X ∩ I) X
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem modifyNthTail_length (f : List α → List α) (H : ∀ l, length (f l) = length l) :
    ∀ n l, length (modifyNthTail f n l) = length l
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem denseEmbedding_coe [NoncompactSpace X] : DenseEmbedding ((↑) : X → OnePoint X)
-- Mathlib/NumberTheory/Divisors.lean
@[to_additive (attr := simp)]
theorem Prime.prod_properDivisors {α : Type*} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) :
    ∏ x ∈ p.properDivisors, f x = f 1
-- Mathlib/SetTheory/Ordinal/Exponential.lean
theorem opow_def (a b : Ordinal) :
    a ^ b = if a = 0 then 1 - b else limitRecOn b 1 (fun _ IH => IH * a) fun b _ => bsup.{u, u} b
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If a function admits a power series expansion on a disk, then it is continuous there. -/
protected theorem HasFPowerSeriesOnBall.continuousOn (hf : HasFPowerSeriesOnBall f p x r) :
    ContinuousOn f (EMetric.ball x r)
-- Mathlib/Combinatorics/Schnirelmann.lean
/-- The Schnirelmann density of a set not containing `1` is `0`. -/
lemma schnirelmannDensity_eq_zero_of_one_not_mem (h : 1 ∉ A) : schnirelmannDensity A = 0
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem natDegree_le_iff_coeff_eq_zero : p.natDegree ≤ n ↔ ∀ N : ℕ, n < N → p.coeff N = 0
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
/-- The homotopy equivalence from a short complex to itself that is induced
by the identity. -/
@[simps]
def refl (S : ShortComplex C) : HomotopyEquiv S S
-- Mathlib/Data/List/Basic.lean
/-- The original list `L` can be recovered by joining the lists produced by `splitOnP p L`,
interspersed with the elements `L.filter p`. -/
theorem splitOnP_spec (as : List α) :
    join (zipWith (· ++ ·) (splitOnP p as) (((as.filter p).map fun x => [x]) ++ [[]])) = as
-- Mathlib/Logic/Relation.lean
theorem Symmetric.swap_eq : Symmetric r → swap r = r
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The infimum edistance of a point to a set is positive if and only if the point is not in the
closure of the set. -/
theorem infEdist_pos_iff_not_mem_closure {x : α} {E : Set α} :
    0 < infEdist x E ↔ x ∉ closure E
-- .lake/packages/batteries/Batteries/Data/Char.lean
@[ext] theorem Char.ext : {a b : Char} → a.val = b.val → a = b
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- An isometry from a complete emetric space is a closed embedding -/
theorem closedEmbedding [CompleteSpace α] [EMetricSpace γ] {f : α → γ} (hf : Isometry f) :
    ClosedEmbedding f