ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
theorem toFinset_prod_dvd_prod [CommMonoid α] (S : Multiset α) : S.toFinset.prod id ∣ S.prod
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ici_subset_Ico_union_Ici : Ici a ⊆ Ico a b ∪ Ici b
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma rpow_sub_one' (hx : 0 ≤ x) (h : y - 1 ≠ 0) : x ^ (y - 1) = x ^ y / x
-- Mathlib/Topology/Algebra/Valued/ValuationTopology.lean
theorem loc_const {x : R} (h : (v x : Γ₀) ≠ 0) : { y : R | v y = v x } ∈ 𝓝 x
-- Mathlib/Data/Finset/Basic.lean
theorem ssubset_iff_exists_cons_subset : s ⊂ t ↔ ∃ (a : _) (h : a ∉ s), s.cons a h ⊆ t
-- Mathlib/Data/Fintype/Sum.lean
theorem Fintype.card_subtype_or_disjoint (p q : α → Prop) (h : Disjoint p q) [Fintype { x // p x }]
    [Fintype { x // q x }] [Fintype { x // p x ∨ q x }] :
    Fintype.card { x // p x ∨ q x } = Fintype.card { x // p x } + Fintype.card { x // q x }
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
theorem is3Clique_iff_exists_cycle_length_three :
    (∃ s : Finset α, G.IsNClique 3 s) ↔ ∃ (u : α) (w : G.Walk u u), w.IsCycle ∧ w.length = 3
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
/-- Like `Submodule.map_mul`, but with the multiplication reversed. -/
theorem submodule_map_mul_reverse (p q : Submodule R (CliffordAlgebra Q)) :
    (p * q).map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) =
      q.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q) *
        p.map (reverse : CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q)
-- Mathlib/Topology/Homotopy/Path.lean
@[simp]
theorem source (F : Homotopy p₀ p₁) (t : I) : F (t, 0) = x₀
-- Mathlib/Order/Monotone/Basic.lean
theorem Antitone.imp (hf : Antitone f) (h : a ≤ b) : f b ≤ f a
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem coe_rangeRestrictField (f : K →+* L) (x : K) : (f.rangeRestrictField x : L) = f x
-- Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean
lemma descFun_spec (f : c.pt → lc.pt) :
    f = descFun hc lc ↔ ∀ j, f ∘ c.ι.app j = lc.ι.app j ∘ ULift.up
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive]
theorem comap_sup_eq (H K : Subgroup N) (hf : Function.Surjective f) :
    comap f H ⊔ comap f K = comap f (H ⊔ K)
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
/-- The norm, relative to `ℤ`, of `ζ - 1` in a `p ^ (k + 1)`-th cyclotomic extension of `ℚ` is
a prime if `p ≠ 2`. -/
lemma prime_norm_toInteger_sub_one_of_prime_ne_two [hcycl : IsCyclotomicExtension {p ^ (k + 1)} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))) (hodd : p ≠ 2) :
    Prime (Algebra.norm ℤ (hζ.toInteger - 1))
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
/-- Nonzero integral ideals in a Dedekind domain are invertible.

We will use this to show that nonzero fractional ideals are invertible,
and finally conclude that fractional ideals in a Dedekind domain form a group with zero.
-/
theorem coe_ideal_mul_inv [h : IsDedekindDomain A] (I : Ideal A) (hI0 : I ≠ ⊥) :
    I * (I : FractionalIdeal A⁰ K)⁻¹ = 1
-- Mathlib/Data/List/Sublists.lean
@[simp]
theorem sublists'_singleton (a : α) : sublists' [a] = [[], [a]]
-- Mathlib/RingTheory/PowerSeries/Order.lean
/-- The order of the monomial `a*X^n` is infinite if `a = 0` and `n` otherwise. -/
theorem order_monomial (n : ℕ) (a : R) [Decidable (a = 0)] :
    order (monomial R n a) = if a = 0 then (⊤ : PartENat) else n
