ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/FieldTheory/Extension.lean
/-- Let `K/F` be an algebraic extension of fields and `L` a field in which all the minimal
polynomial over `F` of elements of `K` splits. Then, for `x ∈ K`, the images of `x` by the
`F`-algebra morphisms from `K` to `L` are exactly the roots in `L` of the minimal polynomial
of `x` over `F`. -/
theorem Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly_of_splits {F K : Type*} (L : Type*)
    [Field F] [Field K] [Field L] [Algebra F L] [Algebra F K]
    (hA : ∀ x : K, (minpoly F x).Splits (algebraMap F L))
    [Algebra.IsAlgebraic F K] (x : K) :
    (Set.range fun (ψ : K →ₐ[F] L) => ψ x) = (minpoly F x).rootSet L
-- Mathlib/Order/Max.lean
@[simp]
theorem not_isMin [NoMinOrder α] (a : α) : ¬IsMin a
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem associated_gcd_right_iff [GCDMonoid α] {x y : α} : Associated y (gcd x y) ↔ y ∣ x
-- Mathlib/Data/Complex/Abs.lean
@[simp]
theorem abs_I : Complex.abs I = 1
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem sup_eq_lsub_iff_succ {ι : Type u} (f : ι → Ordinal.{max u v}) :
    sup.{_, v} f = lsub.{_, v} f ↔ ∀ a < lsub.{_, v} f, succ a < lsub.{_, v} f
