ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
/-- In any concrete category, injective morphisms are monomorphisms. -/
theorem mono_of_injective {X Y : C} (f : X ⟶ Y) (i : Function.Injective f) :
    Mono f
-- Mathlib/Algebra/GroupWithZero/Basic.lean
theorem ne_zero_of_one_div_ne_zero {a : G₀} (h : 1 / a ≠ 0) : a ≠ 0
-- Mathlib/Data/Nat/Bits.lean
lemma bodd_bit (b n) : bodd (bit b n) = b
-- Mathlib/Data/Finset/Fold.lean
theorem lt_fold_min : c < s.fold min b f ↔ c < b ∧ ∀ x ∈ s, c < f x
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_non_aestronglyMeasurable_of_le (h : a ≤ b)
    (hf : ¬AEStronglyMeasurable f (μ.restrict (Ioc a b))) : ∫ x in a..b, f x ∂μ = 0
-- Mathlib/Topology/Connected/PathConnected.lean
theorem isPathConnected_iff :
    IsPathConnected F ↔ F.Nonempty ∧ ∀ᵉ (x ∈ F) (y ∈ F), JoinedIn F x y
-- Mathlib/Data/ENNReal/Inv.lean
@[simp]
theorem add_thirds (a : ℝ≥0∞) : a / 3 + a / 3 + a / 3 = a
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp] theorem measurable_mem : Measurable (· ∈ s) ↔ MeasurableSet s
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem const_comp (c : γ) (f : C(α, β)) : (const β c).comp f = const α c
-- Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean
/-- Express the value of `cosZeta` at a positive even integer as a value
of the Bernoulli polynomial. -/
theorem cosZeta_two_mul_nat (hk : k ≠ 0) (hx : x ∈ Icc 0 1) :
    cosZeta x (2 * k) = (-1) ^ (k + 1) * (2 * π) ^ (2 * k) / 2 / (2 * k)! *
      ((Polynomial.bernoulli (2 * k)).map (algebraMap ℚ ℂ)).eval (x : ℂ)
-- Mathlib/Order/Hom/Lattice.lean
/-- Special case of `map_sdiff` for boolean algebras. -/
theorem map_sdiff' (a b : α) : f (a \ b) = f a \ f b
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem tendsto_ceil_right (n : ℤ) :
    Tendsto (fun x => ceil x : α → α) (𝓝[>] n) (𝓝[≥] (n + 1))
-- Mathlib/RingTheory/Localization/NormTrace.lean
/-- Let `S` be an extension of `R` and `Rₘ Sₘ` be localizations at `M` of `R S` respectively. Let
`b` be a `R`-basis of `S`. Then discriminant of the `Rₘ`-basis of `Sₘ` induced by `b` is the
discriminant of `b`.
-/
theorem Algebra.discr_localizationLocalization (b : Basis ι R S) :
    Algebra.discr Rₘ (b.localizationLocalization Rₘ M Sₘ) =
    algebraMap R Rₘ (Algebra.discr R b)
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- A field extension `E / F` is purely inseparable if and only if the relative perfect closure of
`F` in `E` is equal to `E`. -/
theorem isPurelyInseparable_iff_perfectClosure_eq_top :
    IsPurelyInseparable F E ↔ perfectClosure F E = ⊤
-- Mathlib/Tactic/LinearCombination.lean
theorem c_add_pf [Add α] (p : b = c) (a : α) : a + b = a + c
-- Mathlib/Order/Interval/Multiset.lean
@[simp] lemma mem_Icc : x ∈ Icc a b ↔ a ≤ x ∧ x ≤ b
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[simp]
theorem unop_sum [AddCommMonoid β] {s : Finset α} (f : α → βᵐᵒᵖ) :
    unop (∑ x ∈ s, f x) = ∑ x ∈ s, unop (f x)
