ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
protected theorem map_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n) : R[X]).map f = OfNat.ofNat n
-- Mathlib/NumberTheory/Harmonic/ZetaAsymp.lean
lemma term_nonneg (n : ℕ) (s : ℝ) : 0 ≤ term n s
-- Mathlib/Algebra/Order/Monovary.lean
lemma Antivary.mul_left₀ (hf₁ : 0 ≤ f₁) (hf₂ : 0 ≤ f₂) (h₁ : Antivary f₁ g) (h₂ : Antivary f₂ g) :
    Antivary (f₁ * f₂) g
-- Mathlib/LinearAlgebra/Span.lean
theorem mem_span : x ∈ span R s ↔ ∀ p : Submodule R M, s ⊆ p → x ∈ p
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
@[to_additive]
theorem mul_lt_of_le_of_lt_one [CovariantClass α α (· * ·) (· < ·)] {a b c : α} (hbc : b ≤ c)
    (ha : a < 1) :
    b * a < c
-- Mathlib/Order/Hom/Basic.lean
theorem OrderEmbedding.le_map_sup [SemilatticeSup α] [SemilatticeSup β] (f : α ↪o β) (x y : α) :
    f x ⊔ f y ≤ f (x ⊔ y)
-- Mathlib/Algebra/Order/Interval/Set/Instances.lean
theorem one_minus_lt_one (x : Ioo (0 : β) 1) : 1 - (x : β) < 1
-- Mathlib/Order/Interval/Set/Image.lean
@[simp] lemma preimage_subtype_val_Ici (a : {x // p x}) : (↑) ⁻¹' (Ici a.1) = Ici a
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem two_mul_arctan_inv_2_sub_arctan_inv_7 : 2 * arctan 2⁻¹ - arctan 7⁻¹ = π / 4
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive (attr := simp) MeasureTheory.addFundamentalInterior_union_addFundamentalFrontier]
theorem fundamentalInterior_union_fundamentalFrontier :
    fundamentalInterior G s ∪ fundamentalFrontier G s = s
-- Mathlib/RingTheory/IsTensorProduct.lean
theorem Algebra.lift_algHom_comp_right [Algebra.IsPushout R S R' S'] {A : Type*} [Semiring A]
    [Algebra R A] (f : S →ₐ[R] A) (g : R' →ₐ[R] A) (H) :
    (Algebra.pushoutDesc S' f g H).comp (toAlgHom R R' S') = g
-- Mathlib/Algebra/LinearRecurrence.lean
/-- If `u` is a solution to `E` and `init` designates its first `E.order` values,
  then `u = E.mkSol init`. This proves that `E.mkSol init` is the only solution
  of `E` whose first `E.order` values are given by `init`. -/
theorem eq_mk_of_is_sol_of_eq_init' {u : ℕ → α} {init : Fin E.order → α} (h : E.IsSolution u)
    (heq : ∀ n : Fin E.order, u n = init n) : u = E.mkSol init
-- Mathlib/Analysis/Normed/Operator/Banach.lean
@[simp]
theorem coeFn_ofBijective (f : E →SL[σ] F) (hinj : ker f = ⊥) (hsurj : LinearMap.range f = ⊤) :
    ⇑(ofBijective f hinj hsurj) = f
-- Mathlib/RingTheory/PowerSeries/Basic.lean
@[simp]
theorem constantCoeff_mk {f : ℕ → R} : constantCoeff R (mk f) = f 0
-- Mathlib/Algebra/Module/Torsion.lean
lemma isTorsionBySet_quotient_set_smul :
    IsTorsionBySet R (M⧸s • (⊤ : Submodule R M)) s
-- Mathlib/Algebra/Group/Hom/Defs.lean
/-- Group homomorphisms preserve inverse. -/
@[to_additive (attr := simp) "Additive group homomorphisms preserve negation."]
theorem map_inv [Group G] [DivisionMonoid H] [MonoidHomClass F G H]
    (f : F) (a : G) : f a⁻¹ = (f a)⁻¹
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_lt_sum' {ι : Type*} {s : Finset ι} {f : ι → R} {g : Γ₀} (hg : g < ⊤)
    (hf : ∀ i ∈ s, g < v (f i)) : g < v (∑ i ∈ s, f i)
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
theorem v_sq_scalar (m : M) : v Q m * v Q m = algebraMap _ _ (Q m)
-- Mathlib/Data/Int/ModEq.lean
protected theorem mul_left' (h : a ≡ b [ZMOD n]) : c * a ≡ c * b [ZMOD c * n]
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
/-- The measure of a set under `p.bind f` is the sum over `a : α`
  of the probability of `a` under `p` times the measure of the set under `f a`. -/
@[simp]
theorem toMeasure_bind_apply [MeasurableSpace β] (hs : MeasurableSet s) :
    (p.bind f).toMeasure s = ∑' a, p a * (f a).toMeasure s
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem SuperpolynomialDecay.const_mul [ContinuousMul β] (hf : SuperpolynomialDecay l k f) (c : β) :
    SuperpolynomialDecay l k fun n => c * f n
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem lift_bot (K : IntermediateField F E) :
    lift (F := K) ⊥ = ⊥
-- Mathlib/Data/Set/NAry.lean
@[simp]
theorem image2_singleton_right : image2 f s {b} = (fun a => f a b) '' s
-- Mathlib/Order/RelIso/Group.lean
theorem mul_apply (e₁ e₂ : r ≃r r) (x : α) : (e₁ * e₂) x = e₁ (e₂ x)
-- Mathlib/NumberTheory/RamificationInertia.lean
theorem Factors.ne_bot (P : (factors (map (algebraMap R S) p)).toFinset) : (P : Ideal S) ≠ ⊥
-- Mathlib/Analysis/Normed/Group/InfiniteSum.lean
theorem HasSum.norm_le_of_bounded {f : ι → E} {g : ι → ℝ} {a : E} {b : ℝ} (hf : HasSum f a)
    (hg : HasSum g b) (h : ∀ i, ‖f i‖ ≤ g i) : ‖a‖ ≤ b
-- Mathlib/Data/Nat/Digits.lean
theorem pow_length_le_mul_ofDigits {b : ℕ} {l : List ℕ} (hl : l ≠ []) (hl2 : l.getLast hl ≠ 0) :
    (b + 2) ^ l.length ≤ (b + 2) * ofDigits (b + 2) l
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem omega_succ {n} : n ∈ omega.{u} → insert n n ∈ omega.{u}
-- Mathlib/Data/Set/Lattice.lean
theorem Iic_sInf (s : Set α) : Iic (sInf s) = ⋂ a ∈ s, Iic a
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem ofFractionRing_comp_algebraMap :
    ofFractionRing ∘ algebraMap K[X] (FractionRing K[X]) = algebraMap _ _
-- Mathlib/Data/Finset/NAry.lean
/-- Symmetric statement to `Finset.image_image₂_distrib_right`. -/
theorem image_image₂_right_comm {f : α → β' → γ} {g : β → β'} {f' : α → β → δ} {g' : δ → γ}
    (h_right_comm : ∀ a b, f a (g b) = g' (f' a b)) :
    image₂ f s (t.image g) = (image₂ f' s t).image g'
-- Mathlib/Analysis/Convex/Cone/Proper.lean
@[simp, norm_cast]
theorem coe_dual (K : ProperCone ℝ E) : K.dual = (K : Set E).innerDualCone
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem ae_measure_preimage_mul_right_lt_top_of_ne_zero (h2s : ν' s ≠ 0) (h3s : ν' s ≠ ∞) :
    ∀ᵐ x ∂μ', ν' ((fun y => y * x) ⁻¹' s) < ∞
-- Mathlib/Topology/Order/NhdsSet.lean
theorem Ioc_mem_nhdsSet_Ioc (h : a ≤ b) (h' : c < d) : Ioc a d ∈ 𝓝ˢ (Ioc b c)
-- Mathlib/Probability/Independence/Kernel.lean
theorem IndepSets.bUnion {s : ι → Set (Set Ω)} {s' : Set (Set Ω)} {_mΩ : MeasurableSpace Ω}
    {κ : Kernel α Ω} {μ : Measure α} {u : Set ι} (hyp : ∀ n ∈ u, IndepSets (s n) s' κ μ) :
    IndepSets (⋃ n ∈ u, s n) s' κ μ
-- Mathlib/GroupTheory/CoprodI.lean
theorem mem_rcons_iff {i j : ι} (p : Pair M i) (m : M j) :
    ⟨_, m⟩ ∈ (rcons p).toList ↔ ⟨_, m⟩ ∈ p.tail.toList ∨
      m ≠ 1 ∧ (∃ h : i = j, m = h ▸ p.head)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[ext]
theorem biprod.hom_ext {X Y Z : C} [HasBinaryBiproduct X Y] (f g : Z ⟶ X ⊞ Y)
    (h₀ : f ≫ biprod.fst = g ≫ biprod.fst) (h₁ : f ≫ biprod.snd = g ≫ biprod.snd) : f = g
-- Mathlib/Data/Int/Order/Lemmas.lean
theorem natAbs_lt_iff_mul_self_lt {a b : ℤ} : a.natAbs < b.natAbs ↔ a * a < b * b
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[simp]
theorem Subsingleton.stronglyMeasurable' {α β} [MeasurableSpace α] [TopologicalSpace β]
    [Subsingleton α] (f : α → β) : StronglyMeasurable f
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
theorem const_mul_rev (f g : R) (U hu₁ hu₂) : const R f g U hu₁ * const R g f U hu₂ = 1
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem coeff_mul_monomial' (m) (s : σ →₀ ℕ) (r : R) (p : MvPolynomial σ R) :
    coeff m (p * monomial s r) = if s ≤ m then coeff (m - s) p * r else 0
-- Mathlib/RingTheory/WittVector/Basic.lean
private lemma ghostFun_nsmul (m : ℕ) (x : WittVector p R) : ghostFun (m • x) = m • ghostFun x
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem tendsto_atTop_iff_leadingCoeff_nonneg :
    Tendsto (fun x => eval x P) atTop atTop ↔ 0 < P.degree ∧ 0 ≤ P.leadingCoeff
-- Mathlib/RingTheory/Polynomial/Wronskian.lean
@[simp]
theorem wronskian_zero_left (a : R[X]) : wronskian 0 a = 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getLast?_eq_getLast : ∀ l h, @getLast? α l = some (getLast l h)
-- Mathlib/Topology/Instances/EReal.lean
private lemma continuousAt_mul_top_pos {a : ℝ} (h : 0 < a) :
    ContinuousAt (fun p : EReal × EReal ↦ p.1 * p.2) (⊤, a)
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem map_id (M : Matrix m n α) : M.map id = M
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem aleph0_le_cof {o} : ℵ₀ ≤ cof o ↔ IsLimit o
-- Mathlib/LinearAlgebra/Contraction.lean
@[simp]
theorem contractRight_apply (f : Module.Dual R M) (m : M) : contractRight R M (m ⊗ₜ f) = f m
-- Mathlib/Algebra/DualQuaternion.lean
@[simp]
theorem imJ_snd_dualNumberEquiv (q : Quaternion (DualNumber R)) :
    (dualNumberEquiv q).snd.imJ = q.imJ.snd
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
private theorem rat_prop (r : ℚ) : innerProp' E (r : 𝕜)
-- Mathlib/Probability/Martingale/Basic.lean
theorem submartingale_of_setIntegral_le [IsFiniteMeasure μ] {f : ι → Ω → ℝ} (hadp : Adapted ℱ f)
    (hint : ∀ i, Integrable (f i) μ) (hf : ∀ i j : ι,
      i ≤ j → ∀ s : Set Ω, MeasurableSet[ℱ i] s → ∫ ω in s, f i ω ∂μ ≤ ∫ ω in s, f j ω ∂μ) :
    Submartingale f ℱ μ
-- Mathlib/Algebra/Quaternion.lean
@[simp]
theorem normSq_star : normSq (star a) = normSq a
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem erase_of_not_mem {a : α} {s : Multiset α} : a ∉ s → s.erase a = s
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem norm_ofSubsingleton_id [Subsingleton ι] [Nontrivial G] (i : ι) :
    ‖ofSubsingleton 𝕜 G G i (.id _ _)‖ = 1
-- Mathlib/CategoryTheory/Sites/Continuous.lean
lemma isContinuous_of_iso {F₁ F₂ : C ⥤ D} (e : F₁ ≅ F₂)
    (J : GrothendieckTopology C) (K : GrothendieckTopology D)
    [Functor.IsContinuous.{t} F₁ J K] : Functor.IsContinuous.{t} F₂ J K
-- Mathlib/Analysis/Convex/Mul.lean
lemma ConcaveOn.mul_convexOn (hf : ConcaveOn 𝕜 s f) (hg : ConvexOn 𝕜 s g)
    (hf₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ f x) (hg₀ : ∀ ⦃x⦄, x ∈ s → g x ≤ 0) (hfg : MonovaryOn f g s) :
    ConvexOn 𝕜 s (f * g)
-- Mathlib/Data/Rat/Defs.lean
protected lemma nonneg_total (a : ℚ) : 0 ≤ a ∨ 0 ≤ -a
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- If a vector space is finite-dimensional, then the cardinality of any basis is equal to its
`finrank`. -/
theorem finrank_eq_card_basis' [FiniteDimensional K V] {ι : Type w} (h : Basis ι K V) :
    (finrank K V : Cardinal.{w}) = #ι
-- Mathlib/RingTheory/Ideal/Operations.lean
/-- If `I` divides `J`, then `I` contains `J`.

In a Dedekind domain, to divide and contain are equivalent, see `Ideal.dvd_iff_le`.
-/
theorem le_of_dvd {I J : Ideal R} : I ∣ J → J ≤ I
-- Mathlib/Topology/Algebra/ConstMulAction.lean
nonrec theorem tendsto_const_smul_iff {f : β → α} {l : Filter β} {a : α} {c : M} (hc : IsUnit c) :
    Tendsto (fun x => c • f x) l (𝓝 <| c • a) ↔ Tendsto f l (𝓝 a)
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem even_mul_odd {f : ℕ → M} (he : Multipliable fun k ↦ f (2 * k))
    (ho : Multipliable fun k ↦ f (2 * k + 1)) : Multipliable f
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem neg_eq (H : B₁.IsAlt) (x y : M₁) : -B₁ x y = B₁ y x
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem trim_trim (m : OuterMeasure α) : m.trim.trim = m.trim
-- Mathlib/Algebra/Order/Sum.lean
@[to_additive]
lemma one_le_elim_iff : 1 ≤ Sum.elim v₁ v₂ ↔ 1 ≤ v₁ ∧ 1 ≤ v₂
-- Mathlib/Analysis/InnerProductSpace/Positive.lean
theorem IsPositive.inner_nonneg_right {T : E →L[𝕜] E} (hT : IsPositive T) (x : E) :
    0 ≤ re ⟪x, T x⟫
-- Mathlib/Order/SuccPred/Basic.lean
@[simp]
theorem Ici_succ (a : α) : Ici (succ a) = Ioi a
-- Mathlib/Topology/PartialHomeomorph.lean
theorem continuousOn_symm : ContinuousOn e.symm e.target
-- Mathlib/Algebra/Module/Submodule/Lattice.lean
@[simp]
theorem mem_sInf {S : Set (Submodule R M)} {x : M} : x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma odd_one : Odd (1 : α)
-- Mathlib/Order/Bounded.lean
theorem Bounded.mono (hst : s ⊆ t) (hs : Bounded r t) : Bounded r s
-- Mathlib/Order/RelClasses.lean
theorem wellFoundedGT_dual_iff (α : Type*) [LT α] : WellFoundedGT αᵒᵈ ↔ WellFoundedLT α
-- Mathlib/SetTheory/Ordinal/CantorNormalForm.lean
theorem CNF_of_le_one {b o : Ordinal} (hb : b ≤ 1) (ho : o ≠ 0) : CNF b o = [⟨0, o⟩]
-- Mathlib/Analysis/Complex/Basic.lean
theorem norm_eq_one_of_pow_eq_one {ζ : ℂ} {n : ℕ} (h : ζ ^ n = 1) (hn : n ≠ 0) : ‖ζ‖ = 1
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem le_iff : μ₁ ≤ μ₂ ↔ ∀ s, MeasurableSet s → μ₁ s ≤ μ₂ s
-- Mathlib/Topology/Algebra/UniformMulAction.lean
/-- A `DistribMulAction` that is continuous on a uniform group is uniformly continuous.
This can't be an instance due to it forming a loop with
`UniformContinuousConstSMul.to_continuousConstSMul` -/
theorem uniformContinuousConstSMul_of_continuousConstSMul [Monoid R] [AddCommGroup M]
    [DistribMulAction R M] [UniformSpace M] [UniformAddGroup M] [ContinuousConstSMul R M] :
    UniformContinuousConstSMul R M
-- Mathlib/Data/Matrix/Block.lean
@[simp]
theorem blockDiag_conjTranspose {α : Type*} [AddMonoid α] [StarAddMonoid α]
    (M : Matrix (m × o) (n × o) α) (k : o) : blockDiag Mᴴ k = (blockDiag M k)ᴴ
-- Mathlib/Data/Finset/Prod.lean
theorem product_eq_biUnion [DecidableEq (α × β)] (s : Finset α) (t : Finset β) :
    s ×ˢ t = s.biUnion fun a => t.image fun b => (a, b)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem comap_equiv_eq_map_symm (f : R ≃+* S) (K : NonUnitalSubsemiring S) :
    K.comap (f : R →ₙ+* S) = K.map f.symm
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
@[mono]
theorem MemBaseSet.mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
    (hr : ∀ x ∈ Box.Icc I, r₁ x ≤ r₂ x) (hπ : l₁.MemBaseSet I c₁ r₁ π) : l₂.MemBaseSet I c₂ r₂ π
-- Mathlib/RingTheory/Ideal/Basic.lean
@[simp]
theorem span_singleton_one : span ({1} : Set α) = ⊤
-- Mathlib/MeasureTheory/Integral/Average.lean
/-- **First moment method**. The maximum of an integrable function is greater than its mean. -/
theorem exists_average_le (hμ : μ ≠ 0) (hf : Integrable f μ) : ∃ x, ⨍ a, f a ∂μ ≤ f x
-- Mathlib/Dynamics/BirkhoffSum/Average.lean
theorem birkhoffAverage_zero (f : α → α) (g : α → M) (x : α) :
    birkhoffAverage R f g 0 x = 0
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp] lemma nat_eq_ofENat {m : ℕ} {n : ℕ∞} : (m : Cardinal) = n ↔ m = n
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma homologyMap'_op : (homologyMap' φ h₁ h₂).op =
    h₂.iso.inv.op ≫ homologyMap' (opMap φ) h₂.op h₁.op ≫ h₁.iso.hom.op
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
@[fun_prop]
protected lemma Continuous.nndist [TopologicalSpace β] {f g : β → α} (hf : Continuous f)
    (hg : Continuous g) : Continuous fun b => nndist (f b) (g b)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_le_of_le_sub_left {a b c : Int} (h : b ≤ c - a) : a + b ≤ c
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem zeroLocus_empty : zeroLocus 𝒜 (∅ : Set A) = Set.univ
-- Mathlib/Topology/Constructions.lean
theorem continuousAt_snd {p : X × Y} : ContinuousAt Prod.snd p
-- Mathlib/Algebra/Lie/Basic.lean
theorem symm_bijective :
    Function.Bijective (LieModuleEquiv.symm : (M ≃ₗ⁅R,L⁆ N) → N ≃ₗ⁅R,L⁆ M)
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma IsRegular.of_perm_of_subset_jacobson_annihilator [IsNoetherian R M]
    {rs rs' : List R} (h1 : IsRegular M rs) (h2 : List.Perm rs rs')
    (h3 : ∀ r ∈ rs, r ∈ (Module.annihilator R M).jacobson) : IsRegular M rs'
-- Mathlib/Order/Filter/Lift.lean
theorem lift_lift'_assoc {g : Set α → Set β} {h : Set β → Filter γ} (hg : Monotone g)
    (hh : Monotone h) : (f.lift' g).lift h = f.lift fun s => h (g s)
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
theorem Trident.IsLimit.hom_ext [Nonempty J] {s : Trident f} (hs : IsLimit s) {W : C}
    {k l : W ⟶ s.pt} (h : k ≫ s.ι = l ≫ s.ι) : k = l
-- Mathlib/Data/Finset/Basic.lean
theorem inter_filter (s t : Finset α) : s ∩ filter p t = filter p (s ∩ t)
-- Mathlib/Analysis/Convex/Topology.lean
/-- Every topological vector space over ℝ is path connected.

Not an instance, because it creates enormous TC subproblems (turn on `pp.all`).
-/
protected theorem TopologicalAddGroup.pathConnectedSpace : PathConnectedSpace E
-- Mathlib/Topology/DenseEmbedding.lean
theorem inj_iff {x y} : e x = e y ↔ x = y
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem toNonUnitalSubsemiring_eq_top {S : NonUnitalSubalgebra R A} :
    S.toNonUnitalSubsemiring = ⊤ ↔ S = ⊤
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes left covariance. -/
theorem Left.mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (ha : a < 1) (hb : b ≤ 1)
    (a0 : 0 ≤ a) : a * b < 1
-- Mathlib/LinearAlgebra/Dimension/Finrank.lean
theorem finrank_le_of_rank_le {n : ℕ} (h : Module.rank R M ≤ ↑n) : finrank R M ≤ n
-- Mathlib/Topology/Algebra/Algebra.lean
protected theorem map_neg (f : S →A[R] B) (x : S) : f (-x) = -f x
-- Mathlib/Algebra/Ring/Hom/Defs.lean
theorem coe_toAddMonoidHom (f : α →ₙ+* β) : ⇑f.toAddMonoidHom = f
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp]
theorem map_coe_Ioo_atBot {a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atBot = 𝓝[>] a
-- Mathlib/Algebra/Polynomial/Laurent.lean
@[simp]
theorem _root_.Polynomial.toLaurent_C (r : R) : toLaurent (Polynomial.C r) = C r
-- Mathlib/GroupTheory/Abelianization.lean
@[simp]
theorem mk_eq_of (a : G) : Quot.mk _ a = of a
-- Mathlib/Analysis/Seminorm.lean
theorem ball_finset_sup' (p : ι → Seminorm 𝕜 E) (s : Finset ι) (H : s.Nonempty) (e : E) (r : ℝ) :
    ball (s.sup' H p) e r = s.inf' H fun i => ball (p i) e r
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem ofDual_top [Bot α] : ofDual ⊤ = (⊥ : α)
-- Mathlib/Data/List/Sort.lean
theorem Sorted.tail {r : α → α → Prop} {l : List α} (h : Sorted r l) : Sorted r l.tail
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem inclusion_self (S : L.Substructure M) : inclusion (le_refl S) = Embedding.refl L S
-- Mathlib/Topology/UniformSpace/Basic.lean
@[simp]
theorem id_compRel {r : Set (α × α)} : idRel ○ r = r
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem IsUniversalColimit.of_iso {F : J ⥤ C} {c c' : Cocone F} (hc : IsUniversalColimit c)
    (e : c ≅ c') : IsUniversalColimit c'
-- Mathlib/Data/TypeVec.lean
theorem repeatEq_iff_eq {α : TypeVec n} {i x y} :
    ofRepeat (repeatEq α i (prod.mk _ x y)) ↔ x = y
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[to_additive]
theorem inv [Inv Y] ⦃f : X → Y⦄ (hf : IsLocallyConstant f) : IsLocallyConstant f⁻¹
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem length_lt_card_boundaries : c.length < c.boundaries.card
-- Mathlib/CategoryTheory/Whiskering.lean
theorem pentagon :
    whiskerRight (associator F G H).hom K ≫
        (associator F (G ⋙ H) K).hom ≫ whiskerLeft F (associator G H K).hom =
      (associator (F ⋙ G) H K).hom ≫ (associator F G (H ⋙ K)).hom
-- Mathlib/Topology/PartialHomeomorph.lean
theorem apply_mem_iff (h : e.IsImage s t) (hx : x ∈ e.source) : e x ∈ t ↔ x ∈ s
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem true_eq_false_of_false : False → (True = False)
-- Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean
private theorem esymm_to_weight (k : ℕ) : k * esymm σ R k =
    (-1) ^ k * ∑ t ∈ filter (fun t ↦ card t.fst = k) (pairs σ k), weight σ R k t
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
theorem ext_iff : e = e' ↔ ∀ x, e x = e' x
-- Mathlib/FieldTheory/Adjoin.lean
theorem fG_of_fG_toSubalgebra (S : IntermediateField F E) (h : S.toSubalgebra.FG) : S.FG
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
/-- If the Lie span of a set is the whole Lie algebra, then two Lie derivations equal on this set
are equal on the whole Lie algebra. -/
theorem ext_of_lieSpan_eq_top (s : Set L) (hs : LieSubalgebra.lieSpan R L s = ⊤)
    (h : Set.EqOn D1 D2 s) : D1 = D2
-- Mathlib/Data/ENNReal/Real.lean
theorem iInf_add_iInf (h : ∀ i j, ∃ k, f k + g k ≤ f i + g j) : iInf f + iInf g = ⨅ a, f a + g a
-- Mathlib/Topology/Instances/Irrational.lean
theorem eventually_forall_le_dist_cast_rat_of_den_le (hx : Irrational x) (n : ℕ) :
    ∀ᶠ ε : ℝ in 𝓝 0, ∀ r : ℚ, r.den ≤ n → ε ≤ dist x r
-- Mathlib/Topology/LocallyConstant/Algebra.lean
@[to_additive]
theorem mul_apply [Mul Y] (f g : LocallyConstant X Y) (x : X) : (f * g) x = f x * g x
-- Mathlib/Data/Finset/Pointwise.lean
lemma smul_univ₀' [Fintype β] {s : Finset α} (hs : s.Nontrivial) : s • (univ : Finset β) = univ
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem rank_fun {M η : Type u} [Fintype η] [AddCommGroup M] [Module R M] [Module.Free R M] :
    Module.rank R (η → M) = Fintype.card η * Module.rank R M
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem getElem?_reverse' : ∀ {l : List α} (i j), i + j + 1 = length l →
    l.reverse[i]? = l[j]?
-- Mathlib/Data/Set/Function.lean
theorem _root_.MonotoneOn.mono (h : MonotoneOn f s) (h' : s₂ ⊆ s) : MonotoneOn f s₂
-- Mathlib/Algebra/QuaternionBasis.lean
@[simp]
theorem j_mul_k : q.j * q.k = -c₂ • q.i
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem alternatingProd_reverse :
    ∀ l : List α, alternatingProd (reverse l) = alternatingProd l ^ (-1 : ℤ) ^ (length l + 1)
-- Mathlib/Deprecated/Subring.lean
theorem subset_closure : s ⊆ closure s
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_neg : cfcₙ (fun x ↦ - (f x)) a = - (cfcₙ f a)
-- Mathlib/Order/Monotone/Union.lean
/-- If `f` is strictly antitone both on `(-∞, a]` and `[a, ∞)`, then it is strictly antitone on the
whole line. -/
protected theorem StrictAntiOn.Iic_union_Ici (h₁ : StrictAntiOn f (Iic a))
    (h₂ : StrictAntiOn f (Ici a)) : StrictAnti f
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem neighborSet_inf {H H' : G.Subgraph} (v : V) :
    (H ⊓ H').neighborSet v = H.neighborSet v ∩ H'.neighborSet v
-- Mathlib/Combinatorics/SimpleGraph/Metric.lean
theorem dist_eq_zero_of_not_reachable (h : ¬G.Reachable u v) : G.dist u v = 0
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
@[to_additive]
theorem ContMDiffOn.div {f g : M → G} {s : Set M} (hf : ContMDiffOn I' I n f s)
    (hg : ContMDiffOn I' I n g s) : ContMDiffOn I' I n (fun x => f x / g x) s
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem sum_nodalWeight_mul_inv_sub_ne_zero (hvs : Set.InjOn v s) (hx : ∀ i ∈ s, x ≠ v i)
    (hs : s.Nonempty) : (∑ i ∈ s, nodalWeight s v i * (x - v i)⁻¹) ≠ 0
-- Mathlib/RingTheory/Valuation/Integers.lean
theorem one_of_isUnit (hv : Integers v O) {x : O} (hx : IsUnit x) : v (algebraMap O R x) = 1
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem boundaries_nonempty : c.boundaries.Nonempty
-- Mathlib/Data/List/Dedup.lean
@[simp]
theorem dedup_eq_nil (l : List α) : l.dedup = [] ↔ l = []
-- Mathlib/Data/Finset/Pointwise.lean
theorem inv_smul_mem_iff₀ (ha : a ≠ 0) : a⁻¹ • b ∈ s ↔ b ∈ a • s
-- Mathlib/Data/Finsupp/ToDFinsupp.lean
@[simp]
theorem toFinsupp_neg [AddGroup M] [∀ m : M, Decidable (m ≠ 0)] (f : Π₀ _ : ι, M) :
    (toFinsupp (-f) : ι →₀ M) = -toFinsupp f
-- Mathlib/Data/Complex/Exponential.lean
theorem abs_cos_le_one : |cos x| ≤ 1
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem mod'_to_nat (n d) : (mod' n d : ℕ) = n % d
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem indicator_ae_eq_of_restrict_compl_ae_eq_zero (hs : MeasurableSet s)
    (hf : f =ᵐ[μ.restrict sᶜ] 0) : s.indicator f =ᵐ[μ] f
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_assoc' [GCDMonoid α] (m n k : α) : Associated (gcd (gcd m n) k) (gcd m (gcd n k))
-- Mathlib/Topology/Algebra/Constructions.lean
@[to_additive]
theorem embedding_embedProduct : Embedding (embedProduct M)
-- Mathlib/Data/Real/Irrational.lean
theorem nat_add (h : Irrational x) (m : ℕ) : Irrational (m + x)
-- Mathlib/ModelTheory/Complexity.lean
theorem not_ex_isQF (φ : L.BoundedFormula α (n + 1)) : ¬φ.ex.IsQF
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem min_orderTop_le_orderTop_sub {Γ} [LinearOrder Γ] {x y : HahnSeries Γ R} :
    min x.orderTop y.orderTop ≤ (x - y).orderTop
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem ofNat_sub_ofNat {n} (x y : Nat) : BitVec.ofNat n x - BitVec.ofNat n y = .ofNat n ((2^n - y % 2^n) + x)
-- Mathlib/FieldTheory/Finite/Basic.lean
/-- If `p` is a prime natural number and `x` is a natural number, then there exist natural numbers
`a ≤ p / 2` and `b ≤ p / 2` such that `a ^ 2 + b ^ 2 ≡ x [MOD p]`. This is a version of
`ZMod.sq_add_sq` with estimates on `a` and `b`. -/
theorem Nat.sq_add_sq_modEq (p : ℕ) [Fact p.Prime] (x : ℕ) :
    ∃ a b : ℕ, a ≤ p / 2 ∧ b ≤ p / 2 ∧ a ^ 2 + b ^ 2 ≡ x [MOD p]