ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem or_iff_left_iff_imp  : (a ∨ b ↔ a) ↔ (b → a)
-- Mathlib/Data/PNat/Factors.lean
theorem coeNat_ofPrime (p : Nat.Primes) : (ofPrime p : Multiset ℕ) = {(p : ℕ)}
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem emod_sub_cancel_right {m n k : Int} (i) : (m - i) % n = (k - i) % n ↔ m % n = k % n
-- Mathlib/Data/Multiset/Powerset.lean
@[simp]
theorem powersetCardAux_nil (n : ℕ) : powersetCardAux (n + 1) (@nil α) = []
-- Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean
/-- Given `α : F ⟶ L ⋙ F'`, the property `F'.IsLeftKanExtension α` asserts that
`(F', α)` is an initial object in the category `LeftExtension L F`, i.e. that `(F', α)`
is a left Kan extension of `F` along `L`. -/
class IsLeftKanExtension : Prop where
  nonempty_isUniversal : Nonempty (LeftExtension.mk F' α).IsUniversal
-- Mathlib/Order/Synonym.lean
@[simp]
theorem ofDual_symm_eq : (@ofDual α).symm = toDual
-- Mathlib/RingTheory/Localization/Module.lean
theorem LinearIndependent.iff_fractionRing {ι : Type*} {b : ι → V} :
    LinearIndependent R b ↔ LinearIndependent K b
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
theorem carrier.asIdeal.prime : (carrier.asIdeal f_deg hm q).IsPrime
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem iff_true_intro (h : a) : a ↔ True
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- Surjective monoid homomorphisms constant on a congruence relation `c`'s equivalence classes
    induce a surjective homomorphism on `c`'s quotient. -/
@[to_additive "Surjective `AddMonoid` homomorphisms constant on an additive congruence
relation `c`'s equivalence classes induce a surjective homomorphism on `c`'s quotient."]
theorem lift_surjective_of_surjective (h : c ≤ ker f) (hf : Surjective f) :
    Surjective (c.lift f h)
-- Mathlib/Analysis/Calculus/LHopital.lean
theorem lhopital_zero_right_on_Ioo (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x)
    (hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x) (hg' : ∀ x ∈ Ioo a b, g' x ≠ 0)
    (hfa : Tendsto f (𝓝[>] a) (𝓝 0)) (hga : Tendsto g (𝓝[>] a) (𝓝 0))
    (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[>] a) l) :
    Tendsto (fun x => f x / g x) (𝓝[>] a) l
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem isAdjointPair_iff_comp_eq_compl₂ : IsAdjointPair B B' f g ↔ B'.comp f = B.compl₂ g
-- Mathlib/Topology/Basic.lean
@[simp]
theorem lift'_nhds_interior (x : X) : (𝓝 x).lift' interior = 𝓝 x
-- Mathlib/Data/Nat/Pairing.lean
theorem pair_unpair' {n a b} (H : unpair n = (a, b)) : pair a b = n
-- Mathlib/Topology/Order/ScottTopology.lean
/-- Predicate for an ordered topological space to be equipped with its Scott-Hausdorff topology.

A set `u` is open in the Scott-Hausdorff topology iff when the least upper bound of a directed set
`d` lies in `u` then there is a tail of `d` which is a subset of `u`. -/
class IsScottHausdorff : Prop where
  topology_eq_scottHausdorff : ‹TopologicalSpace α› = scottHausdorff α
-- Mathlib/Algebra/Order/Monovary.lean
lemma Monovary.mul_left₀ (hf₁ : 0 ≤ f₁) (hf₂ : 0 ≤ f₂) (h₁ : Monovary f₁ g) (h₂ : Monovary f₂ g) :
    Monovary (f₁ * f₂) g
-- Mathlib/Order/SetNotation.lean
@[simp]
theorem mem_iUnion {x : α} {s : ι → Set α} : (x ∈ ⋃ i, s i) ↔ ∃ i, x ∈ s i
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem ofFin_le (x : Fin (2^n)) (y : BitVec n) :
  BitVec.ofFin x ≤ y ↔ x ≤ y.toFin
-- Mathlib/Data/Nat/Totient.lean
/-- Note this takes an explicit `Fintype ((ZMod n)ˣ)` argument to avoid trouble with instance
diamonds. -/
@[simp]
theorem _root_.ZMod.card_units_eq_totient (n : ℕ) [NeZero n] [Fintype (ZMod n)ˣ] :
    Fintype.card (ZMod n)ˣ = φ n
-- Mathlib/Data/Setoid/Partition.lean
theorem mem_classes (r : Setoid α) (y) : { x | r.Rel x y } ∈ r.classes
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem B_mem_nhdsWithin_Ioi {K : Set F} {r s ε x : ℝ} (hx : x ∈ B f K r s ε) :
    B f K r s ε ∈ 𝓝[>] x
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem rTensor_comp : (g.comp f).rTensor M = (g.rTensor M).comp (f.rTensor M)
-- Mathlib/Data/PFunctor/Multivariate/M.lean
theorem M.dest_corec {α : TypeVec n} {β : Type u} (g : β → P (α.append1 β)) (x : β) :
    M.dest P (M.corec P g x) = appendFun id (M.corec P g) <$$> g x
-- Mathlib/LinearAlgebra/Span.lean
theorem apply_mem_span_image_iff_mem_span [RingHomSurjective σ₁₂] {f : F} {x : M}
    {s : Set M} (hf : Function.Injective f) :
    f x ∈ Submodule.span R₂ (f '' s) ↔ x ∈ Submodule.span R s
-- Mathlib/Analysis/Convolution.lean
theorem ConvolutionExistsAt.integrable [Sub G] {x : G} (h : ConvolutionExistsAt f g x L μ) :
    Integrable (fun t => L (f t) (g (x - t))) μ
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem card_Ioi_eq_card_Ici_sub_one (a : α) : (Ioi a).card = (Ici a).card - 1
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedSeries_eq_top (n : ℕ) (h : derivedSeries R L 1 = ⊤) :
    derivedSeries R L n = ⊤
-- Mathlib/Data/List/Sublists.lean
theorem sublists'Aux_eq_array_foldl (a : α) : ∀ (r₁ r₂ : List (List α)),
    sublists'Aux a r₁ r₂ = ((r₁.toArray).foldl (init := r₂.toArray)
      (fun r l => r.push (a :: l))).toList
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem lift.of_eq (x : FreeGroup α) : lift FreeGroup.of x = x
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem natTrailingDegree_mul [NoZeroDivisors R] (hp : p ≠ 0) (hq : q ≠ 0) :
    (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
theorem integral_congr {f g : ℂ → E} {c : ℂ} {R : ℝ} (hR : 0 ≤ R) (h : EqOn f g (sphere c R)) :
    (∮ z in C(c, R), f z) = ∮ z in C(c, R), g z
-- Mathlib/RingTheory/Noetherian.lean
/-- If `∀ I > J, P I` implies `P J`, then `P` holds for all submodules. -/
theorem IsNoetherian.induction [IsNoetherian R M] {P : Submodule R M → Prop}
    (hgt : ∀ I, (∀ J > I, P J) → P I) (I : Submodule R M) : P I
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@[simp] lemma FGModuleCatDual_obj : (FGModuleCatDual K V).obj = ModuleCat.of K (Module.Dual K V)
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma IsUnramifiedAtInfinitePlaces.trans
    [h₁ : IsUnramifiedAtInfinitePlaces k K] [h₂ : IsUnramifiedAtInfinitePlaces K F] :
    IsUnramifiedAtInfinitePlaces k F
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem getElem_splitWrtCompositionAux (l : List α) (ns : List ℕ) {i : ℕ}
    (hi : i < (l.splitWrtCompositionAux ns).length) :
    (l.splitWrtCompositionAux ns)[i] =
      (l.take (ns.take (i + 1)).sum).drop (ns.take i).sum
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
lemma dist_inr (a b : A) : dist (a : Unitization 𝕜 A) (b : Unitization 𝕜 A) = dist a b
-- Mathlib/Order/Filter/Subsingleton.lean
theorem subsingleton_iff_exists_singleton_mem [Nonempty α] : l.Subsingleton ↔ ∃ a, {a} ∈ l
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
/-- If `f` is a smooth partition of unity on a set `s : Set M` subordinate to a family of open sets
`U : ι → Set M` and `g : ι → M → F` is a family of functions such that `g i` is smooth on `U i`,
then the sum `fun x ↦ ∑ᶠ i, f i x • g i x` is smooth on the whole manifold. -/
theorem IsSubordinate.smooth_finsum_smul {g : ι → M → F} (hf : f.IsSubordinate U)
    (ho : ∀ i, IsOpen (U i)) (hg : ∀ i, SmoothOn I 𝓘(ℝ, F) (g i) (U i)) :
    Smooth I 𝓘(ℝ, F) fun x => ∑ᶠ i, f i x • g i x
-- Mathlib/RingTheory/Multiplicity.lean
theorem multiplicity_add_eq_min {p a b : α} (h : multiplicity p a ≠ multiplicity p b) :
    multiplicity p (a + b) = min (multiplicity p a) (multiplicity p b)
-- Mathlib/Algebra/GradedMonoid.lean
@[simp] theorem snd_smul [∀ i, SMul α (A i)] (a : α) (x : GradedMonoid A) :
    (a • x).snd = a • x.snd
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
theorem _root_.AlgebraicGeometry.isIso_iff_stalk_iso {X Y : Scheme.{u}} (f : X ⟶ Y) :
    IsIso f ↔ IsIso f.1.base ∧ ∀ x, IsIso (f.stalkMap x)
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
@[simp]
lemma lift_comp_eqToHom_iff {R S S' : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) (h : S = S') :
    p.IsHomLift (f ≫ eqToHom h) φ ↔ p.IsHomLift f φ
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
theorem WalkingParallelPairHom.comp_id
    {X Y : WalkingParallelPair} (f : WalkingParallelPairHom X Y) : comp f (id Y) = f
-- Mathlib/RingTheory/MvPowerSeries/Basic.lean
@[simp, norm_cast]
theorem coe_add : ((φ + ψ : MvPolynomial σ R) : MvPowerSeries σ R) = φ + ψ
-- Mathlib/RingTheory/SimpleModule.lean
lemma isSemisimpleModule_biSup_of_isSemisimpleModule_submodule {s : Set ι} {p : ι → Submodule R M}
    (hp : ∀ i ∈ s, IsSemisimpleModule R (p i)) :
    IsSemisimpleModule R ↥(⨆ i ∈ s, p i)
-- Mathlib/Data/List/Lemmas.lean
theorem foldr_range_eq_of_range_eq {f : β → α → α} {g : γ → α → α} (hfg : Set.range f = Set.range g)
    (a : α) : Set.range (foldr f a) = Set.range (foldr g a)
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem zipRight'_nil_right : zipRight' as ([] : List β) = ([], as)
-- Mathlib/Data/Set/Lattice.lean
theorem inter_empty_of_inter_sUnion_empty {s t : Set α} {S : Set (Set α)} (hs : t ∈ S)
    (h : s ∩ ⋃₀S = ∅) : s ∩ t = ∅
-- Mathlib/Data/Multiset/Basic.lean
theorem filter_eq_nil {s} : filter p s = 0 ↔ ∀ a ∈ s, ¬p a
-- Mathlib/LinearAlgebra/TensorProduct/Subalgebra.lean
/-- If `A` and `B` are subalgebras of a commutative `R`-algebra `S`, both of them are
free `R`-algebras, then the `FiniteDimensional.finrank` of `A ⊔ B` is less than or equal to
the product of that of `A` and `B`. -/
theorem finrank_sup_le_of_free [Module.Free R A] [Module.Free R B] :
    finrank R ↥(A ⊔ B) ≤ finrank R A * finrank R B
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem support_rotate {u v : V} (c : G.Walk v v) (h : u ∈ c.support) :
    (c.rotate h).support.tail ~r c.support.tail
-- Mathlib/RingTheory/Ideal/IsPrincipal.lean
@[simp]
theorem associatesEquivIsPrincipal_symm_apply {I : Ideal R} (hI : IsPrincipal I) :
    (associatesEquivIsPrincipal R).symm ⟨I, hI⟩ = .mk hI.generator
-- Mathlib/Data/Nat/Factorial/Basic.lean
@[simp] theorem factorial_two : 2! = 2
-- Mathlib/RingTheory/Ideal/Norm.lean
theorem absNorm_dvd_norm_of_mem {I : Ideal S} {x : S} (h : x ∈ I) :
    ↑(Ideal.absNorm I) ∣ Algebra.norm ℤ x
-- Mathlib/CategoryTheory/Shift/Localization.lean
lemma shiftFunctor_comp_inverts (a : A) :
    W.IsInvertedBy (shiftFunctor C a ⋙ L)
-- Mathlib/Data/NNReal/Basic.lean
theorem sub_def {r p : ℝ≥0} : r - p = Real.toNNReal (r - p)
-- Mathlib/LinearAlgebra/QuadraticForm/TensorProduct/Isometries.lean
@[simp]
theorem tmul_comp_tensorAssoc
    (Q₁ : QuadraticForm R M₁) (Q₂ : QuadraticForm R M₂) (Q₃ : QuadraticForm R M₃) :
    (Q₁.tmul (Q₂.tmul Q₃)).comp (TensorProduct.assoc R M₁ M₂ M₃) = (Q₁.tmul Q₂).tmul Q₃
-- Mathlib/Data/List/Permutation.lean
theorem map_map_permutations'Aux (f : α → β) (t : α) (ts : List α) :
    map (map f) (permutations'Aux t ts) = permutations'Aux (f t) (map f ts)
-- Mathlib/Algebra/FreeAlgebra.lean
@[simp]
theorem adjoin_range_ι : Algebra.adjoin R (Set.range (ι R : X → FreeAlgebra R X)) = ⊤
-- Mathlib/CategoryTheory/LiftingProperties/Adjunction.lean
/-- When we have an adjunction `G ⊣ F`, any commutative square where the left
map is of the form `G.map i` and the right map is `p` has an "adjoint" commutative
square whose left map is `i` and whose right map is `F.map p`. -/
theorem right_adjoint (sq : CommSq u (G.map i) p v) (adj : G ⊣ F) :
    CommSq (adj.homEquiv _ _ u) i (F.map p) (adj.homEquiv _ _ v)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma coeff_preΨ_ne_zero {n : ℤ} (h : (n : R) ≠ 0) :
    (W.preΨ n).coeff ((n.natAbs ^ 2 - if Even n then 4 else 1) / 2) ≠ 0
-- Mathlib/CategoryTheory/Category/Basic.lean
/-- precompose an equation between morphisms by another morphism -/
theorem whisker_eq (f : X ⟶ Y) {g h : Y ⟶ Z} (w : g = h) : f ≫ g = f ≫ h
-- Mathlib/Data/Rat/Lemmas.lean
@[simp]
theorem inv_intCast_num (a : ℤ) : (a : ℚ)⁻¹.num = Int.sign a
-- Mathlib/Algebra/Group/Nat.lean
@[parity_simps] lemma even_mul : Even (m * n) ↔ Even m ∨ Even n
-- Mathlib/Order/Sublattice.lean
@[simp] lemma mem_comap {L : Sublattice β} : a ∈ L.comap f ↔ f a ∈ L
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
/-- Mixin for a `VectorPrebundle` stating smoothness of coordinate changes. -/
class IsSmooth (a : VectorPrebundle 𝕜 F E) : Prop where
  exists_smoothCoordChange :
    ∀ᵉ (e ∈ a.pretrivializationAtlas) (e' ∈ a.pretrivializationAtlas),
      ∃ f : B → F →L[𝕜] F,
        SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) f (e.baseSet ∩ e'.baseSet) ∧
          ∀ (b : B) (_ : b ∈ e.baseSet ∩ e'.baseSet) (v : F),
            f b v = (e' ⟨b, e.symm b v⟩).2
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
theorem eLpNormEssSup_mono_nnnorm_ae {f g : α → F} (hfg : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ ‖g x‖₊) :
    eLpNormEssSup f μ ≤ eLpNormEssSup g μ
-- Mathlib/Analysis/Calculus/Dslope.lean
theorem ContinuousOn.of_dslope (h : ContinuousOn (dslope f a) s) : ContinuousOn f s
-- Mathlib/RingTheory/LocalProperties.lean
theorem localization_finiteType : RingHom.LocalizationPreserves @RingHom.FiniteType
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem stopPos : ∀ {s}, ValidFor l m r s → s.stopPos = ⟨utf8Len l + utf8Len m⟩
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem Monic.geom_sum {P : R[X]} (hP : P.Monic) (hdeg : 0 < P.natDegree) {n : ℕ} (hn : n ≠ 0) :
    (∑ i ∈ range n, P ^ i).Monic
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[simp]
lemma rightHomologyMap'_zero (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData) :
    rightHomologyMap' 0 h₁ h₂ = 0
-- Mathlib/Data/Fin/Basic.lean
theorem forall_fin_succ' {P : Fin (n + 1) → Prop} :
    (∀ i, P i) ↔ (∀ i : Fin n, P i.castSucc) ∧ P (.last _)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem smul_modByMonic (c : R) (p : R[X]) : c • p %ₘ q = c • (p %ₘ q)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma bot_ne_natCast (n : ℕ) : (⊥ : WithBot α) ≠ n
-- Mathlib/Data/Real/EReal.lean
protected theorem zero_mul : ∀ x : EReal, 0 * x = 0
-- Mathlib/CategoryTheory/Sites/Whiskering.lean
/-- The multicospan associated to a cover `S : J.Cover X` and a presheaf of the form `P ⋙ F`
is isomorphic to the composition of the multicospan associated to `S` and `P`,
composed with `F`. -/
@[simps!]
def multicospanComp : (S.index (P ⋙ F)).multicospan ≅ (S.index P).multicospan ⋙ F
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_mul_mul_comm (a b c d : G) : a * b * (c * d) = a * c * (b * d)
-- Mathlib/Order/CompleteLattice.lean
@[simp]
theorem iSup_apply {α : Type*} {β : α → Type*} {ι : Sort*} [∀ i, SupSet (β i)] {f : ι → ∀ a, β a}
    {a : α} : (⨆ i, f i) a = ⨆ i, f i a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean
theorem Complex.cos_eq_tsum (z : ℂ) :
    Complex.cos z = ∑' n : ℕ, (-1) ^ n * z ^ (2 * n) / ↑(2 * n)!
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem cramerMap_is_linear (i : n) : IsLinearMap α fun b => cramerMap A b i
-- Mathlib/Algebra/MvPolynomial/Counit.lean
theorem counitNat_C (n : ℕ) : counitNat A (C n) = n
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/--
The equivalence `WalkingParallelPair ⥤ WalkingParallelPairᵒᵖ` sending left to left and right to
right.
-/
@[simps functor inverse]
def walkingParallelPairOpEquiv : WalkingParallelPair ≌ WalkingParallelPairᵒᵖ
-- Mathlib/Algebra/Ring/CentroidHom.lean
lemma centroid_eq_centralizer_mulLeftRight :
    RingHom.rangeS (toEndRingHom α) = Subsemiring.centralizer (Set.range L ∪ Set.range R)
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem darts_cons {u v w : V} (h : G.Adj u v) (p : G.Walk v w) :
    (cons h p).darts = ⟨(u, v), h⟩ :: p.darts
-- Mathlib/Data/Nat/Bits.lean
theorem bit_ne_zero (b) {n} (h : n ≠ 0) : bit b n ≠ 0
-- Mathlib/Order/CompleteLatticeIntervals.lean
theorem subset_sSup_emptyset [Inhabited s] :
    sSup (∅ : Set s) = default
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem principal_univ : 𝓟 (univ : Set α) = ⊤
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_findGreatest' {p : α → ℕ → Prop} [∀ x, DecidablePred (p x)] {N : ℕ}
    (hN : ∀ k ≤ N, MeasurableSet { x | Nat.findGreatest (p x) N = k }) :
    Measurable fun x => Nat.findGreatest (p x) N
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
/-- Given an orthogonal basis with respect to a bilinear map, the bilinear map is nondegenerate
if the basis has no elements which are self-orthogonal. -/
theorem IsOrthoᵢ.nondegenerate_of_not_isOrtho_basis_self [NoZeroSMulDivisors R M₁]
    {B : M →ₗ[R] M →ₗ[R] M₁} (v : Basis n R M) (hO : B.IsOrthoᵢ v)
    (h : ∀ i, ¬B.IsOrtho (v i) (v i)) : B.Nondegenerate
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fst_comp_inr [Zero R] : fst ∘ (inr : M → tsze R M) = 0
-- Mathlib/Analysis/SpecialFunctions/JapaneseBracket.lean
theorem integrable_rpow_neg_one_add_norm_sq {r : ℝ} (hnr : (finrank ℝ E : ℝ) < r) :
    Integrable (fun x ↦ ((1 : ℝ) + ‖x‖ ^ 2) ^ (-r / 2)) μ
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem map' {f : A →ₐ[R] A'} (hf_inj : Injective f) : AlgebraicIndependent R (f ∘ x)
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMax.comp_antitone (hf : IsLocalMax f a) {g : β → γ} (hg : Antitone g) :
    IsLocalMin (g ∘ f) a
-- Mathlib/Logic/Equiv/Set.lean
/-- Alias for `Equiv.image_eq_preimage` -/
theorem _root_.Set.preimage_equiv_eq_image_symm {α β} (S : Set α) (f : β ≃ α) :
    f ⁻¹' S = f.symm '' S
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
/-- Expansion of `log (1 + a⁻¹)` as a series in powers of `1 / (2 * a + 1)`. -/
theorem hasSum_log_one_add_inv {a : ℝ} (h : 0 < a) :
    HasSum (fun k : ℕ => (2 : ℝ) * (1 / (2 * k + 1)) * (1 / (2 * a + 1)) ^ (2 * k + 1))
      (log (1 + a⁻¹))
-- Mathlib/FieldTheory/SeparableClosure.lean
theorem lift_sepDegree_bot' : Cardinal.lift.{v} (sepDegree F (⊥ : IntermediateField E K)) =
    Cardinal.lift.{w} (sepDegree F E)
-- Mathlib/Algebra/Group/Fin/Tuple.lean
@[to_additive (attr := simp)]
lemma insertNth_div_same [∀ j, Group (α j)] (i : Fin (n + 1)) (x y : α i)
    (p : ∀ j, α (i.succAbove j)) : i.insertNth x p / i.insertNth y p = Pi.mulSingle i (x / y)
-- Mathlib/Data/Fintype/Card.lean
/-- See also `nonempty_encodable`, `nonempty_denumerable`. -/
theorem nonempty_fintype (α : Type*) [Finite α] : Nonempty (Fintype α)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive (attr := simp)]
theorem preimage_mul_right_one : preimage 1 (· * b) (mul_left_injective _).injOn = {b⁻¹}
-- Mathlib/RingTheory/PiTensorProduct.lean
protected lemma one_mul (x : ⨂[R] i, A i) : mul (tprod R 1) x = x
-- Mathlib/Data/List/Basic.lean
theorem indexOf_eq_length {a : α} {l : List α} : indexOf a l = length l ↔ a ∉ l
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Increment.lean
/-- The increment partition has a prescribed (very big) size in terms of the original partition. -/
theorem card_increment (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α) (hPG : ¬P.IsUniform G ε) :
    (increment hP G ε).parts.card = stepBound P.parts.card
-- Mathlib/Topology/Category/TopCat/EpiMono.lean
theorem mono_iff_injective {X Y : TopCat.{u}} (f : X ⟶ Y) : Mono f ↔ Function.Injective f
-- Mathlib/Topology/Algebra/FilterBasis.lean
@[to_additive]
theorem conj : ∀ x₀, ∀ {U}, U ∈ B → ∃ V ∈ B, V ⊆ (fun x ↦ x₀ * x * x₀⁻¹) ⁻¹' U
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Icc : (some : α → WithTop α) ⁻¹' Icc a b = Icc a b
-- Mathlib/Algebra/MvPolynomial/Division.lean
@[simp]
theorem coeff_divMonomial (s : σ →₀ ℕ) (x : MvPolynomial σ R) (s' : σ →₀ ℕ) :
    coeff s' (x /ᵐᵒⁿᵒᵐⁱᵃˡ s) = coeff (s + s') x
-- Mathlib/Data/Real/ConjExponents.lean
lemma one_sub_inv : 1 - p⁻¹ = q⁻¹
-- Mathlib/Data/FunLike/Embedding.lean
protected theorem injective (f : F) : Function.Injective f
-- Mathlib/Algebra/Ring/Units.lean
@[field_simps]
theorem divp_add (a b : α) (u : αˣ) : a /ₚ u + b = (a + b * u) /ₚ u
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem _root_.List.length_toAssocList (l : List (α × β)) :
    l.toAssocList.length = l.length
-- Mathlib/CategoryTheory/Generator.lean
theorem isSeparator_sigma_of_isSeparator {β : Type w} (f : β → C) [HasCoproduct f] (b : β)
    (hb : IsSeparator (f b)) : IsSeparator (∐ f)
-- Mathlib/CategoryTheory/WithTerminal.lean
/-- The prelax functor from `Cat` to `Cat` defined with `WithTerminal`. -/
@[simps]
def prelaxfunctor : PrelaxFunctor Cat Cat
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.balanceL_aux {l} {x : α} {r o₁ o₂} (hl : Valid' o₁ l x) (hr : Valid' x r o₂)
    (H₁ : size l = 0 → size r ≤ 1) (H₂ : 1 ≤ size l → 1 ≤ size r → size r ≤ delta * size l)
    (H₃ : 2 * @size α l ≤ 9 * size r + 5 ∨ size l ≤ 3) : Valid' o₁ (@balanceL α l x r) o₂
-- Mathlib/Data/Sym/Basic.lean
@[simp] theorem toMultiset_zero : toMultiset (0 : Sym α 0) = 0
-- Mathlib/Analysis/Convolution.lean
/-- The convolution is continuous if one function is locally integrable and the other has compact
support and is continuous. -/
theorem _root_.HasCompactSupport.continuous_convolution_right (hcg : HasCompactSupport g)
    (hf : LocallyIntegrable f μ) (hg : Continuous g) : Continuous (f ⋆[L, μ] g)
-- Mathlib/Tactic/NormNum/Prime.lean
theorem isNat_minFac_2 : {a a' : ℕ} → IsNat a a' → a' % 2 = 0 → IsNat a.minFac 2
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Ne.intro (h : a = b → False) : a ≠ b
-- Mathlib/Topology/Instances/Matrix.lean
theorem HasSum.matrix_blockDiagonal [DecidableEq p] {f : X → p → Matrix m n R}
    {a : p → Matrix m n R} (hf : HasSum f a) :
    HasSum (fun x => blockDiagonal (f x)) (blockDiagonal a)
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma rnDeriv_add_singularPart (μ ν : Measure α) [HaveLebesgueDecomposition μ ν] :
    ν.withDensity (μ.rnDeriv ν) + μ.singularPart ν = μ
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nadd_left_cancel_iff : ∀ {a b c}, a ♯ b = a ♯ c ↔ b = c
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The minimal distance to a set (as `ℝ≥0`) is Lipschitz in point with constant 1 -/
theorem lipschitz_infNndist_pt (s : Set α) : LipschitzWith 1 fun x => infNndist x s
-- Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
theorem PiToModule.fromEnd_injective (hb : Submodule.span R (Set.range b) = ⊤) :
    Function.Injective (PiToModule.fromEnd R b)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive (attr := simp)]
lemma prod_attach_univ [Fintype ι] (f : {i // i ∈ @univ ι _} → α) :
    ∏ i ∈ univ.attach, f i = ∏ i, f ⟨i, mem_univ _⟩
-- Mathlib/Data/Set/Function.lean
@[simp]
theorem piecewise_eq_of_not_mem {i : α} (hi : i ∉ s) : s.piecewise f g i = g i
-- Mathlib/Init/Logic.lean
theorem of_heq_true {a : Prop} (h : HEq a True) : a
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
@[simp, mfld_simps]
theorem tangentMap_id : tangentMap I I (id : M → M) = id
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem cons_inj_right (a : α) : ∀ {s t : Multiset α}, a ::ₘ s = a ::ₘ t ↔ s = t
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem compQuasiMeasurePreserving_toGerm [MeasurableSpace β] {f : α → β} {ν}
    (g : β →ₘ[ν] γ) (hf : Measure.QuasiMeasurePreserving f μ ν) :
    (g.compQuasiMeasurePreserving f hf).toGerm = g.toGerm.compTendsto f hf.tendsto_ae
-- Mathlib/Computability/TMToPartrec.lean
theorem splitAtPred_false {α} (L : List α) : splitAtPred (fun _ => false) L = (L, none, [])
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
/-- An element `a` divides the difference `b - a` if and only if `a` divides `b`. -/
@[simp]
theorem dvd_sub_self_right : a ∣ b - a ↔ a ∣ b
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem eq_bot_iff_forall : S = ⊥ ↔ ∀ x ∈ S, x = (1 : M)
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
@[simp]
theorem map_sub [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (x y : M₁ i) :
    f (update m i (x - y)) = f (update m i x) - f (update m i y)
-- Mathlib/Analysis/Analytic/Inverse.lean
@[simp]
theorem rightInv_coeff_zero (p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) :
    p.rightInv i 0 = 0
-- Mathlib/Data/Matrix/Basic.lean
protected theorem mul_assoc (L : Matrix l m α) (M : Matrix m n α) (N : Matrix n o α) :
    L * M * N = L * (M * N)
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
theorem sign_of_cycleType (f : Perm α) :
    sign f = (-1 : ℤˣ) ^ (f.cycleType.sum + Multiset.card f.cycleType)