-- Mathlib/Data/Set/Lattice.lean
theorem biInter_insert (a : α) (s : Set α) (t : α → Set β) :
    ⋂ x ∈ insert a s, t x = t a ∩ ⋂ x ∈ s, t x
-- Mathlib/Data/Matroid/IndepAxioms.lean
/-- A collection of bases with the exchange property and at least one finite member is a matroid -/
@[simps! E] protected def ofExistsFiniteBase (E : Set α) (Base : Set α → Prop)
    (exists_finite_base : ∃ B, Base B ∧ B.Finite) (base_exchange : ExchangeProperty Base)
    (subset_ground : ∀ B, Base B → B ⊆ E) : Matroid α
-- Mathlib/Probability/Martingale/BorelCantelli.lean
theorem Submartingale.stoppedValue_leastGE_eLpNorm_le [IsFiniteMeasure μ] (hf : Submartingale f ℱ μ)
    (hr : 0 ≤ r) (hf0 : f 0 = 0) (hbdd : ∀ᵐ ω ∂μ, ∀ i, |f (i + 1) ω - f i ω| ≤ R) (i : ℕ) :
    eLpNorm (stoppedValue f (leastGE f r i)) 1 μ ≤ 2 * μ Set.univ * ENNReal.ofReal (r + R)
-- Mathlib/CategoryTheory/Sites/LocallyFullyFaithful.lean
@[simp]
lemma Functor.imageSieve_map {U V : C} (f : U ⟶ V) : G.imageSieve (G.map f) = ⊤
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
theorem boundedBy_apply (s : Set α) :
    boundedBy m s = ⨅ (t : ℕ → Set α) (_ : s ⊆ iUnion t),
                      ∑' n, ⨆ _ : (t n).Nonempty, m (t n)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_le_iff_forall_finset_subset_card_le {α : Type u} {n : ℕ} {t : Set α} :
    #t ≤ n ↔ ∀ s : Finset α, (s : Set α) ⊆ t → s.card ≤ n
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_sup (S T : Submonoid M) (f : F) : (S ⊔ T).map f = S.map f ⊔ T.map f
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
@[simp]
theorem coe_smul (r : S) (D : LieDerivation R L M) : ⇑(r • D) = r • ⇑D
-- Mathlib/Analysis/SpecificLimits/Normed.lean
@[simp]
theorem continuousAt_inv {𝕜 : Type*} [NontriviallyNormedField 𝕜] {x : 𝕜} :
    ContinuousAt Inv.inv x ↔ x ≠ 0
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp, norm_cast]
theorem coe_mk (I : Submodule R P) (hI : IsFractional S I) :
    coeToSubmodule ⟨I, hI⟩ = I
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem zero_mem_iff {a : A} : (0 : R) ∈ σ a ↔ ¬IsUnit a
-- Mathlib/Algebra/Group/Ext.lean
@[to_additive (attr := ext)]
theorem CommGroup.ext {G : Type*} ⦃g₁ g₂ : CommGroup G⦄ (h_mul : g₁.mul = g₂.mul) : g₁ = g₂
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- Replacing a set by its closure does not change the Hausdorff edistance. -/
@[simp]
theorem hausdorffEdist_closure₁ : hausdorffEdist (closure s) t = hausdorffEdist s t
-- Mathlib/Topology/Algebra/ContinuousMonoidHom.lean
/-- `ContinuousMonoidHomClass F A B` states that `F` is a type of continuous monoid
homomorphisms.