-- Mathlib/Topology/Algebra/OpenSubgroup.lean
/-- The type of open subgroups of a topological group. -/
@[to_additive]
structure OpenSubgroup (G : Type*) [Group G] [TopologicalSpace G] extends Subgroup G where
  isOpen' : IsOpen carrier
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem add_one_sub_one (n : Nat) : (n + 1) - 1 = n
-- Mathlib/Analysis/Normed/Operator/ContinuousLinearMap.lean
@[simp]
theorem LinearMap.toContinuousLinearMap₁_apply (f : 𝕜 →ₗ[𝕜] E) (x) :
    f.toContinuousLinearMap₁ x = f x
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_iff_totalOn {s : Set M} :
    LinearIndependent R (fun x => x : s → M) ↔
    (LinearMap.ker <| Finsupp.totalOn M M R id s) = ⊥
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem modEq_iff_toIcoDiv_eq_toIocDiv_add_one :
    a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b + 1
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
@[simp] theorem gcd_mul_right_right (m n : Nat) : gcd n (n * m) = n
-- Mathlib/Data/Set/Function.lean
theorem BijOn.subset_right {r : Set β} (hf : BijOn f s t) (hrt : r ⊆ t) :
    BijOn f (s ∩ f ⁻¹' r) r
-- Mathlib/RepresentationTheory/Maschke.lean
theorem conjugate_i (g : G) (v : V) : (conjugate π g : W → V) (i v) = v
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsGLB.mem_upperBounds_of_tendsto [Preorder γ] [TopologicalSpace γ] [OrderClosedTopology γ]
    {f : α → γ} {s : Set α} {a : α} {b : γ} (hf : AntitoneOn f s) (ha : IsGLB s a)
    (hb : Tendsto f (𝓝[s] a) (𝓝 b)) : b ∈ upperBounds (f '' s)
-- Mathlib/Algebra/Order/CompleteField.lean
@[simp]
theorem inducedOrderRingIso_self : inducedOrderRingIso β β = OrderRingIso.refl β
-- Mathlib/Init/Algebra/Classes.lean
theorem eq_of_incomp {α : Sort u} {lt : α → α → Prop} [IsTrichotomous α lt] {a b} :
    ¬lt a b ∧ ¬lt b a → a = b
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_nonsingular (hf : Function.Injective f) (x y : R) :
    (W.map f).toAffine.Nonsingular (f x) (f y) ↔ W.Nonsingular x y
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem closed (S : L.Substructure M) : (closure L).closed (S : Set M)
-- Mathlib/CategoryTheory/Localization/Construction.lean
/-- A `MorphismProperty` in `W.Localization` is satisfied by all
morphisms in the localized category if it contains the image of the
morphisms in the original category, the inverses of the morphisms
in `W` and if it is stable under composition -/
theorem morphismProperty_is_top (P : MorphismProperty W.Localization)
    [P.IsStableUnderComposition] (hP₁ : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f))
    (hP₂ : ∀ ⦃X Y : C⦄ (w : X ⟶ Y) (hw : W w), P (wInv w hw)) :
    P = ⊤
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem toFinset_union [Fintype (s ∪ t : Set _)] : (s ∪ t).toFinset = s.toFinset ∪ t.toFinset
-- Mathlib/Analysis/Oscillation.lean
/-- The oscillation within `D` of `f` at `x ∈ D` is 0 if and only if `ContinuousWithinAt f D x`. -/
theorem eq_zero_iff_continuousWithinAt [TopologicalSpace E] (f : E → F) {D : Set E}
    {x : E} (xD : x ∈ D) : oscillationWithin f D x = 0 ↔ ContinuousWithinAt f D x
-- Mathlib/Data/Sign.lean
private lemma le_trans (a b c : SignType) (_ : a ≤ b) (_ : b ≤ c) : a ≤ c
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
/-- Expressing `HasDerivAt f f' x` in terms of `HasFDerivAt` -/
theorem hasDerivAt_iff_hasFDerivAt {f' : F} :
    HasDerivAt f f' x ↔ HasFDerivAt f (smulRight (1 : 𝕜 →L[𝕜] 𝕜) f') x
-- Mathlib/Order/Filter/Bases.lean
protected theorem mem_filter_iff (h : IsBasis p s) {U : Set α} :
    U ∈ h.filter ↔ ∃ i, p i ∧ s i ⊆ U
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem lt_div_iff_of_neg (hc : c < 0) : a < b / c ↔ b < a * c
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem coe_copy (f : C(α, β)) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f'
-- Mathlib/Topology/Compactness/Lindelof.lean
lemma IsHereditarilyLindelof.isLindelof_subset (hs : IsHereditarilyLindelof s) (ht : t ⊆ s) :
    IsLindelof t
