ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Polynomial/Induction.lean
/-- To prove something about polynomials,
it suffices to show the condition is closed under taking sums,
and it holds for monomials.
-/
@[elab_as_elim]
protected theorem induction_on' {M : R[X] → Prop} (p : R[X]) (h_add : ∀ p q, M p → M q → M (p + q))
    (h_monomial : ∀ (n : ℕ) (a : R), M (monomial n a)) : M p
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp] lemma natDegree_X_mul (hp : p ≠ 0) : natDegree (X * p) = natDegree p + 1
-- Mathlib/Probability/Distributions/Gaussian.lean
/-- The gaussian distribution pdf integrates to 1 when the variance is not zero.  -/
lemma lintegral_gaussianPDFReal_eq_one (μ : ℝ) {v : ℝ≥0} (h : v ≠ 0) :
    ∫⁻ x, ENNReal.ofReal (gaussianPDFReal μ v x) = 1
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem conj_re (z : K) : re (conj z) = re z
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem add_one_pos (i : Fin (n + 1)) (h : i < Fin.last n) : (0 : Fin (n + 1)) < i + 1
-- Mathlib/Topology/Algebra/Order/Compact.lean
/-- This typeclass says that all closed intervals in `α` are compact. This is true for all
conditionally complete linear orders with order topology and products (finite or infinite)
of such spaces. -/
class CompactIccSpace (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  /-- A closed interval `Set.Icc a b` is a compact set for all `a` and `b`. -/
  isCompact_Icc : ∀ {a b : α}, IsCompact (Icc a b)
-- Mathlib/Algebra/QuaternionBasis.lean
@[simp]
theorem k_mul_j : q.k * q.j = c₂ • q.i
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem re_to_real {x : ℝ} : reR x = x
-- Mathlib/Order/ULift.lean
@[simp] theorem down_lt [LT α] {a b : ULift α} : down a < down b ↔ a < b
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
theorem row_eq_prod {μ : YoungDiagram} {i : ℕ} : μ.row i = {i} ×ˢ Finset.range (μ.rowLen i)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem congr_trans (f₁ : A ≃ₐ[S] B) (f₂ : B ≃ₐ[S] C) (g₁ : D ≃ₐ[R] E) (g₂ : E ≃ₐ[R] F) :
    congr (f₁.trans f₂) (g₁.trans g₂) = (congr f₁ g₁).trans (congr f₂ g₂)
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
lemma _root_.Set.Sized.uvCompression (huv : u.card = v.card) (h𝒜 : (𝒜 : Set (Finset α)).Sized r) :
    (𝓒 u v 𝒜 : Set (Finset α)).Sized r
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
theorem rightAdjointMate_comp {X Y Z : C} [HasRightDual X] [HasRightDual Y] {f : X ⟶ Y}
    {g : Xᘁ ⟶ Z} :
    fᘁ ≫ g =
      (ρ_ (Yᘁ)).inv ≫
        _ ◁ η_ X (Xᘁ) ≫ _ ◁ (f ⊗ g) ≫ (α_ (Yᘁ) Y Z).inv ≫ ε_ Y (Yᘁ) ▷ _ ≫ (λ_ Z).hom
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_left_injective (a : G) : Function.Injective (· * a)
-- Mathlib/CategoryTheory/HomCongr.lean
theorem map_homCongr {X Y X₁ Y₁ : C} (α : X ≅ X₁) (β : Y ≅ Y₁) (f : X ⟶ Y) :
    F.map (Iso.homCongr α β f) = Iso.homCongr (F.mapIso α) (F.mapIso β) (F.map f)
-- Mathlib/Data/Set/Function.lean
theorem update_comp_eq_of_not_mem_range' {α : Sort*} {β : Type*} {γ : β → Sort*} [DecidableEq β]
    (g : ∀ b, γ b) {f : α → β} {i : β} (a : γ i) (h : i ∉ Set.range f) :
    (fun j => update g i a (f j)) = fun j => g (f j)
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem hasFDerivWithinAt_apply (i : ι) (f : ∀ i, F' i) (s' : Set (∀ i, F' i)) :
    HasFDerivWithinAt (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) (proj i) s' f
-- Mathlib/Topology/PartialHomeomorph.lean
theorem prod_eq_prod_of_nonempty'
    {eX eX' : PartialHomeomorph X X'} {eY eY' : PartialHomeomorph Y Y'}
    (h : (eX'.prod eY').source.Nonempty) : eX.prod eY = eX'.prod eY' ↔ eX = eX' ∧ eY = eY'
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem sum_fintype [Fintype ι] (μ : ι → Measure α) : sum μ = ∑ i, μ i
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes left strict covariance. -/
theorem Left.mul_lt_mul_of_nonneg [PosMulStrictMono α] [MulPosMono α]
    (h₁ : a < b) (h₂ : c < d) (a0 : 0 ≤ a) (c0 : 0 ≤ c) : a * c < b * d
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- Adding a point to a collinear set produces a coplanar set. -/
theorem Collinear.coplanar_insert {s : Set P} (h : Collinear k s) (p : P) :
    Coplanar k (insert p s)
-- Mathlib/GroupTheory/CoprodI.lean
@[simp]
theorem mulHead_head {i j : ι} (w : NeWord M i j) (x : M i) (hnotone : x * w.head ≠ 1) :
    (mulHead w x hnotone).head = x * w.head
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast]
theorem lt_to_nat {m n : Num} : (m : ℕ) < n ↔ m < n
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
/-- Given a left exact sequence `0 → M → M' → M''`, if `r` is regular on both
`M` and `M''` it's regular `M'` too. -/
lemma isSMulRegular_of_range_eq_ker {f : M →ₗ[R] M'} {g : M' →ₗ[R] M''}
    (hf : Function.Injective f) (hfg : LinearMap.range f = LinearMap.ker g)
    (h1 : IsSMulRegular M r) (h2 : IsSMulRegular M'' r) :
    IsSMulRegular M' r
-- Mathlib/Algebra/Polynomial/Derivative.lean
@[simp]
theorem derivative_X : derivative (X : R[X]) = 1
-- Mathlib/CategoryTheory/Limits/Shapes/StrictInitial.lean
/-- We say `C` has strict terminal objects if every terminal object is strict, ie given any morphism
`f : I ⟶ A` where `I` is terminal, then `f` is an isomorphism.

Strictly speaking, this says that *any* terminal object must be strict, rather than that strict
terminal objects exist.
-/
class HasStrictTerminalObjects : Prop where
  out : ∀ {I A : C} (f : I ⟶ A), IsTerminal I → IsIso f
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem range_eq_map (f : G →* N) : f.range = (⊤ : Subgroup G).map f
-- Mathlib/Algebra/Order/UpperLower.lean
@[to_additive]
theorem IsLowerSet.div_left (ht : IsLowerSet t) : IsUpperSet (s / t)
-- Mathlib/LinearAlgebra/Projection.lean
theorem linear_proj_add_linearProjOfIsCompl_eq_self (hpq : IsCompl p q) (x : E) :
    (p.linearProjOfIsCompl q hpq x + q.linearProjOfIsCompl p hpq.symm x : E) = x
-- Mathlib/Data/Nat/Size.lean
theorem size_pos {n : ℕ} : 0 < size n ↔ 0 < n
-- Mathlib/Order/WithBot.lean
@[simp] lemma coe_untop : ∀ (x : WithTop α) hx, x.untop hx = x
-- Mathlib/Algebra/Order/CauSeq/Completion.lean
theorem lim_eq_zero_iff (f : CauSeq β abv) : lim f = 0 ↔ LimZero f
-- Mathlib/Algebra/Pointwise/Stabilizer.lean
@[to_additive]
lemma mem_stabilizer_set {s : Set α} : a ∈ stabilizer G s ↔ ∀ b, a • b ∈ s ↔ b ∈ s
-- Mathlib/CategoryTheory/Monoidal/NaturalTransformation.lean
@[simp]
theorem comp_toNatTrans_lax {F G H : LaxMonoidalFunctor C D} {α : F ⟶ G} {β : G ⟶ H} :
    (α ≫ β).toNatTrans = @CategoryStruct.comp (C ⥤ D) _ _ _ _ α.toNatTrans β.toNatTrans
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- A side of a right-angled triangle divided by the cosine of the adjacent angle equals the
hypotenuse, version subtracting vectors. -/
theorem norm_div_cos_angle_sub_of_inner_eq_zero {x y : V} (h : ⟪x, y⟫ = 0) (h0 : x ≠ 0 ∨ y = 0) :
    ‖x‖ / Real.cos (angle x (x - y)) = ‖x - y‖
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_add_measure_compl (h : MeasurableSet s) : μ s + μ sᶜ = μ univ
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[simp] theorem utf8Len_cons (c cs) : utf8Len (c :: cs) = utf8Len cs + c.utf8Size
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem erase_same {a : α} {f : α →₀ M} : (f.erase a) a = 0
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalExtr.comp_continuousOn [TopologicalSpace δ] {s : Set δ} (g : δ → α) {b : δ}
    (hf : IsLocalExtr f (g b)) (hg : ContinuousOn g s) (hb : b ∈ s) : IsLocalExtrOn (f ∘ g) s b
-- Mathlib/RingTheory/Perfection.lean
theorem preVal_eq_zero {x : ModP K v O hv p} : preVal K v O hv p x = 0 ↔ x = 0
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
@[simp]
theorem arg_conj_coe_angle (x : ℂ) : (arg (conj x) : Real.Angle) = -arg x
-- Mathlib/CategoryTheory/Pi/Basic.lean
/-- When `i = j`, projections `Pi.eval C i` and `Pi.eval C j` are related by the equivalence
`Pi.eqToEquivalence C h : C i ≌ C j`. -/
@[simps!]
def Pi.evalCompEqToEquivalenceFunctor {i j : I} (h : i = j) :
    Pi.eval C i ⋙ (Pi.eqToEquivalence C h).functor ≅
      Pi.eval C j
-- Mathlib/Order/Lattice.lean
theorem map_inf [SemilatticeInf β] (hf : MonotoneOn f s) (hx : x ∈ s) (hy : y ∈ s) :
    f (x ⊓ y) = f x ⊓ f y
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
protected theorem sum_inner_mul_inner (b : OrthonormalBasis ι 𝕜 E) (x y : E) :
    ∑ i, ⟪x, b i⟫ * ⟪b i, y⟫ = ⟪x, y⟫
-- Mathlib/Probability/Martingale/Basic.lean
/-- A predictable submartingale is a.e. greater equal than its initial state. -/
theorem Submartingale.zero_le_of_predictable [Preorder E] [SigmaFiniteFiltration μ 𝒢]
    {f : ℕ → Ω → E} (hfmgle : Submartingale f 𝒢 μ) (hfadp : Adapted 𝒢 fun n => f (n + 1)) (n : ℕ) :
    f 0 ≤ᵐ[μ] f n
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem compl_map (f : α ≃o β) (s : LowerSet α) : (map f s).compl = UpperSet.map f s.compl
-- Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean
@[to_additive]
theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
    [CovariantClass α α (Function.swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem ae_lt_of_essSup_lt (hx : essSup f μ < x)
    (hf : IsBoundedUnder (· ≤ ·) (ae μ) f := by isBoundedDefault) :
    ∀ᵐ y ∂μ, f y < x
-- Mathlib/Algebra/Homology/HomotopyCategory/DegreewiseSplit.lean
@[simp]
lemma cocycleOfDegreewiseSplit_triangleRotateShortComplexSplitting_v (p : ℤ) :
    (cocycleOfDegreewiseSplit _ (triangleRotateShortComplexSplitting φ)).1.v p _ rfl =
      -φ.f _
-- Mathlib/CategoryTheory/Sites/Grothendieck.lean
theorem condition (S : J.Cover X) : S.sieve ∈ J X
-- Mathlib/NumberTheory/Dioph.lean
theorem diophPFun_vec (f : Vector3 ℕ n →. ℕ) : DiophPFun f ↔ Dioph {v | f.graph (v ∘ fs, v fz)}
-- Mathlib/Data/List/OfFn.lean
@[simp]
theorem ofFn_get : ∀ l : List α, (ofFn (get l)) = l
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_image_Iio (s : Set α) : IsPiSystem (Iio '' s)
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma toMvPolynomial_totalDegree_le (M : Matrix m n R) (i : m) :
    (M.toMvPolynomial i).totalDegree ≤ 1
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem support_mul_X (s : σ) (p : MvPolynomial σ R) :
    (p * X s).support = p.support.map (addRightEmbedding (Finsupp.single s 1))
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- Finite sums of analytic functions are analytic -/
theorem Finset.analyticAt_sum {f : α → E → F} {c : E}
    (N : Finset α) (h : ∀ n ∈ N, AnalyticAt 𝕜 (f n) c) :
    AnalyticAt 𝕜 (fun z ↦ ∑ n ∈ N, f n z) c
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
theorem add_sub_sub_add_right (n m k l : Nat) :
    (n + l) - m - (k + l) = n - m - k
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
theorem dvd_mul_sub_mul {k a b x y : α} (hab : k ∣ a - b) (hxy : k ∣ x - y) :
    k ∣ a * x - b * y
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_mul (x y : ℝ) : (↑(x * y) : EReal) = x * y
-- Mathlib/Order/PartialSups.lean
@[simp]
lemma disjoint_partialSups_right [DistribLattice α] [OrderBot α] {f : ℕ → α} {n : ℕ} {x : α} :
    Disjoint x (partialSups f n) ↔ ∀ k ≤ n, Disjoint x (f k)
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem LipschitzWith.to_rightInverse [PseudoEMetricSpace α] [PseudoEMetricSpace β] {K : ℝ≥0}
    {f : α → β} (hf : LipschitzWith K f) {g : β → α} (hg : Function.RightInverse g f) :
    AntilipschitzWith K g
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Pasting.lean
@[reassoc (attr := simp)]
theorem inl_pushoutLeftPushoutInrIso_inv :
    pushout.inl _ _ ≫ (pushoutLeftPushoutInrIso f g g').inv = pushout.inl _ _ ≫ pushout.inl _ _
-- Mathlib/Data/Analysis/Filter.lean
@[simp]
theorem map_F (m : α → β) {f : Filter α} (F : f.Realizer) (s) : (F.map m).F s = image m (F.F s)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_pos {a b : Int} (ha : 0 < a) (hb : 0 < b) : 0 < a + b
-- Mathlib/CategoryTheory/Shift/SingleFunctors.lean
@[reassoc (attr := simp)]
lemma inv_hom_id_hom_app (e : F ≅ G) (n : A) (X : C) :
    (e.inv.hom n).app X ≫ (e.hom.hom n).app X = 𝟙 _
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem isLeftDescent_inv_iff {w : W} {i : B} :
    cs.IsLeftDescent w⁻¹ i ↔ cs.IsRightDescent w i
-- Mathlib/GroupTheory/Torsion.lean
@[to_additive]
theorem mem_torsion (g : G) : g ∈ torsion G ↔ IsOfFinOrder g
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_div_le_of_neg (ha : a < 0) (hb : b < 0) : 1 / a ≤ b ↔ 1 / b ≤ a
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem mapMatrix_id : (AddMonoidHom.id α).mapMatrix = AddMonoidHom.id (Matrix m n α)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- Reversing the order of the points passed to `oangle` negates the angle. -/
theorem oangle_rev (p₁ p₂ p₃ : P) : ∡ p₃ p₂ p₁ = -∡ p₁ p₂ p₃
-- Mathlib/Data/Pi/Interval.lean
theorem card_uIcc : (uIcc a b).card = ∏ i, (uIcc (a i) (b i)).card
-- Mathlib/Algebra/Ring/Parity.lean
lemma Odd.pow (ha : Odd a) : ∀ {n : ℕ}, Odd (a ^ n)
-- Mathlib/CategoryTheory/Extensive.lean
theorem FinitaryExtensive.isVanKampen_finiteCoproducts [FinitaryExtensive C] {ι : Type*}
    [Finite ι] {F : Discrete ι ⥤ C} {c : Cocone F} (hc : IsColimit c) : IsVanKampenColimit c
-- Mathlib/Data/Finset/Basic.lean
theorem subset_cons (h : a ∉ s) : s ⊆ s.cons a h
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
/-- The value of the Infimum of a nonempty family of outer measures on a set is not simply
the minimum value of a measure on that set: it is the infimum sum of measures of countable set of
sets that covers that set, where a different measure can be used for each set in the cover. -/
theorem biInf_apply' {ι} (I : Set ι) (m : ι → OuterMeasure α) {s : Set α} (hs : s.Nonempty) :
    (⨅ i ∈ I, m i) s = ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t), ∑' n, ⨅ i ∈ I, m i (t n)
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
@[simp]
theorem factorThru_add_sub_factorThru_left {X Y : C} {P : Subobject Y} (f g : X ⟶ Y)
    (w : P.Factors (f + g)) (wf : P.Factors f) :
    P.factorThru (f + g) w - P.factorThru f wf =
      P.factorThru g (factors_right_of_factors_add f g w wf)
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
@[reassoc (attr := simp)]
lemma opShiftFunctorEquivalence_unitIso_inv_naturality (n : ℤ) {X Y : Cᵒᵖ} (f : X ⟶ Y) :
    (f⟦n⟧').unop⟦n⟧'.op ≫ (opShiftFunctorEquivalence C n).unitIso.inv.app Y =
      (opShiftFunctorEquivalence C n).unitIso.inv.app X ≫ f
-- Mathlib/Data/Part.lean
theorem assert_defined {p : Prop} {f : p → Part α} : ∀ h : p, (f h).Dom → (assert p f).Dom
-- Mathlib/Tactic/Abel.lean
lemma subst_into_add {α} [AddCommMonoid α] (l r tl tr t)
    (prl : (l : α) = tl) (prr : r = tr) (prt : tl + tr = t) : l + r = t
-- Mathlib/Tactic/Ring/Basic.lean
theorem const_pos (n : ℕ) (h : Nat.ble 1 n = true) : 0 < (n.rawCast : ℕ)
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem mem_lieSpan {x : L} : x ∈ lieSpan R L s ↔ ∀ K : LieSubalgebra R L, s ⊆ K → x ∈ K
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem differentiableWithinAt_dslope_of_ne (h : b ≠ a) :
    DifferentiableWithinAt 𝕜 (dslope f a) s b ↔ DifferentiableWithinAt 𝕜 f s b
-- Mathlib/Data/Nat/Choose/Multinomial.lean
theorem binomial_succ_succ [DecidableEq α] (h : a ≠ b) :
    multinomial {a, b} (Function.update (Function.update f a (f a).succ) b (f b).succ) =
      multinomial {a, b} (Function.update f a (f a).succ) +
      multinomial {a, b} (Function.update f b (f b).succ)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_or_distrib_right : ∀ (x y z : Bool), ((x || y) && z) = (x && z || y && z)
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
/-- In a semi-`NormedSpace`, a continuous seminorm is zero on elements of norm `0`. -/
lemma map_eq_zero_of_norm_zero (q : Seminorm 𝕜 F)
    (hq : Continuous q) {x : F} (hx : ‖x‖ = 0) : q x = 0
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
theorem leftOp {W : MorphismProperty C} {L : C ⥤ Dᵒᵖ} (h : W.IsInvertedBy L) :
    W.op.IsInvertedBy L.leftOp
-- Mathlib/CategoryTheory/CommSq.lean
theorem map_commSq (s : CommSq f g h i) : CommSq (F.map f) (F.map g) (F.map h) (F.map i)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem zeta_mul_apply {f : ArithmeticFunction ℕ} {x : ℕ} : (ζ * f) x = ∑ i ∈ divisors x, f i
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
@[simp] lemma exp_lt_one_iff {a : EReal} : exp a < 1 ↔ a < 0
-- Mathlib/Order/Sublattice.lean
@[simp, norm_cast] lemma coe_inf (a b : L) : a ⊓ b = (a : α) ⊓ b
-- Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean
theorem contractRight_eq (x : CliffordAlgebra Q) :
    contractRight (Q := Q) x d = reverse (contractLeft (R := R) (M := M) d <| reverse x)
-- Mathlib/Data/Multiset/Basic.lean
theorem add_singleton_eq_iff {s t : Multiset α} {a : α} : s + {a} = t ↔ a ∈ t ∧ s = t.erase a
-- Mathlib/Probability/Martingale/BorelCantelli.lean
theorem stoppedValue_stoppedValue_leastGE (f : ℕ → Ω → ℝ) (π : Ω → ℕ) (r : ℝ) {n : ℕ}
    (hπn : ∀ ω, π ω ≤ n) : stoppedValue (fun i => stoppedValue f (leastGE f r i)) π =
      stoppedValue (stoppedProcess f (leastGE f r n)) π
-- Mathlib/MeasureTheory/Integral/Periodic.lean
@[simp]
protected theorem measure_univ : volume (Set.univ : Set (AddCircle T)) = ENNReal.ofReal T
-- Mathlib/Combinatorics/Additive/Corner/Roth.lean
/-- **Roth's theorem** for finite abelian groups.

The maximum density of a 3AP-free set in `G` goes to zero as `|G|` tends to infinity. -/
theorem roth_3ap_theorem (ε : ℝ) (hε : 0 < ε) (hG : cornersTheoremBound ε ≤ card G)
    (A : Finset G) (hAε : ε * card G ≤ A.card) : ¬ ThreeAPFree (A : Set G)
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[reassoc (attr := simp)]
theorem kernelIsoOfEq_inv_comp_ι {f g : X ⟶ Y} [HasKernel f] [HasKernel g] (h : f = g) :
    (kernelIsoOfEq h).inv ≫ kernel.ι _ = kernel.ι _
-- Mathlib/CategoryTheory/Sites/Sieves.lean
lemma functorPushforward_functor (S : Sieve X) (e : C ≌ D) :
    S.functorPushforward e.functor = (S.pullback (e.unitInv.app X)).functorPullback e.inverse
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive]
theorem prod_trunc {M : Type*} [CommMonoid M] {a b : ℕ} (f : Fin (a + b) → M)
    (hf : ∀ j : Fin b, f (natAdd a j) = 1) :
    (∏ i : Fin (a + b), f i) = ∏ i : Fin a, f (castLE (Nat.le.intro rfl) i)
-- Mathlib/Algebra/Module/Submodule/Map.lean
/-- The infimum of a family of invariant submodule of an endomorphism is also an invariant
submodule. -/
theorem _root_.LinearMap.iInf_invariant {σ : R →+* R} [RingHomSurjective σ] {ι : Sort*}
    (f : M →ₛₗ[σ] M) {p : ι → Submodule R M} (hf : ∀ i, ∀ v ∈ p i, f v ∈ p i) :
    ∀ v ∈ iInf p, f v ∈ iInf p
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_copy (f : α →+* β) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/Data/Finmap.lean
theorem toFinmap_cons (a : α) (b : β a) (xs : List (Sigma β)) :
    List.toFinmap (⟨a, b⟩ :: xs) = insert a b xs.toFinmap
-- .lake/packages/lean4/src/lean/Init/Prelude.lean
protected theorem Nat.lt_trans {n m k : Nat} (h₁ : LT.lt n m) : LT.lt m k → LT.lt n k
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem coe_smul (r : R) (f : NormedAddGroupHom V₁ V₂) : ⇑(r • f) = r • ⇑f
-- Mathlib/Topology/Sets/Compacts.lean
@[simp]
theorem map_id (K : PositiveCompacts α) : K.map id continuous_id IsOpenMap.id = K
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Pasting.lean
@[reassoc (attr := simp)]
theorem inr_inl_pushoutLeftPushoutInrIso_hom :
    pushout.inr _ _ ≫ pushout.inl _ _ ≫ (pushoutLeftPushoutInrIso f g g').hom =
      g' ≫ pushout.inr _ _
-- Mathlib/Data/Part.lean
theorem mem_assert {p : Prop} {f : p → Part α} : ∀ {a} (h : p), a ∈ f h → a ∈ assert p f
-- Mathlib/Data/Fintype/Basic.lean
@[simp] lemma univ_inter (s : Finset α) : univ ∩ s = s
-- Mathlib/Data/Nat/PrimeFin.lean
@[simp] lemma primeFactors_one : primeFactors 1 = ∅
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The pigeonhole principle for finitely many pigeons counted by heads: there is a pigeonhole with
at most as many pigeons as the floor of the average number of pigeons across all pigeonholes. -/
theorem exists_card_fiber_lt_of_card_lt_nsmul (ht : ↑s.card < t.card • b) :
    ∃ y ∈ t, ↑(s.filter fun x => f x = y).card < b
-- Mathlib/Data/QPF/Multivariate/Basic.lean
theorem liftP_iff_of_isUniform (h : q.IsUniform) {α : TypeVec n} (x : F α) (p : ∀ i, α i → Prop) :
    LiftP p x ↔ ∀ (i), ∀ u ∈ supp x i, p i u
-- Mathlib/Order/Atoms.lean
/-- A complete lower-modular lattice that is coatomistic is strongly coatomic.
Not an instance to prevent loops. -/
theorem CompleteLattice.isStronglyCoatomic [IsLowerModularLattice α] [IsCoatomistic α] :
    IsStronglyCoatomic α
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem integral_eq (f : α → E) (hf : Integrable f μ) : ∫ a, f a ∂μ = L1.integral (hf.toL1 f)
-- Mathlib/Analysis/BoxIntegral/Partition/Additive.lean
/-- If `g : M → N` is an additive map and `f` is a box additive map, then `g ∘ f` is a box additive
map. -/
@[simps (config := .asFn)]
def map (f : ι →ᵇᵃ[I₀] M) (g : M →+ N) : ι →ᵇᵃ[I₀] N
-- Mathlib/Data/Finset/Basic.lean
theorem toFinset_eq (n : Nodup l) : @Finset.mk α l n = l.toFinset
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem not_nonempty_empty : ¬(∅ : Finset α).Nonempty
-- Mathlib/CategoryTheory/Localization/HasLocalization.lean
/-- The data of a localized category with a given universe
for the morphisms.  -/
class HasLocalization where
  /-- the objects of the localized category. -/
  {D : Type u}
  /-- the category structure. -/
  [hD : Category.{w} D]
  /-- the localization functor. -/
  L : C ⥤ D
  [hL : L.IsLocalization W]
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
/-- The symmetry of homotopy between morphisms of short complexes. -/
@[simps]
def symm (h : Homotopy φ₁ φ₂) : Homotopy φ₂ φ₁
-- Mathlib/RingTheory/Bialgebra/Basic.lean
/-- `comulAlgHom R A` is the comultiplication of the `R`-bialgebra `A`, as an `R`-algebra map. -/
@[simps!]
def comulAlgHom : A →ₐ[R] A ⊗[R] A
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem gt_asymm (h : cmp x y = .gt) : cmp y x ≠ .gt
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
@[simp]
theorem coe_copy (f : C₀(α, β)) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/CategoryTheory/CofilteredSystem.lean
/-- The subfunctor of `F` obtained by restricting to the preimages of a set `s ∈ F.obj i`. -/
@[simps]
def toPreimages : J ⥤ Type v
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem toNonUnitalSubalgebra_le_iff {S₁ S₂ : NonUnitalStarSubalgebra R A} :
    S₁.toNonUnitalSubalgebra ≤ S₂.toNonUnitalSubalgebra ↔ S₁ ≤ S₂
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
/-- We say that a type has `MeasurableNeg` if `x ↦ -x` is a measurable function. -/
class MeasurableNeg (G : Type*) [Neg G] [MeasurableSpace G] : Prop where
  measurable_neg : Measurable (Neg.neg : G → G)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem abs_cos_eq_of_two_zsmul_eq {θ ψ : Angle} (h : (2 : ℤ) • θ = (2 : ℤ) • ψ) :
    |cos θ| = |cos ψ|
-- Mathlib/Topology/Maps/Basic.lean
theorem closure_eq_preimage_closure_image (hf : Inducing f) (s : Set X) :
    closure s = f ⁻¹' closure (f '' s)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
protected theorem Inducing.topologicalGroup {F : Type*} [Group H] [TopologicalSpace H]
    [FunLike F H G] [MonoidHomClass F H G] (f : F) (hf : Inducing f) : TopologicalGroup H
-- Mathlib/FieldTheory/AbelRuffini.lean
theorem gal_X_isSolvable : IsSolvable (X : F[X]).Gal
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem lt.step {n m : Nat} : n < m → n < succ m
-- Mathlib/Topology/Category/LightProfinite/Limits.lean
lemma finiteCoproduct.ι_injective (a : α) : Function.Injective (finiteCoproduct.ι X a)
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive (attr := simp)]
theorem one_apply [One β] (x : α) : (1 : C(α, β)) x = 1
-- Mathlib/Data/Nat/Bitwise.lean
lemma bitwise_eq_binaryRec (f : Bool → Bool → Bool) :
    bitwise f =
    binaryRec (fun n => cond (f false true) n 0) fun a m Ia =>
      binaryRec (cond (f true false) (bit a m) 0) fun b n _ => bit (f a b) (Ia n)
-- Mathlib/Topology/Algebra/Valued/NormedValued.lean
theorem norm_nonneg (x : L) : 0 ≤ norm x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem sin_add_pi (x : ℝ) : sin (x + π) = -sin x