You should also extend this typeclass when you extend `ContinuousMonoidHom`. -/
-- Porting note: Changed A B to outParam to help synthesizing order
@[to_additive]
class ContinuousMonoidHomClass (A B : outParam Type*) [Monoid A] [Monoid B]
    [TopologicalSpace A] [TopologicalSpace B] [FunLike F A B]
    extends MonoidHomClass F A B : Prop where
  /-- Proof of the continuity of the map. -/
  map_continuous (f : F) : Continuous f
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive]
theorem _root_.SemiconjBy.op [Mul α] {a x y : α} (h : SemiconjBy a x y) :
    SemiconjBy (op a) (op y) (op x)
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
/-- The conditional cdf is non-negative for all `a : α`. -/
theorem condCDF_nonneg (ρ : Measure (α × ℝ)) (a : α) (r : ℝ) : 0 ≤ condCDF ρ a r
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/--
Accessing bits in `x.rotateLeft r` the range `[r, w)` is equal to
accessing bits `x` in the range `[0, w - r)`.

Proof by example:
Let x := <6 5 4 3 2 1 0> : BitVec 7.
x.rotateLeft 2 = (<6 5 | 4 3 2 1 0>).rotateLeft 2 = <3 2 1 0 | 6 5>

(x.rotateLeft 2).getLsb ⟨i, i ≥ 2⟩
= <3 2 1 0 | 6 5>.getLsb ⟨i, i ≥ 2⟩
= <3 2 1 0>[i - 2]
= <6 5 | 3 2 1 0>[i - 2]

Intuitively, grab the full width (7), then move the marker `|` by `r` to the right `(-2)`
Then, access the bit at `i` from the right `(+i)`.
 -/
theorem getLsb_rotateLeftAux_of_geq {x : BitVec w} {r : Nat} {i : Nat} (hi : i ≥ r) :
    (x.rotateLeftAux r).getLsb i = (decide (i < w) && x.getLsb (i - r))
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- See also the strictly more general `initial_iff_initial_comp` below. -/
theorem initial_iff_equivalence_comp [IsEquivalence F] : Initial G ↔ Initial (F ⋙ G)
-- Mathlib/Topology/MetricSpace/Contracting.lean
theorem dist_inequality (x y) : dist x y ≤ (dist x (f x) + dist y (f y)) / (1 - K)
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem symm_apply_apply (h : M ≃ₘ^n⟮I, J⟯ N) (x : M) : h.symm (h x) = x
-- Mathlib/NumberTheory/Padics/PadicVal.lean
theorem le_multiplicity_iff_replicate_subperm_primeFactorsList {a b : ℕ} {n : ℕ} (ha : a.Prime)
    (hb : b ≠ 0) :
    ↑n ≤ multiplicity a b ↔ replicate n a <+~ b.primeFactorsList