-- Mathlib/Topology/Sets/Compacts.lean
theorem map_comp (f : β → γ) (g : α → β) (hf : Continuous f) (hg : Continuous g) (hf' : IsOpenMap f)
    (hg' : IsOpenMap g) (K : CompactOpens α) :
    K.map (f ∘ g) (hf.comp hg) (hf'.comp hg') = (K.map g hg hg').map f hf hf'
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem toReal_coe (x : ℝ) : toReal (x : EReal) = x
-- Mathlib/MeasureTheory/Measure/Haar/Unique.lean
/-- In a locally compact regular space with an inner regular measure, the measure of a compact
set `k` is the infimum of the integrals of compactly supported functions equal to `1` on `k`. -/
lemma IsCompact.measure_eq_biInf_integral_hasCompactSupport
    {X : Type*} [TopologicalSpace X] [MeasurableSpace X] [BorelSpace X]
    {k : Set X} (hk : IsCompact k)
    (μ : Measure X) [IsFiniteMeasureOnCompacts μ] [InnerRegularCompactLTTop μ]
    [LocallyCompactSpace X] [RegularSpace X] :
    μ k = ⨅ (f : X → ℝ) (_ : Continuous f) (_ : HasCompactSupport f) (_ : EqOn f 1 k)
      (_ : 0 ≤ f), ENNReal.ofReal (∫ x, f x ∂μ)
-- Mathlib/GroupTheory/CommutingProbability.lean
lemma reciprocalFactors_odd {n : ℕ} (h1 : n ≠ 1) (h2 : Odd n) :
    reciprocalFactors n = n % 4 * n :: reciprocalFactors (n / 4 + 1)
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
/-- Converse to the mean value inequality: if `f` is `C`-lipschitz then
its derivative at `x₀` has norm bounded by `C`.
Version using `fderiv`. -/
theorem norm_fderiv_le_of_lipschitz {f : E → F} {x₀ : E}
    {C : ℝ≥0} (hlip : LipschitzWith C f) : ‖fderiv 𝕜 f x₀‖ ≤ C
-- Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean
theorem StrongEpi.iff_of_arrow_iso {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
    (e : Arrow.mk f ≅ Arrow.mk g) : StrongEpi f ↔ StrongEpi g
-- Mathlib/CategoryTheory/Functor/EpiMono.lean
@[simp]
theorem epi_map_iff_epi [hF₁ : PreservesEpimorphisms F] [hF₂ : ReflectsEpimorphisms F] :
    Epi (F.map f) ↔ Epi f
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Bounds.lean
lemma sin_le (hx : 0 ≤ x) : sin x ≤ x
-- Mathlib/Data/Sigma/Interval.lean
@[simp]
theorem Ioc_mk_mk : Ioc (⟨i, a⟩ : Sigma α) ⟨i, b⟩ = (Ioc a b).map (Embedding.sigmaMk i)
-- Mathlib/Data/Nat/Digits.lean
theorem digits_len (b n : ℕ) (hb : 1 < b) (hn : n ≠ 0) : (b.digits n).length = b.log n + 1
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem sum_sq_le_of_mem_box (hx : x ∈ box n d) : ∑ i : Fin n, x i ^ 2 ≤ n * (d - 1) ^ 2
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem roots_X : roots (X : R[X]) = {0}
-- Mathlib/Data/NNRat/Defs.lean
@[norm_cast] lemma den_coe : (q : ℚ).den = q.den
-- Mathlib/LinearAlgebra/BilinearForm/Properties.lean
theorem toDual_def {B : BilinForm K V} (b : B.SeparatingLeft) {m n : V} : B.toDual b m n = B m n
-- Mathlib/Data/Fin/Basic.lean
protected lemma lt_of_lt_of_le : a < b → b ≤ c → a < c
-- Mathlib/Data/Seq/Computation.lean
theorem Results.val_unique {s : Computation α} {a b m n} (h1 : Results s a m) (h2 : Results s b n) :
    a = b
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
@[simp]
theorem hausdorffMeasure_image (e : X ≃ᵢ Y) (d : ℝ) (s : Set X) : μH[d] (e '' s) = μH[d] s
-- Mathlib/LinearAlgebra/Matrix/PosDef.lean
/-- For `A` positive semidefinite, we have `x⋆ A x = 0` iff `A x = 0` (linear maps version). -/
theorem PosSemidef.toLinearMap₂'_zero_iff [DecidableEq n]
    {A : Matrix n n 𝕜} (hA : PosSemidef A) (x : n → 𝕜) :
    Matrix.toLinearMap₂' 𝕜 A (star x) x = 0 ↔ Matrix.toLin' A x = 0
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem mono_left (h : QuasiMeasurePreserving f μa μb) (ha : μa' ≪ μa) :
    QuasiMeasurePreserving f μa' μb
-- Mathlib/Algebra/Order/Group/Basic.lean
@[to_additive zsmul_mono_right]
lemma zpow_mono_left (hn : 0 ≤ n) : Monotone ((· ^ n) : α → α)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_quadratic_lt : degree (C a * X ^ 2 + C b * X + C c) < 3
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem append_nil (s : WSeq α) : append s nil = s
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem fderivWithin_zero_of_isolated (h : 𝓝[s \ {x}] x = ⊥) : fderivWithin 𝕜 f s x = 0
-- Mathlib/Data/Real/Archimedean.lean
theorem iInf_of_not_bddBelow {α : Sort*} {f : α → ℝ} (hf : ¬BddBelow (Set.range f)) :
    ⨅ i, f i = 0
-- Mathlib/Order/CompleteLattice.lean
theorem sSup_le_sSup_of_forall_exists_le (h : ∀ x ∈ s, ∃ y ∈ t, x ≤ y) : sSup s ≤ sSup t
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp] theorem norm_equiv_symm (f : ∀ i, β i) : ‖(WithLp.equiv ⊤ _).symm f‖ = ‖f‖
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- Dilations scale the diameter by `ratio f` in pseudoemetric spaces. -/
theorem ediam_image (s : Set α) : EMetric.diam ((f : α → β) '' s) = ratio f * EMetric.diam s
-- Mathlib/MeasureTheory/Covering/Besicovitch.lean
/-- A Besicovitch tau-package is a family of balls in a metric space with positive bounded radii,
together with enough data to proceed with the Besicovitch greedy algorithm. We register this in
a single structure to make sure that all our constructions in this algorithm only depend on
one variable. -/
structure TauPackage (β : Type*) (α : Type*) extends BallPackage β α where
  τ : ℝ
  one_lt_tau : 1 < τ
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
private lemma toAffine_negAddY_of_ne {P Q : Fin 3 → F} {n d : F} (hPz : P z ≠ 0) (hQz : Q z ≠ 0)
    (hd : d ≠ 0) :
    W.toAffine.negAddY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (n / (P z * Q z * d)) =
      (n * (n ^ 2 + W.a₁ * n * P z * Q z * d - W.a₂ * P z ^ 2 * Q z ^ 2 * d ^ 2
          - P x * Q z ^ 2 * d ^ 2 - Q x * P z ^ 2 * d ^ 2 - P x * Q z ^ 2 * d ^ 2)
        + P y * Q z ^ 3 * d ^ 3) / (P z * Q z * d) ^ 3
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/EulerSineProd.lean
theorem antideriv_sin_comp_const_mul (hz : z ≠ 0) (x : ℝ) :
    HasDerivAt (fun y : ℝ => -Complex.cos (2 * z * y) / (2 * z)) (Complex.sin (2 * z * x)) x
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- A version of `UniformOnFun.hasBasis_nhds_of_basis`
with weaker conclusion and weaker assumptions.

We make no assumptions about the set `𝔖`
but conclude only that the neighbourhoods filter is equal to some indexed infimum. -/
protected theorem nhds_eq_of_basis {ι : Sort*} {p : ι → Prop} {V : ι → Set (β × β)}
    (h : (𝓤 β).HasBasis p V) (f : α →ᵤ[𝔖] β) :
    𝓝 f = ⨅ s ∈ 𝔖, ⨅ (i) (_ : p i), 𝓟 {g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V i}
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp, aesop safe apply (rule_sets := [finsetNonempty])]
lemma nonempty_Ici : (Ici a).Nonempty
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
@[simp]
lemma toMvPolynomial_constantCoeff (f : M₁ →ₗ[R] M₂) (i : ι₂) :
    constantCoeff (f.toMvPolynomial b₁ b₂ i) = 0
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.abs {β} [NormedLatticeAddCommGroup β] {f : α → β} (hf : Integrable f μ) :
    Integrable (fun a => |f a|) μ
-- Mathlib/Topology/Homotopy/Contractible.lean
theorem Nullhomotopic.comp_left {f : C(Y, Z)} (hf : f.Nullhomotopic) (g : C(X, Y)) :
    (f.comp g).Nullhomotopic
-- Mathlib/RingTheory/Unramified/Basic.lean
/-- This holds in general for epimorphisms. -/
theorem of_isLocalization : FormallyUnramified R Rₘ
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_Ioo_of_Ico : AECover (μ.restrict <| Ioo A B) l fun i => Ico (a i) (b i)
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem dvd_term_of_isRoot_of_dvd_terms {r p : S} {f : S[X]} (i : ℕ) (hr : f.IsRoot r)
    (h : ∀ j ≠ i, p ∣ f.coeff j * r ^ j) : p ∣ f.coeff i * r ^ i
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem derivative_pow_succ (p : R[X]) (n : ℕ) :
    derivative (p ^ (n + 1)) = C (n + 1 : R) * p ^ n * derivative p
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Cauchy–Schwarz inequality with norm -/
theorem abs_real_inner_le_norm (x y : F) : |⟪x, y⟫_ℝ| ≤ ‖x‖ * ‖y‖
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem map_apply (hf : Measurable f) {s : Set β} (hs : MeasurableSet s) :
    μ.map f s = μ (f ⁻¹' s)
-- Mathlib/Algebra/GCDMonoid/Nat.lean
theorem normalize_coe_nat (n : ℕ) : normalize (n : ℤ) = n
-- Mathlib/Algebra/MvPolynomial/Derivation.lean
theorem derivation_eq_zero_of_forall_mem_vars {D : Derivation R (MvPolynomial σ R) A}
    {f : MvPolynomial σ R} (h : ∀ i ∈ f.vars, D (X i) = 0) : D f = 0
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem smul_re : (s • a).re = s • a.re
-- Mathlib/Analysis/Complex/RemovableSingularity.lean
/-- **Removable singularity** theorem: if `s` is a neighborhood of `c : ℂ`, a function `f : ℂ → E`
is complex differentiable and is bounded on `s \ {c}`, then `f` redefined to be equal to
`limUnder (𝓝[≠] c) f` at `c` is complex differentiable on `s`. -/
theorem differentiableOn_update_limUnder_of_bddAbove {f : ℂ → E} {s : Set ℂ} {c : ℂ} (hc : s ∈ 𝓝 c)
    (hd : DifferentiableOn ℂ f (s \ {c})) (hb : BddAbove (norm ∘ f '' (s \ {c}))) :
    DifferentiableOn ℂ (update f c (limUnder (𝓝[≠] c) f)) s
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
theorem foldr_loop_succ (f : Fin n → α → α) (x) (h : m < n) :
    foldr.loop n f ⟨m+1, h⟩ x = foldr.loop n f ⟨m, Nat.le_of_lt h⟩ (f ⟨m, h⟩ x)
-- Mathlib/Order/Monotone/Basic.lean
protected theorem StrictAnti.comp_strictAntiOn (hg : StrictAnti g) (hf : StrictAntiOn f s) :
    StrictMonoOn (g ∘ f) s
-- Mathlib/NumberTheory/FermatPsp.lean
/-- If `n` is a Fermat pseudoprime to base `b`, then `n` is coprime with `b`, assuming that `b` is
positive.

This lemma is a small wrapper based on `coprime_of_probablePrime`
-/
theorem coprime_of_fermatPsp {n b : ℕ} (h : FermatPsp n b) (h₁ : 1 ≤ b) : Nat.Coprime n b
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem codRestrict_apply (p : L.Substructure N) (f : M ↪[L] N) {h} (x : M) :
    (codRestrict p f h x : N) = f x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
@[continuity]
theorem continuous_tan : Continuous fun x : {x | cos x ≠ 0} => tan x
-- Mathlib/Topology/IsLocalHomeomorph.lean
lemma isLocallyInjective (hf : IsLocalHomeomorph f) : IsLocallyInjective f
-- Mathlib/Algebra/Lie/Solvable.lean
theorem derivedSeriesOfIdeal_le_self (k : ℕ) : D k I ≤ I
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma p_opcyclesMap : K.pOpcycles i ≫ opcyclesMap φ i = φ.f i ≫ L.pOpcycles i
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
theorem mem_basicOpen_den (x : ProjectiveSpectrum.top 𝒜)
    (f : HomogeneousLocalization.NumDenSameDeg 𝒜 x.asHomogeneousIdeal.toIdeal.primeCompl) :
    x ∈ ProjectiveSpectrum.basicOpen 𝒜 f.den
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.not_and_not_right [Decidable b] : ¬(a ∧ ¬b) ↔ (a → b)
-- Mathlib/Analysis/Normed/Operator/ContinuousLinearMap.lean
@[simp]
theorem LinearMap.toContinuousLinearMap₁_coe (f : 𝕜 →ₗ[𝕜] E) :
    (f.toContinuousLinearMap₁ : 𝕜 →ₗ[𝕜] E) = f
-- Mathlib/CategoryTheory/Sites/Coverage.lean
lemma eq_top_pullback {X Y : C} {S T : Sieve X} (h : S ≤ T) (f : Y ⟶ X) (hf : S f) :
    T.pullback f = ⊤
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
/-- `∧` distributes over `∨` (on the right). -/
theorem or_and_right : (a ∨ b) ∧ c ↔ (a ∧ c) ∨ (b ∧ c)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem coe_copy (S : Subalgebra R A) (s : Set A) (hs : s = ↑S) : (S.copy s hs : Set A) = s
-- Mathlib/Data/Seq/WSeq.lean
@[simp]
theorem dropn_nil (n) : drop (nil : WSeq α) n = nil
-- Mathlib/Analysis/Convex/Cone/Pointed.lean
@[simp, norm_cast]
theorem toConvexCone_positive : ↑(positive 𝕜 E) = ConvexCone.positive 𝕜 E
-- Mathlib/Analysis/Convex/Intrinsic.lean
@[simp]
theorem intrinsicClosure_diff_intrinsicInterior (s : Set P) :
    intrinsicClosure 𝕜 s \ intrinsicInterior 𝕜 s = intrinsicFrontier 𝕜 s
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_closedBall_comm : x ∈ closedBall y ε ↔ y ∈ closedBall x ε
-- Mathlib/Order/SuccPred/Basic.lean
theorem LE.le.exists_succ_iterate (h : a ≤ b) : ∃ n, succ^[n] a = b
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem length_toList_pos_of_mem_support (h : x ∈ p.support) : 0 < length (toList p x)
-- Mathlib/RingTheory/Ideal/Over.lean
/-- This technical lemma asserts the existence of a polynomial `p` in an ideal `P ⊂ R[x]`
that is non-zero in the quotient `R / (P ∩ R) [x]`.  The assumptions are equivalent to
`P ≠ 0` and `P ∩ R = (0)`.
-/
theorem exists_nonzero_mem_of_ne_bot {P : Ideal R[X]} (Pb : P ≠ ⊥) (hP : ∀ x : R, C x ∈ P → x = 0) :
    ∃ p : R[X], p ∈ P ∧ Polynomial.map (Quotient.mk (P.comap (C : R →+* R[X]))) p ≠ 0
-- Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean
/-- An endomorphism of a finite-dimensional vector space has a finite spectrum. -/
theorem Module.End.finite_spectrum {K : Type v} {V : Type w} [Field K] [AddCommGroup V]
    [Module K V] [FiniteDimensional K V] (f : Module.End K V) :
    Set.Finite (spectrum K f)
-- Mathlib/Topology/MetricSpace/Contracting.lean
/-- If a map `f` has a contracting iterate `f^[n]`, then the fixed point of `f^[n]` is also a fixed
point of `f`. -/
theorem isFixedPt_fixedPoint_iterate {n : ℕ} (hf : ContractingWith K f^[n]) :
    IsFixedPt f (hf.fixedPoint f^[n])
-- Mathlib/Data/List/Enum.lean
theorem get?_enum (l : List α) (n) : get? (enum l) n = (get? l n).map fun a => (n, a)
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem map_inv_lt_iff (f : F) {a : α} {b : β} : EquivLike.inv f b < a ↔ b < f a
-- Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean
theorem unitization_range : (unitization s).range = StarAlgebra.adjoin R s
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- A set is analytic if and only if it is the continuous image of some Polish space. -/
theorem analyticSet_iff_exists_polishSpace_range {s : Set α} :
    AnalyticSet s ↔
      ∃ (β : Type) (h : TopologicalSpace β) (_ : @PolishSpace β h) (f : β → α),
        @Continuous _ _ h _ f ∧ range f = s
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
theorem separableSpace_range_union_singleton {_ : MeasurableSpace α} [TopologicalSpace β]
    [PseudoMetrizableSpace β] (hf : StronglyMeasurable f) {b : β} :
    SeparableSpace (range f ∪ {b} : Set β)
-- Mathlib/RingTheory/Ideal/Maps.lean
theorem smul_restrictScalars {R S M} [CommSemiring R] [CommSemiring S]
    [Algebra R S] [AddCommMonoid M] [Module R M] [Module S M]
    [IsScalarTower R S M] (I : Ideal R) (N : Submodule S M) :
    (I.map (algebraMap R S) • N).restrictScalars R = I • N.restrictScalars R
-- Mathlib/RingTheory/Int/Basic.lean
theorem Int.exists_prime_and_dvd {n : ℤ} (hn : n.natAbs ≠ 1) : ∃ p, Prime p ∧ p ∣ n
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
@[simp]
theorem comap_id : comap (RingHom.id R) = ContinuousMap.id _
-- Mathlib/Data/Int/SuccPred.lean
theorem pred_iterate (a : ℤ) : ∀ n, pred^[n] a = a - n
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.basis_self (h : M.Indep I) : M.Basis I I
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
@[simp]
theorem re_neg (z : 𝔻) : (-z).re = -z.re
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem support_neg [∀ i, AddGroup (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] {f : Π₀ i, β i} :
    support (-f) = support f
-- Mathlib/Probability/Process/Stopping.lean
theorem measurableSet_min_const_iff (hτ : IsStoppingTime f τ) (s : Set Ω) {i : ι} :
    MeasurableSet[(hτ.min_const i).measurableSpace] s ↔
      MeasurableSet[hτ.measurableSpace] s ∧ MeasurableSet[f i] s
-- Mathlib/Data/List/Sort.lean
theorem perm_insertionSort : ∀ l : List α, insertionSort r l ~ l
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
/-- If `Irreducible (cyclotomic (2 ^ k) K)` (in particular for `K = ℚ`) and `k` is at least `2`,
then the norm of `ζ - 1` is `2`. -/
theorem norm_sub_one_two {k : ℕ} (hζ : IsPrimitiveRoot ζ (2 ^ k)) (hk : 2 ≤ k)
    [H : IsCyclotomicExtension {(2 : ℕ+) ^ k} K L] (hirr : Irreducible (cyclotomic (2 ^ k) K)) :
    norm K (ζ - 1) = 2
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem Filter.coLindelof_neBot_iff : NeBot (Filter.coLindelof X) ↔ NonLindelofSpace X
-- .lake/packages/lean4/src/lean/Init/Omega/Coeffs.lean
theorem dot_set_left (xs ys : Coeffs) (i : Nat) (z : Int) :
    dot (set xs i z) ys = dot xs ys + (z - get xs i) * get ys i
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The angle between a positive multiple of a vector and a vector. -/
@[simp]
theorem angle_smul_left_of_pos (x y : V) {r : ℝ} (hr : 0 < r) : angle (r • x) y = angle x y
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem reachable_iff_reflTransGen (u v : V) :
    G.Reachable u v ↔ Relation.ReflTransGen G.Adj u v
-- Mathlib/CategoryTheory/Triangulated/Opposite.lean
lemma shift_unop_opShiftFunctorEquivalence_counitIso_inv_app (X : Cᵒᵖ) (n : ℤ) :
    ((opShiftFunctorEquivalence C n).counitIso.inv.app X).unop⟦n⟧' =
      ((opShiftFunctorEquivalence C n).unitIso.hom.app ((Opposite.op ((X.unop)⟦n⟧)))).unop
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem Complex.coe_orthonormalBasisOneI :
    (Complex.orthonormalBasisOneI : Fin 2 → ℂ) = ![1, I]