-- Mathlib/RingTheory/Ideal/Quotient.lean
@[simp]
lemma mk_singleton_self (x : R) : mk (Ideal.span {x}) x = 0
-- Mathlib/Data/Matroid/Map.lean
lemma restrictSubtype_dual' (hM : M.E = E) : (M.restrictSubtype E)✶ = M✶.restrictSubtype E
-- Mathlib/Data/Real/Sqrt.lean
@[simp]
theorem sqrt_zero : √0 = 0
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
/-- A point `c` belongs the perpendicular bisector of `[p₁, p₂] iff `p₂ -ᵥ p₁` is orthogonal to
`c -ᵥ midpoint ℝ p₁ p₂`. -/
theorem mem_perpBisector_iff_inner_eq_zero' :
    c ∈ perpBisector p₁ p₂ ↔ ⟪p₂ -ᵥ p₁, c -ᵥ midpoint ℝ p₁ p₂⟫ = 0
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
protected theorem symm_preimage_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) :
    e.symm ⁻¹' (e ⁻¹' s) = s
-- Mathlib/MeasureTheory/Constructions/Pi.lean
@[simp]
theorem tprod_nil (μ : ∀ i, Measure (π i)) : Measure.tprod [] μ = dirac PUnit.unit
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
/-- Characterization of multiplicative identity -/
theorem one_def [Nonempty N] : (1 : HomotopyGroup N X x) = ⟦const⟧
-- Mathlib/Logic/Embedding/Basic.lean
theorem exists_surjective_iff {α β : Sort*} :
    (∃ f : α → β, Surjective f) ↔ Nonempty (α → β) ∧ Nonempty (β ↪ α)
-- Mathlib/LinearAlgebra/Ray.lean
theorem exists_pos_left (h : SameRay R x y) (hx : x ≠ 0) (hy : y ≠ 0) :
    ∃ r : R, 0 < r ∧ r • x = y
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
/-- For subgroups generated by a single element, see the simpler `zpow_induction_left`. -/
@[to_additive (attr := elab_as_elim)
  "For additive subgroups generated by a single element, see the simpler
  `zsmul_induction_left`."]
theorem closure_induction_left {p : (x : G) → x ∈ closure s → Prop} (one : p 1 (one_mem _))
    (mul_left : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy → p (x * y) (mul_mem (subset_closure hx) hy))
    (mul_left_inv : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy →
      p (x⁻¹ * y) (mul_mem (inv_mem (subset_closure hx)) hy))
    {x : G} (h : x ∈ closure s) : p x h
-- Mathlib/Order/Bounded.lean
theorem Unbounded.mono (hst : s ⊆ t) (hs : Unbounded r s) : Unbounded r t
-- Mathlib/Analysis/LocallyConvex/Basic.lean
theorem Balanced.inter (hA : Balanced 𝕜 A) (hB : Balanced 𝕜 B) : Balanced 𝕜 (A ∩ B)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem const_smul_mem_Lp (c : 𝕜) (f : Lp E p μ) : c • (f : α →ₘ[μ] E) ∈ Lp E p μ
-- Mathlib/Topology/DerivedSet.lean
lemma isClosed_iff_derivedSet_subset (A : Set X) : IsClosed A ↔ derivedSet A ⊆ A
-- Mathlib/RingTheory/FiniteType.lean
theorem finiteType {f : A →+* B} (hf : f.Finite) : FiniteType f
-- Mathlib/Algebra/Homology/Augment.lean
@[simp]
theorem augment_X_zero (C : ChainComplex V ℕ) {X : V} (f : C.X 0 ⟶ X) (w : C.d 1 0 ≫ f = 0) :
    (augment C f w).X 0 = X
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp, norm_cast] lemma coe_mul (f g : α →+* α) : ⇑(f * g) = f ∘ g
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem dualDual_symm_apply (a : αᵒᵈᵒᵈ) : (dualDual α).symm a = ofDual (ofDual a)
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem take_take {s : Stream' α} : ∀ {m n}, (s.take n).take m = s.take (min n m)
-- Mathlib/Data/ZMod/Module.lean
@[simp]
theorem _root_.Submodule.toAddSubgroup_toZModSubmodule (S : Submodule (ZMod n) M) :
    toZModSubmodule n S.toAddSubgroup = S
-- Mathlib/Data/Real/Irrational.lean
theorem of_pow : ∀ n : ℕ, Irrational (x ^ n) → Irrational x
-- Mathlib/Order/LiminfLimsup.lean
theorem isCobounded_ge_of_top [Preorder α] [OrderTop α] {f : Filter α} : f.IsCobounded (· ≥ ·)
-- Mathlib/Analysis/Convex/Independent.lean
/-- If a family is convex independent, so is any subfamily indexed by a subtype of the index type.
-/
protected theorem ConvexIndependent.subtype {p : ι → E} (hc : ConvexIndependent 𝕜 p) (s : Set ι) :
    ConvexIndependent 𝕜 fun i : s => p i
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[simp]
theorem zero_rpow {x : ℝ} (h : x ≠ 0) : (0 : ℝ≥0) ^ x = 0
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_le' : |a|ₘ ≤ b ↔ a ≤ b ∧ a⁻¹ ≤ b
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem cauchy_series_of_le_geometric {C : ℝ} {u : ℕ → α} {r : ℝ} (hr : r < 1)
    (h : ∀ n, ‖u n‖ ≤ C * r ^ n) : CauchySeq fun n ↦ ∑ k ∈ range n, u k
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma rnDeriv_restrict (μ ν : Measure α) [HaveLebesgueDecomposition μ ν] [SigmaFinite ν]
    {s : Set α} (hs : MeasurableSet s) :
    (μ.restrict s).rnDeriv ν =ᵐ[ν] s.indicator (μ.rnDeriv ν)
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem dist_lt_iff (C0 : (0 : ℝ) < C) : dist f g < C ↔ ∀ x : α, dist (f x) (g x) < C
-- Mathlib/LinearAlgebra/Matrix/LDL.lean
theorem LDL.lowerInv_triangular {i j : n} (hij : i < j) : LDL.lowerInv hS i j = 0
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
/-- The homology data on a short complex equipped with a splitting. -/
@[simps]
noncomputable def homologyData [HasZeroObject C] (s : S.Splitting) : S.HomologyData
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem exp_inj_of_neg_pi_lt_of_le_pi {x y : ℂ} (hx₁ : -π < x.im) (hx₂ : x.im ≤ π) (hy₁ : -π < y.im)
    (hy₂ : y.im ≤ π) (hxy : exp x = exp y) : x = y
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem smoothOn_proj {s : Set (TotalSpace F E)} : SmoothOn (IB.prod 𝓘(𝕜, F)) IB (π F E) s
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
/-- `legendreSym p (-1)` is given by `χ₄ p`. -/
theorem legendreSym.at_neg_one (hp : p ≠ 2) : legendreSym p (-1) = χ₄ p
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem typein_inj (r : α → α → Prop) [IsWellOrder α r] {a b} : typein r a = typein r b ↔ a = b
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
lemma LinearMap.toMatrix_pow (f : M₁ →ₗ[R] M₁) (k : ℕ) :
    (toMatrix v₁ v₁ f) ^ k = toMatrix v₁ v₁ (f ^ k)
-- Mathlib/Algebra/Lie/Classical.lean
@[simp]
theorem eb_val (h : j ≠ i) : (Eb R i j h).val = Matrix.stdBasisMatrix i j 1
-- Mathlib/Data/Set/Function.lean
theorem SurjOn.comap_nonempty (h : SurjOn f s t) (ht : t.Nonempty) : s.Nonempty
-- Mathlib/Data/Matrix/Basic.lean
theorem conjTranspose_injective [InvolutiveStar α] :
    Function.Injective (conjTranspose : Matrix m n α → Matrix n m α)
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.tendsto_left_iff (hla : la.HasBasis pa sa) :
    Tendsto f la lb ↔ ∀ t ∈ lb, ∃ i, pa i ∧ MapsTo f (sa i) t
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- Given a monoid homomorphism `f` from `M` to `P`, the kernel of `f` is the unique congruence
    relation on `M` whose induced map from the quotient of `M` to `P` is injective. -/
@[to_additive "Given an `AddMonoid` homomorphism `f` from `M` to `P`, the kernel of `f`
is the unique additive congruence relation on `M` whose induced map from the quotient of `M`
to `P` is injective."]
theorem ker_eq_lift_of_injective (H : c ≤ ker f) (h : Injective (c.lift f H)) : ker f = c
-- Mathlib/CategoryTheory/Sites/LocallyBijective.lean
lemma isLocallyBijective_iff_isIso :
    IsLocallyInjective f ∧ IsLocallySurjective f ↔ IsIso f
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive]
theorem one_lt_iff_ne_one : 1 < a ↔ a ≠ 1
-- Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
@[simp]
theorem finsuppTensorFinsupp_single (i : ι) (m : M) (k : κ) (n : N) :
    finsuppTensorFinsupp R S M N ι κ (Finsupp.single i m ⊗ₜ Finsupp.single k n) =
      Finsupp.single (i, k) (m ⊗ₜ n)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_insert [MeasurableSingletonClass α] {a : α} {s : Set α} (h : a ∉ s)
    (f : α → ℝ≥0∞) : ∫⁻ x in insert a s, f x ∂μ = f a * μ {a} + ∫⁻ x in s, f x ∂μ
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem map_eq_append_split {f : α → β} {l : List α} {s₁ s₂ : List β}
    (h : map f l = s₁ ++ s₂) : ∃ l₁ l₂, l = l₁ ++ l₂ ∧ map f l₁ = s₁ ∧ map f l₂ = s₂
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The `LSeries` associated to the arithmetic function `ζ` converges at `s` if and only if
`re s > 1`. -/
theorem LSeriesSummable_zeta_iff {s : ℂ} : LSeriesSummable (ζ ·) s ↔ 1 < s.re
-- Mathlib/Algebra/Category/Grp/Basic.lean
theorem asHom_injective {G : AddCommGrp.{0}} : Function.Injective (@asHom G)
-- Mathlib/Data/PNat/Defs.lean
@[simp]
theorem toPNat'_coe : ∀ n : ℕ, (toPNat' n : ℕ) = ite (0 < n) n 1
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1S_add_left' (T T' T'' : Set α → E →L[ℝ] F)
    (h_add : ∀ s, MeasurableSet s → μ s < ∞ → T'' s = T s + T' s) (f : α →₁ₛ[μ] E) :
    setToL1S T'' f = setToL1S T f + setToL1S T' f
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem mkHom_f_succ_succ (n : ℕ) :
    (mkHom P Q zero one one_zero_comm succ).f (n + 2) =
      (succ n
          ⟨(mkHom P Q zero one one_zero_comm succ).f n,
            (mkHom P Q zero one one_zero_comm succ).f (n + 1),
            (mkHom P Q zero one one_zero_comm succ).comm (n + 1) n⟩).1
-- Mathlib/FieldTheory/Perfect.lean
/-- The iterated Frobenius automorphism for a perfect ring. -/
@[simps! apply]
noncomputable def iterateFrobeniusEquiv : R ≃+* R
-- Mathlib/Topology/Order.lean
@[simp]
lemma generateFrom_insert_univ {α : Type*} {s : Set (Set α)} :
    generateFrom (insert univ s) = generateFrom s
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem derivWithin_neg (hxs : UniqueDiffWithinAt 𝕜 s x) : derivWithin Neg.neg s x = -1
-- Mathlib/Topology/UniformSpace/Cauchy.lean
lemma cauchy_iInf_uniformSpace' {ι : Sort*} {u : ι → UniformSpace β}
    {l : Filter β} [l.NeBot] :
    Cauchy (uniformSpace := ⨅ i, u i) l ↔ ∀ i, Cauchy (uniformSpace := u i) l
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
@[reassoc (attr := simp)]
theorem isoIsPullback_inv_snd (h : IsPullback fst snd f g) (h' : IsPullback fst' snd' f g) :
    (h.isoIsPullback h').inv ≫ snd = snd'
-- Mathlib/GroupTheory/Perm/Cycle/Factors.lean
/-- Two permutations `f g : Perm α` have the same cycle factors iff they are the same. -/
theorem cycleFactorsFinset_injective : Function.Injective (@cycleFactorsFinset α _ _)
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem sigmaFinsuppEquivDFinsupp_single [DecidableEq ι] [Zero N] (a : Σi, η i) (n : N) :
    sigmaFinsuppEquivDFinsupp (Finsupp.single a n) =
      @DFinsupp.single _ (fun i => η i →₀ N) _ _ a.1 (Finsupp.single a.2 n)
-- Mathlib/FieldTheory/Fixed.lean
theorem rank_le_card : Module.rank (FixedPoints.subfield G F) F ≤ Fintype.card G
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem zeroExtend_zeroExtend_of_le (x : BitVec w) (h : k ≤ l) :
    (x.zeroExtend l).zeroExtend k = x.zeroExtend k
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem symm_toDiffeomorph : e.symm.toDiffeomorph = e.toDiffeomorph.symm
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
/-- A morphism of presheaves of modules. -/
structure Hom (P Q : PresheafOfModules R) where
  hom : P.presheaf ⟶ Q.presheaf
  map_smul : ∀ (X : Cᵒᵖ) (r : R.obj X) (x : P.presheaf.obj X), hom.app X (r • x) = r • hom.app X x
-- Mathlib/Data/Nat/Defs.lean
protected lemma div_eq_zero_iff (hb : 0 < b) : a / b = 0 ↔ a < b
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- Dividing out by a prime factor reduces the `padicValNat` by `1`. -/
protected theorem div (dvd : p ∣ b) : padicValNat p (b / p) = padicValNat p b - 1
-- Mathlib/FieldTheory/SeparableDegree.lean
/-- If a field `F` is of exponential characteristic `q`, then `Polynomial.expand F (q ^ n) f`
and `f` have the same separable degree. -/
theorem natSepDegree_expand (q : ℕ) [hF : ExpChar F q] {n : ℕ} :
    (expand F (q ^ n) f).natSepDegree = f.natSepDegree
-- Mathlib/CategoryTheory/Filtered/Connected.lean
theorem IsFiltered.isConnected [IsFiltered C] : IsConnected C
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
theorem to_mulHom_injective {f g : A →ₛₙₐ[φ] B} (h : (f : A →ₙ* B) = (g : A →ₙ* B)) : f = g
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem attach_cons (x : α) (s : Sym α n) :
    (cons x s).attach =
      cons ⟨x, mem_cons_self _ _⟩ (s.attach.map fun x => ⟨x, mem_cons_of_mem x.prop⟩)
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem coe_iff_coe : ∀(a b : Bool), (a ↔ b) ↔ a = b
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem hasFDerivAt_aeval (x : 𝕜) :
    HasFDerivAt (fun x => aeval x q) (smulRight (1 : 𝕜 →L[𝕜] 𝕜) (aeval x (derivative q))) x
-- Mathlib/Data/ENNReal/Basic.lean
theorem coe_two : ((2 : ℝ≥0) : ℝ≥0∞) = 2
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem symm_proj_apply (e : Trivialization F (π F E)) (z : TotalSpace F E)
    (hz : z.proj ∈ e.baseSet) : e.symm z.proj (e z).2 = z.2
-- Mathlib/Analysis/Calculus/LocalExtr/Basic.lean
/-- If `f` has a local min on `s` at `a`, `f'` is the derivative of `f` at `a` within `s`, and
`y` belongs to the positive tangent cone of `s` at `a`, then `0 ≤ f' y`. -/
theorem IsLocalMinOn.hasFDerivWithinAt_nonneg (h : IsLocalMinOn f s a)
    (hf : HasFDerivWithinAt f f' s a) (hy : y ∈ posTangentConeAt s a) : 0 ≤ f' y
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem mrange_eq_map (f : F) : mrange f = (⊤ : Submonoid M).map f
-- Mathlib/Data/Analysis/Topology.lean
theorem isOpen_iff [TopologicalSpace α] (F : Realizer α) {s : Set α} :
    IsOpen s ↔ ∀ a ∈ s, ∃ b, a ∈ F.F b ∧ F.F b ⊆ s
-- Mathlib/SetTheory/Ordinal/Notation.lean
@[simp 1200]
theorem ofNat_one : ofNat 1 = 1
-- Mathlib/Order/Circular.lean
theorem left_mem_cIcc (a b : α) : a ∈ cIcc a b
-- Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean
/-- A subsemiring `S` of `R` determines a subsemiring `S.op` of the opposite ring `Rᵐᵒᵖ`. -/
@[simps]
def opEquiv : Subsemiring R ≃o Subsemiring Rᵐᵒᵖ
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem zero_min (a) : min 0 a = 0
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- The integral of the derivative of a product of two maps.
Special case of `integral_deriv_mul_eq_sub_of_hasDeriv_right` where the functions have a
  one-sided derivative at the endpoints. -/
theorem integral_deriv_mul_eq_sub_of_hasDerivWithinAt {u v u' v' : ℝ → A}
    (hu : ∀ x ∈ [[a, b]], HasDerivWithinAt u (u' x) [[a, b]] x)
    (hv : ∀ x ∈ [[a, b]], HasDerivWithinAt v (v' x) [[a, b]] x)
    (hu' : IntervalIntegrable u' volume a b)
    (hv' : IntervalIntegrable v' volume a b) :
    ∫ x in a..b, u' x * v x + u x * v' x = u b * v b - u a * v a
-- Mathlib/Analysis/Normed/Group/BallSphere.lean
@[simp] theorem coe_neg_closedBall {r : ℝ} (v : closedBall (0 : E) r) : ↑(-v) = (-v : E)
-- Mathlib/Topology/Bornology/Basic.lean
theorem IsBounded.all (s : Set α) : IsBounded s
-- Mathlib/ModelTheory/Definability.lean
theorem le_iff : s ≤ t ↔ (s : Set (α → M)) ≤ (t : Set (α → M))
-- Mathlib/Algebra/CharZero/Lemmas.lean
@[simp, norm_cast]
theorem cast_div_charZero {k : Type*} [DivisionSemiring k] [CharZero k] {m n : ℕ} (n_dvd : n ∣ m) :
    ((m / n : ℕ) : k) = m / n
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem zero_sigma : @Multiset.sigma α σ 0 t = 0
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
lemma prob_compl_le_one_sub_of_le_prob {p : ℝ≥0∞} (hμs : p ≤ μ s) (s_mble : MeasurableSet s) :
    μ sᶜ ≤ 1 - p
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_vector (α : Type u) (n : ℕ) : #(Vector α n) = #α ^ n
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem nat_add (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (n + x)
-- Mathlib/Topology/Order/Basic.lean
theorem IsOpen.exists_Ioo_subset [OrderTopology α] [Nontrivial α] {s : Set α} (hs : IsOpen s)
    (h : s.Nonempty) : ∃ a b, a < b ∧ Ioo a b ⊆ s
-- Mathlib/Data/Set/Lattice.lean
theorem sInter_iUnion (s : ι → Set (Set α)) : ⋂₀ ⋃ i, s i = ⋂ i, ⋂₀ s i
-- Mathlib/Order/RelClasses.lean
theorem not_subset_of_ssubset (h : a ⊂ b) : ¬b ⊆ a
-- Mathlib/Algebra/Order/Module/Defs.lean
/-- Typeclass for strict reverse monotonicity of scalar multiplication by nonnegative elements on
the left, namely `a • b₁ < a • b₂ → b₁ < b₂` if `0 ≤ a`.

You should usually not use this very granular typeclass directly, but rather a typeclass like
`OrderedSMul`. -/
class PosSMulReflectLT : Prop where
  /-- Do not use this. Use `lt_of_smul_lt_smul_left` instead. -/
  protected elim ⦃a : α⦄ (ha : 0 ≤ a) ⦃b₁ b₂ : β⦄ (hb : a • b₁ < a • b₂) : b₁ < b₂
-- Mathlib/Order/Defs.lean
theorem gt_irrefl : ∀ a : α, ¬a > a
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[norm_cast]
theorem coe_add : (↑(f + f') : MultilinearMap R (fun _ : ι => M) N) = f + f'
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem repr_floor_apply (m : E) (i : ι) : b.repr (floor b m) i = ⌊b.repr m i⌋
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma homologyMap'_eq : homologyMap' φ h₁ h₂ = γ.left.φH
-- Mathlib/CategoryTheory/Sites/Coverage.lean
lemma saturate_of_superset (K : Coverage C) {X : C} {S T : Sieve X} (h : S ≤ T)
    (hS : Saturate K X S) : Saturate K X T
-- Mathlib/Algebra/Polynomial/Basic.lean
protected theorem smul_sum {S T : Type*} [AddCommMonoid S] [DistribSMul T S] (p : R[X]) (b : T)
    (f : ℕ → R → S) : b • p.sum f = p.sum fun n a => b • f n a
-- Mathlib/Algebra/Lie/SkewAdjoint.lean
theorem Matrix.isSkewAdjoint_bracket {A B : Matrix n n R} (hA : A ∈ skewAdjointMatricesSubmodule J)
    (hB : B ∈ skewAdjointMatricesSubmodule J) : ⁅A, B⁆ ∈ skewAdjointMatricesSubmodule J
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem inr_le_inr_iff [LE α] [LE β] {a b : β} : (inr a : α ⊕ β) ≤ inr b ↔ a ≤ b
-- Mathlib/Data/List/Basic.lean
theorem getLast_append_singleton {a : α} (l : List α) :
    getLast (l ++ [a]) (append_ne_nil_of_ne_nil_right l _ (cons_ne_nil a _)) = a
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem adjoin_union (s t : Set A) : adjoin R (s ∪ t) = adjoin R s ⊔ adjoin R t
-- Mathlib/Probability/StrongLaw.lean
theorem moment_truncation_eq_intervalIntegral (hf : AEStronglyMeasurable f μ) {A : ℝ} (hA : 0 ≤ A)
    {n : ℕ} (hn : n ≠ 0) : ∫ x, truncation f A x ^ n ∂μ = ∫ y in -A..A, y ^ n ∂Measure.map f μ
-- Mathlib/Topology/Order/ProjIcc.lean
theorem quotientMap_projIcc : QuotientMap (projIcc a b h)
-- Mathlib/Algebra/Star/StarAlgHom.lean
/-- A *non-unital ⋆-algebra homomorphism* is a non-unital algebra homomorphism between
non-unital `R`-algebras `A` and `B` equipped with a `star` operation, and this homomorphism is
also `star`-preserving. -/
structure NonUnitalStarAlgHom (R A B : Type*) [Monoid R] [NonUnitalNonAssocSemiring A]
  [DistribMulAction R A] [Star A] [NonUnitalNonAssocSemiring B] [DistribMulAction R B]
  [Star B] extends A →ₙₐ[R] B where
  /-- By definition, a non-unital ⋆-algebra homomorphism preserves the `star` operation. -/
  map_star' : ∀ a : A, toFun (star a) = star (toFun a)
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem sphere_disjoint_ball : Disjoint (sphere x ε) (ball x ε)
-- Mathlib/Algebra/Group/Action/Defs.lean
@[to_additive]
lemma Function.Injective.smulCommClass [SMul M α] [SMul N α] [SMul M β] [SMul N β]
    [SMulCommClass M N β] {f : α → β} (hf : Injective f) (h₁ : ∀ (c : M) x, f (c • x) = c • f x)
    (h₂ : ∀ (c : N) x, f (c • x) = c • f x) : SMulCommClass M N α
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- The mean value theorem: if the derivative of a function is bounded by `C`, then the function is
`C`-Lipschitz. Version with `fderiv` and `LipschitzWith`. -/
theorem _root_.lipschitzWith_of_nnnorm_fderiv_le
    {E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E] {f : E → G}
    {C : ℝ≥0} (hf : Differentiable 𝕜 f)
    (bound : ∀ x, ‖fderiv 𝕜 f x‖₊ ≤ C) : LipschitzWith C f
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem one_im : im (1 : K) = 0
-- Mathlib/Algebra/Homology/Augment.lean
@[simp]
theorem augmentTruncate_hom_f_zero (C : CochainComplex V ℕ) :
    (augmentTruncate C).hom.f 0 = 𝟙 (C.X 0)
-- Mathlib/Data/List/Chain.lean
theorem Chain'.cons {x y l} (h₁ : R x y) (h₂ : Chain' R (y :: l)) : Chain' R (x :: y :: l)
-- Mathlib/Data/Nat/Digits.lean
@[simp]
theorem ofDigits_singleton {b n : ℕ} : ofDigits b [n] = n
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem isNoetherian_adjoin_finset [IsNoetherianRing R] (s : Finset A)
    (hs : ∀ x ∈ s, IsIntegral R x) : IsNoetherian R (Algebra.adjoin R (s : Set A))
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.restrict_of_comp_subtype {s : Set ι}
    (hs : LinearIndependent R (v ∘ (↑) : s → M)) : LinearIndependent R (s.restrict v)
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem eval_πs' {l : Products I} {o₁ o₂ : Ordinal} (h : o₁ ≤ o₂)
    (hlt : ∀ i ∈ l.val, ord I i < o₁) :
    πs' C h (l.eval (π C (ord I · < o₁))) = l.eval (π C (ord I · < o₂))
-- Mathlib/SetTheory/Game/PGame.lean
theorem lt_congr_left {x₁ x₂ y : PGame} (hx : x₁ ≈ x₂) : x₁ < y ↔ x₂ < y
-- Mathlib/Computability/Primrec.lean
theorem prim_iff₁ {f : ℕ → ℕ} : (@Primrec' 1 fun v => f v.head) ↔ Primrec f
-- Mathlib/Data/Int/LeastGreatest.lean
/--
    If `P : ℤ → Prop` is a predicate such that the set `{m : P m}` is bounded below and nonempty,
    then this set has the least element. This lemma uses classical logic to avoid assumption
    `[DecidablePred P]`. See `Int.leastOfBdd` for a constructive counterpart. -/
theorem exists_least_of_bdd
    {P : ℤ → Prop}
    (Hbdd : ∃ b : ℤ , ∀ z : ℤ , P z → b ≤ z)
    (Hinh : ∃ z : ℤ , P z) : ∃ lb : ℤ , P lb ∧ ∀ z : ℤ , P z → lb ≤ z
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem infix_nil : l <:+: [] ↔ l = []
-- Mathlib/Algebra/Group/Units.lean
/-- Multiplication by a `u : Mˣ` on the right doesn't affect `IsUnit`. -/
@[to_additive (attr := simp)
"Addition of a `u : AddUnits M` on the right doesn't affect `IsAddUnit`."]
theorem Units.isUnit_mul_units [Monoid M] (a : M) (u : Mˣ) : IsUnit (a * u) ↔ IsUnit a
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem isConnected_Ici : IsConnected (Ici a)
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoLocallyUniformlyOn.union {s₁ s₂ : Set α} (hs₁ : IsOpen s₁) (hs₂ : IsOpen s₂)
    (h₁ : TendstoLocallyUniformlyOn F f p s₁) (h₂ : TendstoLocallyUniformlyOn F f p s₂) :
    TendstoLocallyUniformlyOn F f p (s₁ ∪ s₂)
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- `p` is equidistant from a set of points in `s` if and only if its
`orthogonalProjection` is. -/
theorem dist_set_eq_iff_dist_orthogonalProjection_eq {s : AffineSubspace ℝ P} [Nonempty s]
    [HasOrthogonalProjection s.direction] {ps : Set P} (hps : ps ⊆ s) (p : P) :
    (Set.Pairwise ps fun p1 p2 => dist p1 p = dist p2 p) ↔
      Set.Pairwise ps fun p1 p2 =>
        dist p1 (orthogonalProjection s p) = dist p2 (orthogonalProjection s p)
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
lemma IsInvertedBy.map_iff {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (G : C₂ ⥤ C₃) :
    (W.map F).IsInvertedBy G ↔ W.IsInvertedBy (F ⋙ G)
-- Mathlib/CategoryTheory/Adjunction/Mates.lean
theorem conjugateEquiv_adjunction_id {L R : C ⥤ C} (adj : L ⊣ R) (α : 𝟭 C ⟶ L) (c : C) :
    (conjugateEquiv adj Adjunction.id α).app c = α.app (R.obj c) ≫ adj.counit.app c
-- Mathlib/FieldTheory/Finite/Basic.lean
/-- The cardinality of a field is at most `n` times the cardinality of the image of a degree `n`
  polynomial -/
theorem card_image_polynomial_eval [DecidableEq R] [Fintype R] {p : R[X]} (hp : 0 < p.degree) :
    Fintype.card R ≤ natDegree p * (univ.image fun x => eval x p).card