-- Mathlib/RingTheory/Algebraic.lean
lemma Algebra.isAlgebraic_def : Algebra.IsAlgebraic R A ↔ ∀ x : A, IsAlgebraic R x
-- Mathlib/Algebra/Order/Floor/Div.lean
@[simp] lemma ceilDiv_one [Nontrivial α] (b : β) : b ⌈/⌉ (1 : α) = b
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
lemma isClique_singleton (a : α) : G.IsClique {a}
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem add_smul [AddCommMonoid R] [SMulWithZero R V] {x y : HahnSeries Γ R}
    {z : HahnModule Γ' R V} (h : ∀ (r s : R) (u : V), (r + s) • u = r • u + s • u) :
    (x + y) • z = x • z + y • z
-- Mathlib/Analysis/Calculus/MeanValue.lean
theorem constant_of_derivWithin_zero (hdiff : DifferentiableOn ℝ f (Icc a b))
    (hderiv : ∀ x ∈ Ico a b, derivWithin f (Icc a b) x = 0) : ∀ x ∈ Icc a b, f x = f a
-- Mathlib/Topology/StoneCech.lean
theorem stoneCechExtend_extends : stoneCechExtend hg ∘ stoneCechUnit = g
-- Mathlib/Data/Vector/MapLemmas.lean
@[simp]
theorem mapAccumr₂_mapAccumr_left (f₁ : γ → β → σ₁ → σ₁ × ζ) (f₂ : α → σ₂ → σ₂ × γ) :
    (mapAccumr₂ f₁ (mapAccumr f₂ xs s₂).snd ys s₁)
    = let m := (mapAccumr₂ (fun x y s =>
          let r₂ := f₂ x s.snd
          let r₁ := f₁ r₂.snd y s.fst
          ((r₁.fst, r₂.fst), r₁.snd)
        ) xs ys (s₁, s₂))
      (m.fst.fst, m.snd)
-- Mathlib/RingTheory/Ideal/Colon.lean
theorem mem_colon' {r} : r ∈ N.colon P ↔ P ≤ comap (r • (LinearMap.id : M →ₗ[R] M)) N
-- Mathlib/Topology/Order/LeftRightLim.lean
/-- In a second countable space, the set of points where a monotone function is not continuous
is at most countable. -/
theorem countable_not_continuousAt [SecondCountableTopology β] :
    Set.Countable { x | ¬ContinuousAt f x }
-- Mathlib/Data/Complex/Exponential.lean
@[mono]
theorem exp_monotone : Monotone exp
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem coe_refl : ⇑(refl α) = id
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The kernel of `biproduct.π f i` is `⨁ Subtype.restrict {i}ᶜ f`. -/
@[simps!]
def kernelBiproductπIso : kernel (biproduct.π f i) ≅ ⨁ Subtype.restrict (fun j => j ≠ i) f
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem all (f) : ∀ {s}, ValidFor l m r s → s.all f = m.all f
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_le_symm : 𝓤 α ≤ @Prod.swap α α <$> 𝓤 α
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
@[simp]
theorem wideCospan_map_term {A : C} (s : Set (Subobject A)) (j) :
    (wideCospan s).map (WidePullbackShape.Hom.term j) =
      ((equivShrink (Subobject A)).symm j).arrow
-- Mathlib/Analysis/Complex/LocallyUniformLimit.lean
/-- The logarithmic derivative of a sequence of functions converging locally uniformly to a
function is the logarithmic derivative of the limit function. -/
theorem logDeriv_tendsto {ι : Type*} {p : Filter ι} (f : ι → ℂ → ℂ) (g : ℂ → ℂ)
    {s : Set ℂ} (hs : IsOpen s) (x : s) (hF : TendstoLocallyUniformlyOn f g p s)
    (hf : ∀ᶠ n : ι in p, DifferentiableOn ℂ (f n) s) (hg : g x ≠ 0) :
    Tendsto (fun n : ι => logDeriv (f n) x) p (𝓝 ((logDeriv g) x))
-- Mathlib/Topology/Spectral/Hom.lean
theorem copy_eq (f : SpectralMap α β) (f' : α → β) (h : f' = f) : f.copy f' h = f
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive (attr := simp)]
theorem measurable_inv_iff {G : Type*} [Group G] [MeasurableSpace G] [MeasurableInv G]
    {f : α → G} : (Measurable fun x => (f x)⁻¹) ↔ Measurable f
-- Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean
theorem eLpNorm'_trim (hm : m ≤ m0) {f : α → E} (hf : StronglyMeasurable[m] f) :
    eLpNorm' f q (μ.trim hm) = eLpNorm' f q μ
-- Mathlib/Algebra/Field/Defs.lean
@[simp]
theorem smul_one_eq_cast (A : Type*) [DivisionRing A] (m : ℚ) : m • (1 : A) = ↑m
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
/-- Composition of bimodule object morphisms. -/
@[simps]
def comp {M N O : Bimod A B} (f : Hom M N) (g : Hom N O) : Hom M O
-- Mathlib/Data/Nat/Log.lean
theorem log_of_left_le_one {b : ℕ} (hb : b ≤ 1) (n) : log b n = 0
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem llift_apply (f : X → M) (x : X →₀ R) : llift M R S X f x = lift M R X f x
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem iUnion_smul_eq_setOf_exists {s : Set β} : ⋃ g : α, g • s = { a | ∃ g : α, g • a ∈ s }
-- Mathlib/GroupTheory/Perm/Sign.lean
@[simp]
theorem sign_trans_trans_symm [DecidableEq β] [Fintype β] (f : Perm β) (e : α ≃ β) :
    sign ((e.trans f).trans e.symm) = sign f
