ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
@[simp]
theorem finSuccEquiv_apply (p : MvPolynomial (Fin (n + 1)) R) :
    finSuccEquiv R n p =
      eval₂Hom (Polynomial.C.comp (C : R →+* MvPolynomial (Fin n) R))
        (fun i : Fin (n + 1) => Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i) p
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
theorem id_eq_path_refl (x : FundamentalGroupoid X) : 𝟙 x = ⟦Path.refl x.as⟧
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem repr_mul (a b) : repr (a * b) = repr a * repr b
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem isOpen_singleton_iff {α : Type*} [PseudoMetricSpace α] {x : α} :
    IsOpen ({x} : Set α) ↔ ∃ ε > 0, ∀ y, dist y x < ε → y = x
-- Mathlib/CategoryTheory/GradedObject.lean
@[reassoc (attr := simp)]
lemma map_inv_hom_id_eval_app (e : X ≅ Y) (F : C ⥤ D ⥤ E) (j : J) (Y : D) :
    (F.map (e.inv j)).app Y ≫ (F.map (e.hom j)).app Y = 𝟙 _
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[norm_cast]
theorem coe_prod (s : Subsemiring R) (t : Subsemiring S) :
    (s.prod t : Set (R × S)) = (s : Set R) ×ˢ (t : Set S)
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum₂_mul [CommRing α] (x y : α) (n : ℕ) :
    (∑ i ∈ range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- **Vitali's convergence theorem**: A sequence of functions `f` converges to `g` in Lp if and
only if it is uniformly integrable and converges to `g` in measure. -/
theorem tendstoInMeasure_iff_tendsto_Lp_finite [IsFiniteMeasure μ] (hp : 1 ≤ p) (hp' : p ≠ ∞)
    (hf : ∀ n, Memℒp (f n) p μ) (hg : Memℒp g p μ) :
    TendstoInMeasure μ f atTop g ∧ UnifIntegrable f p μ ↔
      Tendsto (fun n => eLpNorm (f n - g) p μ) atTop (𝓝 0)
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
/-- If a measurable space is countably generated and separates points, it is measure equivalent
to some subset of the Cantor space `ℕ → Bool` (equipped with the product sigma algebra).
Note: `s` need not be measurable, so this map need not be a `MeasurableEmbedding` to
the Cantor Space. -/
theorem measurableEquiv_nat_bool_of_countablyGenerated [MeasurableSpace α]
    [CountablyGenerated α] [SeparatesPoints α] :
    ∃ s : Set (ℕ → Bool), Nonempty (α ≃ᵐ s)
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_mono_ae {f g : α → β} (hfg : f ≤ᵐ[μ] g) : essSup f μ ≤ essSup g μ
-- Mathlib/CategoryTheory/Pi/Basic.lean
@[simp]
theorem isoApp_trans {X Y Z : ∀ i, C i} (f : X ≅ Y) (g : Y ≅ Z) (i : I) :
    isoApp (f ≪≫ g) i = isoApp f i ≪≫ isoApp g i
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem degree_C_mul (a0 : a ≠ 0) : (C a * p).degree = p.degree
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem rTensor_comp_apply (x : N ⊗[R] M) :
    (g.comp f).rTensor M x = (g.rTensor M) ((f.rTensor M) x)
-- Mathlib/Algebra/Module/Defs.lean
theorem self_ne_neg
    (R) (M) [Semiring R] [CharZero R] [AddCommGroup M] [Module R M] [NoZeroSMulDivisors R M]
    {v : M} : v ≠ -v ↔ v ≠ 0
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem toBoolAlg_one : toBoolAlg (1 : α) = ⊤
-- Mathlib/Analysis/Convex/Radon.lean
/-- **Helly's theorem** for finite families of convex sets.

If `F` is a finite family of convex sets in a vector space of finite dimension `d`, and any
`k ≤ d + 1` sets of `F` intersect nontrivially, then all sets of `F` intersect nontrivially. -/
theorem helly_theorem' {F : ι → Set E} {s : Finset ι}
    (h_convex : ∀ i ∈ s, Convex 𝕜 (F i))
    (h_inter : ∀ I ⊆ s, I.card ≤ finrank 𝕜 E + 1 → (⋂ i ∈ I, F i).Nonempty) :
    (⋂ i ∈ s, F i).Nonempty
-- Mathlib/Logic/Hydra.lean
theorem cutExpand_iff [DecidableEq α] [IsIrrefl α r] {s' s : Multiset α} :
    CutExpand r s' s ↔
      ∃ (t : Multiset α) (a : α), (∀ a' ∈ t, r a' a) ∧ a ∈ s ∧ s' = s.erase a + t
-- Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean
@[reassoc (attr := simp)]
lemma desc_commutes_zero {Y Z : C} (f : Z ⟶ Y)
    (I : InjectiveResolution Y) (J : InjectiveResolution Z) :
    J.ι.f 0 ≫ (desc f I J).f 0 = f ≫ I.ι.f 0
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
/-- In any concrete category, surjective morphisms are epimorphisms. -/
theorem epi_of_surjective {X Y : C} (f : X ⟶ Y) (s : Function.Surjective f) :
    Epi f
-- Mathlib/GroupTheory/Sylow.lean
theorem card_sylow_eq_index_normalizer [Fact p.Prime] [Finite (Sylow p G)] (P : Sylow p G) :
    Nat.card (Sylow p G) = (P : Subgroup G).normalizer.index
-- Mathlib/GroupTheory/Torsion.lean
lemma isTorsionFree_iff_noZeroSMulDivisors_int [AddGroup G] :
    AddMonoid.IsTorsionFree G ↔ NoZeroSMulDivisors ℤ G
-- Mathlib/Algebra/GCDMonoid/Finset.lean
@[simp]
theorem lcm_singleton {b : β} : ({b} : Finset β).lcm f = normalize (f b)
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[simp] theorem imp_not_self : (a → ¬a) ↔ ¬a
-- Mathlib/Order/SymmDiff.lean
theorem symmDiff_left_surjective (a : α) : Surjective (· ∆ a)
-- Mathlib/Logic/Function/Basic.lean
lemma not_bijective : Bijective Not
-- Mathlib/Data/NNReal/Basic.lean
theorem iSup_mul_iSup_le {a : ℝ≥0} {g h : ι → ℝ≥0} (H : ∀ i j, g i * h j ≤ a) :
    iSup g * iSup h ≤ a
-- Mathlib/Topology/CompactOpen.lean
/-- The compact-open topology on `C(X, Y)`
is equal to the infimum of the compact-open topologies on `C(s, Y)` for `s` a compact subset of `X`.
The key point of the proof is that for every compact set `K`,
the universal set `Set.univ : Set K` is a compact set as well. -/
theorem compactOpen_eq_iInf_induced :
    (ContinuousMap.compactOpen : TopologicalSpace C(X, Y)) =
      ⨅ (K : Set X) (_ : IsCompact K), .induced (.restrict K) ContinuousMap.compactOpen
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem isLowerSet_compl : IsLowerSet sᶜ ↔ IsUpperSet s
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem eval_eq (X : σ → R) (f : MvPolynomial σ R) :
    eval X f = ∑ d ∈ f.support, f.coeff d * ∏ i ∈ d.support, X i ^ d i
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
@[simp]
theorem formPerm_coe (l : List α) (hl : l.Nodup) : formPerm (l : Cycle α) hl = l.formPerm
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
lemma equiv_comp (L : C ⥤ D) [L.IsLocalization W] {X Y Z : C} [HasSmallLocalizedHom.{w} W X Y]
    [HasSmallLocalizedHom.{w} W Y Z] [HasSmallLocalizedHom.{w} W X Z]
    (α : SmallHom.{w} W X Y) (β : SmallHom.{w} W Y Z) :
    equiv W L (α.comp β) = equiv W L α ≫ equiv W L β
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem ker_le_comap (H : Subgroup N) : f.ker ≤ comap f H
-- Mathlib/Order/Cover.lean
theorem Set.OrdConnected.apply_covBy_apply_iff (f : α ↪o β) (h : (range f).OrdConnected) :
    f a ⋖ f b ↔ a ⋖ b
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem IsVanKampenColimit.isUniversal {F : J ⥤ C} {c : Cocone F} (H : IsVanKampenColimit c) :
    IsUniversalColimit c
-- Mathlib/Algebra/Order/Monoid/ToMulBot.lean
theorem toMulBot_strictMono : StrictMono (@toMulBot α _)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_add_zsmul' (a b : α) (m : ℤ) :
    toIocDiv hp (a + m • p) b = toIocDiv hp a b - m
-- Mathlib/Order/GameAdd.lean
theorem GameAdd.snd_fst {a₁ a₂ b : α} (h : rα a₁ a₂) : GameAdd rα s(b, a₁) s(a₂, b)
-- Mathlib/FieldTheory/IntermediateField.lean
theorem lift_injective (F : IntermediateField K L) : Function.Injective F.lift
-- Mathlib/Analysis/SpecificLimits/Basic.lean
@[simp] theorem tendsto_pow_atTop_nhds_zero_iff {𝕜 : Type*} [LinearOrderedField 𝕜] [Archimedean 𝕜]
    [TopologicalSpace 𝕜] [OrderTopology 𝕜] {r : 𝕜} :
    Tendsto (fun n : ℕ ↦ r ^ n) atTop (𝓝 0) ↔ |r| < 1
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem SimpleFunc.lintegral_eq_lintegral {m : MeasurableSpace α} (f : α →ₛ ℝ≥0∞) (μ : Measure α) :
    ∫⁻ a, f a ∂μ = f.lintegral μ
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
theorem zpow_mul' (A : M) (h : IsUnit A.det) (m n : ℤ) : A ^ (m * n) = (A ^ n) ^ m
-- Mathlib/Order/OrdContinuous.lean
theorem map_iInf (hf : RightOrdContinuous f) (g : ι → α) : f (⨅ i, g i) = ⨅ i, f (g i)
-- Mathlib/Order/Partition/Finpartition.lean
theorem exists_le_of_le {a b : α} {P Q : Finpartition a} (h : P ≤ Q) (hb : b ∈ Q.parts) :
    ∃ c ∈ P.parts, c ≤ b
-- Mathlib/Algebra/Quandle.lean
/--
The associativity of a unital shelf comes for free.
-/
lemma assoc (x y z : S) : (x ◃ y) ◃ z = x ◃ y ◃ z
-- Mathlib/Topology/Connected/PathConnected.lean
theorem _root_.Filter.Tendsto.path_extend
    {l r : Y → X} {y : Y} {l₁ : Filter ℝ} {l₂ : Filter X} {γ : ∀ y, Path (l y) (r y)}
    (hγ : Tendsto (↿γ) (𝓝 y ×ˢ l₁.map (projIcc 0 1 zero_le_one)) l₂) :
    Tendsto (↿fun x => (γ x).extend) (𝓝 y ×ˢ l₁) l₂
-- Mathlib/Data/Int/GCD.lean
theorem xgcdAux_P {r r'} :
    ∀ {s t s' t'}, P x y (r, s, t) → P x y (r', s', t') → P x y (xgcdAux r s t r' s' t')
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_atTop_add_const_left (C : β) (hf : Tendsto f l atTop) :
    Tendsto (fun x => C + f x) l atTop
-- Mathlib/Topology/Order/DenselyOrdered.lean
theorem nhdsWithin_Ioi_neBot [NoMaxOrder α] {a b : α} (H : a ≤ b) : NeBot (𝓝[Ioi a] b)
-- Mathlib/LinearAlgebra/Ray.lean
@[simp]
theorem Module.Ray.map_symm (e : M ≃ₗ[R] N) : (Module.Ray.map e).symm = Module.Ray.map e.symm
-- Mathlib/Data/Sum/Order.lean
theorem inl_le_inl_iff [LE α] [LE β] {a b : α} : toLex (inl a : α ⊕ β) ≤ toLex (inl b) ↔ a ≤ b
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The matrix associated to the adjoint of a linear map corresponding to two orthonormal bases
is the conjugate tranpose of the matrix associated to the linear map. -/
lemma LinearMap.toMatrix_adjoint (f : E →ₗ[𝕜] F) :
    toMatrix v₂.toBasis v₁.toBasis (adjoint f) = (toMatrix v₁.toBasis v₂.toBasis f)ᴴ
-- Mathlib/Data/List/OfFn.lean
/-- This breaks a list of `m*n` items into `m` groups each containing `n` elements. -/
theorem ofFn_mul {m n} (f : Fin (m * n) → α) :
    List.ofFn f = List.join (List.ofFn fun i : Fin m => List.ofFn fun j : Fin n => f ⟨i * n + j,
    calc
      ↑i * n + j < (i + 1) * n :=
        (Nat.add_lt_add_left j.prop _).trans_eq (by rw [Nat.add_mul, Nat.one_mul])
      _ ≤ _ := Nat.mul_le_mul_right _ i.prop⟩)
-- Mathlib/Data/Set/Subset.lean
lemma preimage_val_sInter_eq_sInter : A ↓∩ (⋂₀ S) = ⋂₀ ((A ↓∩ ·) '' S)
-- Mathlib/Logic/Encodable/Basic.lean
@[simp]
theorem decode_one : (decode 1 : Option Bool) = some true
-- Mathlib/Geometry/Euclidean/Inversion/Basic.lean
@[simp]
theorem inversion_zero_radius (c x : P) : inversion c 0 x = c
-- Mathlib/Algebra/Homology/Embedding/IsSupported.lean
lemma isZero_X_of_isStrictlySupported [K.IsStrictlySupported e]
    (i' : ι') (hi' : ∀ i, e.f i ≠ i') :
    IsZero (K.X i')
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem recF_eq {α : Type _} (g : F α → α) (x : q.P.W) :
    recF g x = g (abs (q.P.map (recF g) x.dest))
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem aleph0_lt_aleph_one : ℵ₀ < aleph 1
-- Mathlib/Data/Nat/Prime/Basic.lean
@[simp] lemma coprime_two_left : Coprime 2 n ↔ Odd n
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem func_mem (x : PSet) (i : x.Type) : x.Func i ∈ x
-- Mathlib/Data/ZMod/Basic.lean
lemma mul_val_inv (hmn : m.Coprime n) : (m * (m⁻¹ : ZMod n).val : ZMod n) = 1
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt64.val_ofNat (n) :
    (no_index (OfNat.ofNat n) : UInt64).val = OfNat.ofNat n
-- Mathlib/Data/Finsupp/NeLocus.lean
@[simp]
theorem coe_neLocus : ↑(f.neLocus g) = { x | f x ≠ g x }
-- Mathlib/SetTheory/Cardinal/Finite.lean
lemma card_prod_singleton (s : Set α) (b : β) : Nat.card (s ×ˢ {b}) = Nat.card s
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem mk_le_mk [Preorder β] {f g : α → β} (hf hg) : (mk f hf : α →ₘ[μ] β) ≤ mk g hg ↔ f ≤ᵐ[μ] g
-- Mathlib/GroupTheory/SpecificGroups/Alternating.lean
theorem finRotate_bit1_mem_alternatingGroup {n : ℕ} :
    finRotate (2 * n + 1) ∈ alternatingGroup (Fin (2 * n + 1))
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Iso.lean
@[simp]
theorem pushoutCoconeOfRightIso_ι_app_left : (pushoutCoconeOfRightIso f g).ι.app left = 𝟙 _
-- Mathlib/GroupTheory/Coxeter/Basic.lean
@[simp] theorem map_simple (e : W ≃* H) (i : B) : (cs.map e).simple i = e (cs.simple i)
-- Mathlib/Data/Finsupp/Defs.lean
theorem mapRange_add [AddZeroClass N] {f : M → N} {hf : f 0 = 0}
    (hf' : ∀ x y, f (x + y) = f x + f y) (v₁ v₂ : α →₀ M) :
    mapRange f hf (v₁ + v₂) = mapRange f hf v₁ + mapRange f hf v₂
-- Mathlib/Data/Nat/Defs.lean
@[simp, nolint simpNF] protected lemma add_eq_right : a + b = b ↔ a = 0
-- Mathlib/Data/Nat/Factorial/SuperFactorial.lean
theorem det_vandermonde_id_eq_superFactorial (n : ℕ) :
    (Matrix.vandermonde (fun (i : Fin (n + 1)) ↦ (i : R))).det = Nat.superFactorial n
-- Mathlib/Order/UpperLower/Basic.lean
@[simp] lemma le_upperClosure {s : UpperSet α} : s ≤ upperClosure t ↔ t ⊆ s
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem _root_.totallyBounded_Ioo (a b : α) : TotallyBounded (Ioo a b)
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[refl]
theorem refl (v : VectorMeasure α M) : v ≪ᵥ v
-- Mathlib/Logic/Basic.lean
theorem forall₂_swap
    {ι₁ ι₂ : Sort*} {κ₁ : ι₁ → Sort*} {κ₂ : ι₂ → Sort*} {p : ∀ i₁, κ₁ i₁ → ∀ i₂, κ₂ i₂ → Prop} :
    (∀ i₁ j₁ i₂ j₂, p i₁ j₁ i₂ j₂) ↔ ∀ i₂ j₂ i₁ j₁, p i₁ j₁ i₂ j₂
-- Mathlib/LinearAlgebra/Determinant.lean
@[simp]
theorem det_toMatrix (b : Basis ι A M) (f : M →ₗ[A] M) :
    Matrix.det (toMatrix b b f) = LinearMap.det f
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma mop_whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) :
    (X ◁ f).mop = f.mop ▷ mop X
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMinOn.not_nhds_le_map [TopologicalSpace β] (hf : IsLocalMinOn f s a)
    [NeBot (𝓝[<] f a)] : ¬𝓝 (f a) ≤ map f (𝓝[s] a)
-- Mathlib/Computability/Ackermann.lean
@[simp]
theorem ack_zero (n : ℕ) : ack 0 n = n + 1
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem substructureEquivMap_apply (f : M ↪[L] N) (p : L.Substructure M) (x : p) :
    (f.substructureEquivMap p x : N) = f x
-- Mathlib/Data/Part.lean
theorem mem_unique : ∀ {a b : α} {o : Part α}, a ∈ o → b ∈ o → a = b
-- Mathlib/Topology/Basic.lean
theorem denseRange_iff_closure_range : DenseRange f ↔ closure (range f) = univ
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
theorem foldl_loop_eq (f : α → Fin n → α) (x) : foldl.loop n f x n = x
-- Mathlib/Algebra/Lie/Subalgebra.lean
@[simp]
theorem incl_range : K.incl.range = K
-- Mathlib/Data/Real/EReal.lean
lemma div_nonpos_of_nonpos_of_nonneg {a b : EReal} (h : a ≤ 0) (h' : 0 ≤ b) : a / b ≤ 0
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
@[simp]
theorem mapOfLE_valuation_apply (R S : ValuationSubring K) (h : R ≤ S) (x : K) :
    R.mapOfLE S h (R.valuation x) = S.valuation x
-- Mathlib/Topology/SeparatedMap.lean
theorem IsSeparatedMap.isClosed_eqLocus (he : f ∘ g₁ = f ∘ g₂) : IsClosed {a | g₁ a = g₂ a}
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma D₂_totalShift₂XIso_hom (n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + y = n₀') (h₁ : n₁ + y = n₁') :
    ((shiftFunctor₂ C y).obj K).D₂ (up ℤ) n₀ n₁ ≫ (K.totalShift₂XIso y n₁ n₁' h₁).hom =
      y.negOnePow • ((K.totalShift₂XIso y n₀ n₀' h₀).hom ≫ K.D₂ (up ℤ) n₀' n₁')
-- Mathlib/Topology/Metrizable/Urysohn.lean
/-- For a regular topological space with second countable topology,
there exists an inducing map to `l^∞ = ℕ →ᵇ ℝ`. -/
theorem exists_inducing_l_infty : ∃ f : X → ℕ →ᵇ ℝ, Inducing f
-- Mathlib/NumberTheory/Multiplicity.lean
theorem pow_add_pow (hxy : p ∣ x + y) (hx : ¬p ∣ x) {n : ℕ} (hn : Odd n) :
    padicValNat p (x ^ n + y ^ n) = padicValNat p (x + y) + padicValNat p n
-- Mathlib/Data/Matrix/RowCol.lean
@[simp]
theorem row_add [Add α] (v w : m → α) : row ι (v + w) = row ι v + row ι w
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem add_closure_iUnion_range_single :
    AddSubmonoid.closure (⋃ i : ι, Set.range (single i : β i → Π₀ i, β i)) = ⊤
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem lsub_sum {α : Type u} {β : Type v} (f : α ⊕ β → Ordinal) :
    lsub.{max u v, w} f =
      max (lsub.{u, max v w} fun a => f (Sum.inl a)) (lsub.{v, max u w} fun b => f (Sum.inr b))
-- Mathlib/Testing/SlimCheck/Functions.lean
theorem List.applyId_eq_self [DecidableEq α] {xs ys : List α} (x : α) :
    x ∉ xs → List.applyId.{u} (xs.zip ys) x = x
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem coe_toReal (r : ℝ≥0) : (r : ℝ≥0∞).toReal = r
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem ediam_univ (h : α ≃ᵢ β) : EMetric.diam (univ : Set α) = EMetric.diam (univ : Set β)
-- Mathlib/Order/PartialSups.lean
@[simp]
theorem partialSups_zero (f : ℕ → α) : partialSups f 0 = f 0
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[reassoc]
theorem conePointsIsoOfNatIso_hom_comp {F G : J ⥤ C} {s : Cone F} {t : Cone G} (P : IsLimit s)
    (Q : IsLimit t) (w : F ≅ G) (j : J) :
    (conePointsIsoOfNatIso P Q w).hom ≫ t.π.app j = s.π.app j ≫ w.hom.app j
-- Mathlib/CategoryTheory/Adjunction/AdjointFunctorTheorems.lean
/-- If `G : D ⥤ C` is a right adjoint it satisfies the solution set condition.  -/
theorem solutionSetCondition_of_isRightAdjoint [G.IsRightAdjoint] : SolutionSetCondition G
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem restrict_apply_mk (f : C(α, β)) (s : Set α) (x : α) (hx : x ∈ s) :
    f.restrict s ⟨x, hx⟩ = f x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem takeWhile_append_dropWhile (p : α → Bool) :
    ∀ (l : List α), takeWhile p l ++ dropWhile p l = l
-- Mathlib/Data/Nat/Find.lean
lemma find_pos (h : ∃ n : ℕ, p n) : 0 < Nat.find h ↔ ¬p 0
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem sumDualDistrib_symm_inr : (sumDualDistrib α β).symm (inr (toDual b)) = toDual (inr b)
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
lemma cliqueSet_eq_image [NoAccidental t] : (graph t).cliqueSet 3 = toTriangle '' t
-- Mathlib/Topology/Order.lean
@[deprecated nhds_nhdsAdjoint_of_ne (since := "2024-02-10")]
theorem nhdsAdjoint_nhds_of_ne (a : α) (f : Filter α) {b : α} (h : b ≠ a) :
    @nhds α (nhdsAdjoint a f) b = pure b
-- Mathlib/Data/Complex/Order.lean
theorem eq_re_of_ofReal_le {r : ℝ} {z : ℂ} (hz : (r : ℂ) ≤ z) : z = z.re
-- Mathlib/Data/Finset/Lattice.lean
protected theorem sup_comm (s : Finset β) (t : Finset γ) (f : β → γ → α) :
    (s.sup fun b => t.sup (f b)) = t.sup fun c => s.sup fun b => f b c
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem mul_ediv_assoc (a : Int) : ∀ {b c : Int}, c ∣ b → (a * b) / c = a * (b / c)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
/-- The equation that characterizes `enumOrd` definitionally. This isn't the nicest expression to
    work with, so consider using `enumOrd_def` instead. -/
theorem enumOrd_def' (o) :
    enumOrd S o = sInf (S ∩ Set.Ici (blsub.{u, u} o fun a _ => enumOrd S a))
-- Mathlib/Computability/TuringMachine.lean
theorem stmts_supportsStmt {M : Λ → Stmt₁} {S : Finset Λ} {q : Stmt₁} (ss : Supports M S) :
    some q ∈ stmts M S → SupportsStmt S q
-- Mathlib/CategoryTheory/Abelian/LeftDerived.lean
@[simp]
theorem NatTrans.leftDerived_id (F : C ⥤ D) [F.Additive] (n : ℕ) :
    NatTrans.leftDerived (𝟙 F) n = 𝟙 (F.leftDerived n)
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
lemma rnDeriv_pos' [SigmaFinite μ] [SFinite ν] (hμν : μ ≪ ν) :
    ∀ᵐ x ∂μ, 0 < ν.rnDeriv μ x
-- Mathlib/CategoryTheory/Sums/Associator.lean
@[simp]
theorem inverseAssociator_obj_inr_inl (X) :
    (inverseAssociator C D E).obj (inr (inl X)) = inl (inr X)
-- Mathlib/Data/Bool/Basic.lean
theorem decide_true {p : Prop} [Decidable p] : p → decide p
-- Mathlib/Order/Closure.lean
theorem le_closure_iff (x y : α) : x ≤ u (l y) ↔ u (l x) ≤ u (l y)
-- Mathlib/Analysis/Convex/Jensen.lean
/-- A form of the **equality case of Jensen's equality**.

For a strictly concave function `f` and positive weights `w`, if
`f (∑ i ∈ t, w i • p i) = ∑ i ∈ t, w i • f (p i)`, then the points `p` are all equal.

See also `StrictConcaveOn.map_sum_eq_iff`. -/
lemma StrictConcaveOn.eq_of_map_sum_eq (hf : StrictConcaveOn 𝕜 s f) (h₀ : ∀ i ∈ t, 0 < w i)
    (h₁ : ∑ i ∈ t, w i = 1) (hmem : ∀ i ∈ t, p i ∈ s)
    (h_eq : f (∑ i ∈ t, w i • p i) ≤ ∑ i ∈ t, w i • f (p i)) :
    ∀ ⦃j⦄, j ∈ t → ∀ ⦃k⦄, k ∈ t → p j = p k
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem and_iff_left_iff_imp  : ∀(a b : Bool), ((a && b) = a) ↔ (a → b)
-- Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean
theorem integral_comp_mul_left (g : ℝ → F) (a : ℝ) :
    (∫ x : ℝ, g (a * x)) = |a⁻¹| • ∫ y : ℝ, g y
-- Mathlib/Topology/Constructions.lean
@[continuity]
theorem Continuous.Prod.mk (x : X) : Continuous fun y : Y => (x, y)
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
@[simp] theorem toBialgEquiv_refl : toBialgEquiv (.refl X) = .refl _ _
-- Mathlib/FieldTheory/KummerExtension.lean
theorem X_pow_sub_C_irreducible_of_prime_pow
    {p : ℕ} (hp : p.Prime) (hp' : p ≠ 2) (n : ℕ) {a : K} (ha : ∀ b : K, b ^ p ≠ a) :
    Irreducible (X ^ (p ^ n) - C a)
-- Mathlib/Topology/MetricSpace/Holder.lean
theorem ediam_image_le (hf : HolderWith C r f) (s : Set X) :
    EMetric.diam (f '' s) ≤ (C : ℝ≥0∞) * EMetric.diam s ^ (r : ℝ)
-- Mathlib/RingTheory/IsAdjoinRoot.lean
theorem aeval_root (h : IsAdjoinRoot S f) : aeval h.root f = 0
-- Mathlib/Data/NNRat/Defs.lean
theorem toNNRat_add_le : toNNRat (q + p) ≤ toNNRat q + toNNRat p
-- Mathlib/RepresentationTheory/Invariants.lean
/-- The `averageMap` acts as the identity on the subspace of invariants.
-/
theorem averageMap_id (v : V) (hv : v ∈ invariants ρ) : averageMap ρ v = v
-- Mathlib/Topology/FiberBundle/IsHomeomorphicTrivialBundle.lean
/-- The projection from a trivial fiber bundle to its base is open. -/
protected theorem isOpenMap_proj (h : IsHomeomorphicTrivialFiberBundle F proj) :
    IsOpenMap proj
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem comap_smul' (f : V →ₗ[K] V₂) (p : Submodule K V₂) (a : K) :
    p.comap (a • f) = ⨅ _ : a ≠ 0, p.comap f
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_lt_nadd_left (h : b < c) (a) : a ♯ b < a ♯ c
-- Mathlib/Order/Basic.lean
@[simp]
lemma ltByCases_gt (h : y < x) {h₁ : x < y → P} {h₂ : x = y → P} {h₃ : y < x → P} :
    ltByCases x y h₁ h₂ h₃ = h₃ h
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
@[simp]
theorem sameCycle_pow_right {n : ℕ} : SameCycle f x ((f ^ n) y) ↔ SameCycle f x y
-- Mathlib/Data/Sign.lean
theorem sign_pow (x : α) (n : ℕ) : sign (x ^ n) = sign x ^ n
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
private lemma if_exact : Function.Exact (LinearMap.ker f).subtype f
-- Mathlib/AlgebraicGeometry/Properties.lean
theorem isIntegral_of_irreducibleSpace_of_isReduced [IsReduced X] [H : IrreducibleSpace X] :
    IsIntegral X
-- Mathlib/GroupTheory/Nilpotent.lean
/-- Any ascending central series for a group is bounded above by the upper central series. -/
theorem ascending_central_series_le_upper (H : ℕ → Subgroup G) (hH : IsAscendingCentralSeries H) :
    ∀ n : ℕ, H n ≤ upperCentralSeries G n
-- Mathlib/Data/Num/Bitwise.lean
@[simp] lemma shiftr_eq_shiftRight (p : PosNum) (n : Nat) : p.shiftr n = p >>> n
-- Mathlib/Algebra/Quaternion.lean
theorem mk_univ_quaternionAlgebra_of_infinite [Infinite R] :
    #(Set.univ : Set ℍ[R,c₁,c₂]) = #R
-- Mathlib/Algebra/Module/Torsion.lean
@[simps]
instance : SMul S (torsion' R M S)
-- .lake/packages/lean4/src/lean/Init/Data/String/Basic.lean
@[simp] theorem length_push (c : Char) : (String.push s c).length = s.length + 1
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem le_sub_left_of_add_le {a b c : Int} (h : a + b ≤ c) : b ≤ c - a
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem reverse_reverse (as : List α) : as.reverse.reverse = as
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem mul_one_hom {Z : C} (f : Z ⟶ M.X) : (f ⊗ M.one) ≫ M.mul = (ρ_ Z).hom ≫ f
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean
theorem right_nonuniformWitnesses_card (h : ¬G.IsUniform ε s t) :
    (t.card : 𝕜) * ε ≤ (G.nonuniformWitnesses ε s t).2.card
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxOn.inter (hf : IsMaxOn f s a) (t) : IsMaxOn f (s ∩ t) a
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem apply_total (f : M →ₗ[R] M') (v) (l : α →₀ R) :
    f (Finsupp.total α M R v l) = Finsupp.total α M' R (f ∘ v) l
-- Mathlib/Init/Data/Int/Order.lean
protected theorem eq_zero_or_eq_zero_of_mul_eq_zero {a b : ℤ} (h : a * b = 0) : a = 0 ∨ b = 0
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
@[simp]
theorem normalizedFactors_pow {x : α} (n : ℕ) :
    normalizedFactors (x ^ n) = n • normalizedFactors x