-- Mathlib/Analysis/Asymptotics/Theta.lean
lemma IsTheta.isTheta_congr_right (h : f' =Θ[l] g') : k =Θ[l] f' ↔ k =Θ[l] g'
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem toCone_π_app (B : Bicone F) (j : Discrete J) : B.toCone.π.app j = B.π j.as
-- Mathlib/Data/Complex/Basic.lean
@[norm_cast] lemma ofReal_zsmul (n : ℤ) (r : ℝ) : ↑(n • r) = n • (r : ℂ)
-- Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean
theorem preimage_inversion_sphere_dist_center (hR : R ≠ 0) (hy : y ≠ c) :
    inversion c R ⁻¹' sphere y (dist y c) =
      insert c (perpBisector c (inversion c R y) : Set P)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp, norm_cast] lemma coe_abs (f : α →ᵇ β) : ⇑|f| = |⇑f|
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[reassoc (attr := simp)]
theorem colimit.pre_desc (c : Cocone F) :
    colimit.pre F E ≫ colimit.desc F c = colimit.desc (E ⋙ F) (c.whisker E)
-- Mathlib/Topology/Basic.lean
theorem Set.Finite.interior_sInter {S : Set (Set X)} (hS : S.Finite) :
    interior (⋂₀ S) = ⋂ s ∈ S, interior s
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
@[simp]
theorem unitization_apply (x : Unitization ℤ s) : unitization s x = x.fst + x.snd
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem image_erase [DecidableEq α] {f : α → β} (hf : Injective f) (s : Finset α) (a : α) :
    (s.erase a).image f = (s.image f).erase (f a)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem mem_Lp_of_ae_le {f : α →ₘ[μ] E} {g : Lp F p μ} (h : ∀ᵐ x ∂μ, ‖f x‖ ≤ ‖g x‖) :
    f ∈ Lp E p μ
-- Mathlib/Analysis/Normed/Group/AddCircle.lean
theorem norm_le_half_period {x : AddCircle p} (hp : p ≠ 0) : ‖x‖ ≤ |p| / 2
-- .lake/packages/lean4/src/lean/Init/WF.lean
theorem lexNdepWf {r  : α → α → Prop} {s : β → β → Prop} (ha : WellFounded r) (hb : WellFounded s) : WellFounded (lexNdep r s)
-- Mathlib/Order/Interval/Basic.lean
/-- Pushforward of nonempty intervals. -/
@[simps!]
def map (f : α →o β) (a : NonemptyInterval α) : NonemptyInterval β
-- Mathlib/Algebra/Ring/Basic.lean
lemma IsLeftCancelMulZero.to_noZeroDivisors [NonUnitalNonAssocRing α] [IsLeftCancelMulZero α] :
    NoZeroDivisors α
-- Mathlib/Data/Complex/Basic.lean
protected theorem ext_iff {z w : ℂ} : z = w ↔ z.re = w.re ∧ z.im = w.im
-- Mathlib/GroupTheory/Complement.lean
theorem equiv_fst_eq_self_of_mem_of_one_mem {g : G} (h1 : 1 ∈ T) (hg : g ∈ S) :
    (hST.equiv g).fst = ⟨g, hg⟩
-- Mathlib/Data/Multiset/Powerset.lean
theorem powerset_aux'_perm {l₁ l₂ : List α} (p : l₁ ~ l₂) : powersetAux' l₁ ~ powersetAux' l₂
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
theorem seminormAux_zero (k n : ℕ) : (0 : 𝓢(E, F)).seminormAux k n = 0
-- Mathlib/Topology/Order/LowerUpperTopology.lean
/-- A function `f : β → α` with upper topology in the codomain is continuous
provided that the preimage of every interval `Set.Iic a` is a closed set. -/
@[deprecated (since := "2023-12-24")]
lemma continuous_of_Iic [TopologicalSpace β] {f : β → α} (h : ∀ a, IsClosed (f ⁻¹' (Iic a))) :
    Continuous f
-- Mathlib/Logic/Function/Basic.lean
lemma factorsThrough_iff (g : α → γ) [Nonempty γ] : g.FactorsThrough f ↔ ∃ (e : β → γ), g = e ∘ f
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
    (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = ↑I ∩ { y | y i ≤ x }
-- Mathlib/RingTheory/Ideal/Over.lean
theorem isMaximal_of_isIntegral_of_isMaximal_comap [Algebra R S] [Algebra.IsIntegral R S]
    (I : Ideal S) [I.IsPrime] (hI : IsMaximal (I.comap (algebraMap R S))) : IsMaximal I
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem ofComplex_I : ofComplex Complex.I = ι Q 1
-- Mathlib/Order/Concept.lean
@[simp]
theorem sInf_fst (S : Set (Concept α β r)) : (sInf S).fst = ⋂ c ∈ S, (c : Concept _ _ _).fst
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem not_isLeftInversion_mul_right_iff {w : W}  :
    ¬cs.IsLeftInversion (t * w) t ↔ cs.IsLeftInversion w t
-- Mathlib/Order/GaloisConnection.lean
theorem l_inf_u [SemilatticeInf α] [SemilatticeInf β] (gi : GaloisInsertion l u) (a b : β) :
    l (u a ⊓ u b) = a ⊓ b
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem ι_ne_one [Nontrivial R] (x : M) : ι R x ≠ 1
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem gcd_fib_add_self (m n : ℕ) : gcd (fib m) (fib (n + m)) = gcd (fib m) (fib n)
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is a separable field extension of exponential characteristic `q`, then
`F(S) = F(S ^ (q ^ n))` for any subset `S` of `E` and any natural number `n`. -/
theorem adjoin_eq_adjoin_pow_expChar_pow_of_isSeparable' [Algebra.IsSeparable F E] (S : Set E)
    (q : ℕ) [ExpChar F q] (n : ℕ) : adjoin F S = adjoin F ((· ^ q ^ n) '' S)
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem HasFDerivAtFilter.isBigO_sub_rev (hf : HasFDerivAtFilter f f' x L) {C}
    (hf' : AntilipschitzWith C f') : (fun x' => x' - x) =O[L] fun x' => f x' - f x
-- Mathlib/Probability/Independence/Basic.lean
lemma IndepSets_iff (s1 s2 : Set (Set Ω)) (μ : Measure Ω) :
    IndepSets s1 s2 μ ↔ ∀ t1 t2 : Set Ω, t1 ∈ s1 → t2 ∈ s2 → (μ (t1 ∩ t2) = μ t1 * μ t2)
-- Mathlib/Topology/Instances/ENNReal.lean
@[simp] -- Porting note (#11215): TODO: generalize to `[InvolutiveInv _] [ContinuousInv _]`
protected theorem tendsto_inv_iff {f : Filter α} {m : α → ℝ≥0∞} {a : ℝ≥0∞} :
    Tendsto (fun x => (m x)⁻¹) f (𝓝 a⁻¹) ↔ Tendsto m f (𝓝 a)
-- Mathlib/ModelTheory/Substructures.lean
theorem subset_closure_withConstants : A ⊆ closure (L[[A]]) s
-- Mathlib/Analysis/Complex/AbelLimit.lean
lemma nhdsWithin_stolzCone_le_nhdsWithin_stolzSet {s : ℝ} (hs : 0 < s) :
    ∃ M, 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
-- Mathlib/Topology/UniformSpace/Compact.lean
/-- Heine-Cantor: a continuous function on a compact uniform space is uniformly
continuous. -/
theorem CompactSpace.uniformContinuous_of_continuous [CompactSpace α] {f : α → β}
    (h : Continuous f) : UniformContinuous f
-- Mathlib/Topology/Basic.lean
theorem isClosed_of_closure_subset (h : closure s ⊆ s) : IsClosed s
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[deprecated getElem?_modifyNth_eq (since := "2024-06-12")]
theorem get?_modifyNth_eq (f : α → α) (n) (l : List α) :
    (modifyNth f n l).get? n = f <$> l.get? n
-- Mathlib/Order/Interval/Set/Pi.lean
@[to_additive]
theorem image_mulSingle_Ioo_right (i : ι) (b : α i) :
    Pi.mulSingle i '' Ioo 1 b = Ioo 1 (Pi.mulSingle i b)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem ι_eq_zero : ι (0 : QuadraticForm R Unit) = 0
-- Mathlib/GroupTheory/Perm/Support.lean
theorem apply_mem_support {x : α} : f x ∈ f.support ↔ x ∈ f.support
-- Mathlib/Topology/LocallyFinite.lean
theorem LocallyFinite.eventually_subset {s : ι → Set X}
    (hs : LocallyFinite s) (hs' : ∀ i, IsClosed (s i)) (x : X) :
    ∀ᶠ y in 𝓝 x, {i | y ∈ s i} ⊆ {i | x ∈ s i}
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mul_lt_of_le_one_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b < c) (hb : 0 ≤ b) :
    a * b < c
-- Mathlib/Data/List/NodupEquivFin.lean
@[simp]
theorem coe_getIso_symm_apply : ((H.getIso l).symm x : ℕ) = indexOf (↑x) l
-- Mathlib/Analysis/SpecificLimits/Basic.lean
/-- If `edist (f n) (f (n+1))` is bounded by `C * 2^-n`, then the distance from
`f 0` to the limit of `f` is bounded above by `2 * C`. -/
theorem edist_le_of_edist_le_geometric_two_of_tendsto₀ : edist (f 0) a ≤ 2 * C
-- Mathlib/Algebra/Module/Submodule/LinearMap.lean
@[simp]
protected theorem coeSubtype : (SMulMemClass.subtype S' : S' → M) = Subtype.val
-- Mathlib/Order/BooleanAlgebra.lean
theorem compl_le_iff_compl_le : xᶜ ≤ y ↔ yᶜ ≤ x
-- Mathlib/LinearAlgebra/Pi.lean
@[simp]
theorem funUnique_apply (ι R M : Type*) [Unique ι] [Semiring R] [AddCommMonoid M] [Module R M] :
    (funUnique ι R M : (ι → M) → M) = eval default
-- Mathlib/LinearAlgebra/CrossProduct.lean
theorem cross_cross (u v w : Fin 3 → R) : u ×₃ v ×₃ w = u ×₃ (v ×₃ w) - v ×₃ (u ×₃ w)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
protected theorem append_reverseAux {u v w x : V}
    (p : G.Walk u v) (q : G.Walk v w) (r : G.Walk u x) :
    (p.append q).reverseAux r = q.reverseAux (p.reverseAux r)
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem mapRange_id (g : α →₀ M) : mapRange id rfl g = g
-- Mathlib/CategoryTheory/Opposites.lean
@[simp] theorem Quiver.Hom.unop_mk {X Y : Cᵒᵖ} (f : X ⟶ Y) : Quiver.Hom.unop {unop := f} = f
-- Mathlib/RingTheory/Norm/Basic.lean
theorem norm_eq_norm_adjoin [FiniteDimensional K L] [Algebra.IsSeparable K L] (x : L) :
    norm K x = norm K (AdjoinSimple.gen K x) ^ finrank K⟮x⟯ L
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem ConvexOn.quasiconvexOn (hf : ConvexOn 𝕜 s f) : QuasiconvexOn 𝕜 s f
-- Mathlib/FieldTheory/RatFunc/Basic.lean
/-- Induction principle for `RatFunc K`: if `f p q : P (p / q)` for all `p q : K[X]`,
then `P` holds on all elements of `RatFunc K`.

See also `induction_on'`, which is a recursion principle defined in terms of `RatFunc.mk`.
-/
protected theorem induction_on {P : RatFunc K → Prop} (x : RatFunc K)
    (f : ∀ (p q : K[X]) (hq : q ≠ 0), P (algebraMap _ (RatFunc K) p / algebraMap _ _ q)) : P x
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem reverse_injective {u v : V} : Function.Injective (reverse : G.Walk u v → _)
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem limit.pre_pre [h : HasLimit (D ⋙ E ⋙ F)] : haveI : HasLimit ((D ⋙ E) ⋙ F) := h
    limit.pre F E ≫ limit.pre (E ⋙ F) D = limit.pre F (D ⋙ E)
-- Mathlib/CategoryTheory/EssentiallySmall.lean
/-- A category is `w`-locally small if every hom set is `w`-small.

See `ShrinkHoms C` for a category instance where every hom set has been replaced by a small model.
-/
@[pp_with_univ]
class LocallySmall (C : Type u) [Category.{v} C] : Prop where
  /-- A locally small category has small hom-types. -/
  hom_small : ∀ X Y : C, Small.{w} (X ⟶ Y) := by infer_instance
-- Mathlib/Data/Num/Lemmas.lean
theorem ofNat'_bit (b n) : ofNat' (Nat.bit b n) = cond b Num.bit1 Num.bit0 (ofNat' n)
-- Mathlib/Topology/Order/ScottTopology.lean
@[simp] lemma toScott_ofScott (a : WithScott α) : toScott (ofScott a) = a
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsRelPrime.of_mul_add_right_left (h : IsRelPrime (z * y + x) y) : IsRelPrime x y
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Dvd.lean
@[simp] theorem mod_mod_of_dvd (a : Nat) (h : c ∣ b) : a % b % c = a % c
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem add_pow_add_pred_mem_of_pow_mem  {m n : ℕ}
    (ha : a ^ m ∈ I) (hb : b ^ n ∈ I) :
    (a + b) ^ (m + n - 1) ∈ I
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem toBilin'Aux_toMatrixAux [DecidableEq n] (B₂ : BilinForm R₂ (n → R₂)) :
    -- Porting note: had to hint the base ring even though it should be clear from context...
    Matrix.toBilin'Aux (BilinForm.toMatrixAux (R₂ := R₂)
      (fun j => stdBasis R₂ (fun _ => R₂) j 1) B₂) = B₂
-- Mathlib/NumberTheory/LSeries/Convergence.lean
/-- If `f` is `O(1)`, then the abscissa of absolute convergence of `f` is bounded above by `1`. -/
lemma LSeries.abscissaOfAbsConv_le_one_of_isBigO_one {f : ℕ → ℂ} (h : f =O[atTop] (1 : ℕ → ℝ)) :
    abscissaOfAbsConv f ≤ 1
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_succ_of_le (p i : Fin n) (h : p ≤ i) : p.predAbove (succ i) = i
-- Mathlib/Topology/StoneCech.lean
/-- The value of `Ultrafilter.extend f` on an ultrafilter `b` is the
  unique limit of the ultrafilter `b.map f` in `γ`. -/
theorem ultrafilter_extend_eq_iff {f : α → γ} {b : Ultrafilter α} {c : γ} :
    Ultrafilter.extend f b = c ↔ ↑(b.map f) ≤ 𝓝 c
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean
@[measurability]
theorem Measurable.cos : Measurable fun x => Real.cos (f x)