ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Geometry/Manifold/ChartedSpace.lean
/-- If `s` is a non-empty open subset of `M`, every chart of `s` is the restriction
 of some chart on `M`. -/
lemma chart_eq {s : Opens M} (hs : Nonempty s) {e : PartialHomeomorph s H} (he : e ∈ atlas H s) :
    ∃ x : s, e = (chartAt H (x : M)).subtypeRestr hs
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addY_of_Z_eq_zero_left {P Q : Fin 3 → R} (hP : W'.Equation P) (hPz : P z = 0) :
    W'.addY P Q = (P x * Q z) ^ 3 * Q y
-- Mathlib/Topology/Basic.lean
theorem mem_nhds_iff : s ∈ 𝓝 x ↔ ∃ t ⊆ s, IsOpen t ∧ x ∈ t
-- Mathlib/Topology/Compactification/OnePoint.lean
@[simp]
theorem infty_ne_coe (x : X) : ∞ ≠ (x : OnePoint X)
-- Mathlib/Topology/Order/LocalExtr.lean
theorem isLocalMin_const {b : β} : IsLocalMin (fun _ => b) a
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/SimplyConnected.lean
/-- In a simply connected space, any two paths are homotopic -/
theorem paths_homotopic {x y : X} (p₁ p₂ : Path x y) : Path.Homotopic p₁ p₂
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem ne_zero_of_mul_ne_zero_left (h : n * m ≠ 0) : n ≠ 0
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem IsEquivalent.tendsto_nhds_iff {c : β} (huv : u ~[l] v) :
    Tendsto u l (𝓝 c) ↔ Tendsto v l (𝓝 c)
-- Mathlib/Data/Sum/Interval.lean
lemma Ioo_inr_inr :
    Ioo (inrₗ b₁ : α ⊕ₗ β) (inrₗ b₂) = (Ioo b₁ b₂).map (Embedding.inr.trans toLex.toEmbedding)
-- Mathlib/Algebra/Order/Monoid/Defs.lean
/-- An ordered (additive) commutative monoid is a commutative monoid with a partial order such that
addition is monotone. -/
class OrderedAddCommMonoid (α : Type*) extends AddCommMonoid α, PartialOrder α where
  protected add_le_add_left : ∀ a b : α, a ≤ b → ∀ c, c + a ≤ c + b
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp]
theorem mersenne_lt_mersenne {p q : ℕ} : mersenne p < mersenne q ↔ p < q
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem ker_prod [Module R₁ M₂] [Module R₁ M₃] (f : M₁ →L[R₁] M₂) (g : M₁ →L[R₁] M₃) :
    ker (f.prod g) = ker f ⊓ ker g
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem gc_homogeneousIdeal :
    @GaloisConnection (HomogeneousIdeal 𝒜) (Set (ProjectiveSpectrum 𝒜))ᵒᵈ _ _
      (fun I => zeroLocus 𝒜 I) fun t => vanishingIdeal t
-- Mathlib/Topology/MetricSpace/CantorScheme.lean
/-- A scheme on a complete space with vanishing diameter
such that each set contains the closure of its children
induces a total map. -/
theorem ClosureAntitone.map_of_vanishingDiam [CompleteSpace α] (hdiam : VanishingDiam A)
    (hanti : ClosureAntitone A) (hnonempty : ∀ l, (A l).Nonempty) : (inducedMap A).1 = univ
-- Mathlib/Algebra/Algebra/Hom.lean
@[norm_cast]
theorem coe_mks {f : A → B} (h₁ h₂ h₃ h₄ h₅) : ⇑(⟨⟨⟨⟨f, h₁⟩, h₂⟩, h₃, h₄⟩, h₅⟩ : A →ₐ[R] B) = f
-- Mathlib/Data/Real/Irrational.lean
theorem ne_zero (h : Irrational x) : x ≠ 0
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem iota_zero : iota 0 = []
-- Mathlib/Order/Hom/Lattice.lean
/-- Adjoins a `⊤` to the domain and codomain of a `SupHom`. -/
@[simps]
protected def withTop (f : SupHom α β) : SupHom (WithTop α) (WithTop β)
-- .lake/packages/lean4/src/lean/Init/GetElem.lean
theorem getElem?_neg [GetElem? cont idx elem dom] [LawfulGetElem cont idx elem dom]
    (c : cont) (i : idx) (h : ¬dom c i) [Decidable (dom c i)] : c[i]? = none
-- Mathlib/Algebra/GradedMonoid.lean
/-- A version of `List.coe_dProd_set_like` with `Subtype.mk`. -/
theorem SetLike.list_dProd_eq (A : ι → S) [SetLike.GradedMonoid A] (fι : α → ι) (fA : ∀ a, A (fι a))
    (l : List α) :
    (@List.dProd _ _ (fun i => ↥(A i)) _ _ l fι fA) =
      ⟨List.prod (l.map fun a => fA a),
        (l.dProdIndex_eq_map_sum fι).symm ▸
          list_prod_map_mem_graded l _ _ fun i _ => (fA i).prop⟩
-- Mathlib/Data/Finset/Interval.lean
theorem Icc_eq_image_powerset (h : s ⊆ t) : Icc s t = (t \ s).powerset.image (s ∪ ·)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_right_inj {a b c : Ordinal} (a0 : 0 < a) : a * b = a * c ↔ b = c
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem uniformEmbedding_inr : UniformEmbedding (Sum.inr : β → α ⊕ β)
-- Mathlib/RingTheory/Congruence/Basic.lean
@[simp, norm_cast]
theorem coe_top : ⇑(⊤ : RingCon R) = ⊤
-- Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean
theorem Matrix.rank_vecMulVec {K m n : Type u} [CommRing K] [Fintype n]
    [DecidableEq n] (w : m → K) (v : n → K) : (Matrix.vecMulVec w v).toLin'.rank ≤ 1
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `F` is a field of exponential characteristic `q`, `F(S) / F` is separable, then
`F(S) = F(S ^ (q ^ n))` for any natural number `n`. -/
theorem adjoin_eq_adjoin_pow_expChar_pow_of_isSeparable (S : Set E)
    [Algebra.IsSeparable F (adjoin F S)] (q : ℕ) [ExpChar F q] (n : ℕ) :
    adjoin F S = adjoin F ((· ^ q ^ n) '' S)
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
@[reassoc]
theorem biproduct.matrix_map {f : J → C} {g : K → C} {h : K → C} (m : ∀ j k, f j ⟶ g k)
    (n : ∀ k, g k ⟶ h k) :
    biproduct.matrix m ≫ biproduct.map n = biproduct.matrix fun j k => m j k ≫ n k
-- Mathlib/Algebra/Order/Floor.lean
theorem lt_ceil : n < ⌈a⌉₊ ↔ (n : α) < a
-- Mathlib/MeasureTheory/Integral/Bochner.lean
@[simp]
theorem integral_dirac [MeasurableSpace α] [MeasurableSingletonClass α] (f : α → E) (a : α) :
    ∫ x, f x ∂Measure.dirac a = f a
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.symm (h : IsBigOWith c l (fun x => f₁ x - f₂ x) g) :
    IsBigOWith c l (fun x => f₂ x - f₁ x) g
-- Mathlib/Topology/Instances/PNat.lean
@[simp, norm_cast]
theorem dist_coe (x y : ℕ+) : dist (↑x : ℕ) (↑y : ℕ) = dist x y
-- Mathlib/Order/BoundedOrder.lean
@[simp]
theorem isMin_bot : IsMin (⊥ : α)
-- Mathlib/Algebra/Homology/HomotopyCategory.lean
@[simp 1100]
theorem quotient_map_out_comp_out {C D E : HomotopyCategory V c} (f : C ⟶ D) (g : D ⟶ E) :
    (quotient V c).map (Quot.out f ≫ Quot.out g) = f ≫ g
-- Mathlib/Data/Finset/Basic.lean
theorem not_mem_erase (a : α) (s : Finset α) : a ∉ erase s a
-- Mathlib/Logic/Equiv/Pairwise.lean
lemma EmbeddingLike.pairwise_comp {X : Type*} {Y : Type*} {F} [FunLike F Y X] [EmbeddingLike F Y X]
    (f : F) {p : X → X → Prop} (h : Pairwise p) : Pairwise (p on f)
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpL1_mono {E} [NormedLatticeAddCommGroup E] [CompleteSpace E] [NormedSpace ℝ E]
    [OrderedSMul ℝ E] {f g : α → E} (hf : Integrable f μ) (hg : Integrable g μ) (hfg : f ≤ᵐ[μ] g) :
    condexpL1 hm μ f ≤ᵐ[μ] condexpL1 hm μ g
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem tendsto_log_nat_add_one_sub_log : Tendsto (fun k : ℕ => log (k + 1) - log k) atTop (𝓝 0)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Basic.lean
theorem shiftRight_eq_div_pow (m : Nat) : ∀ n, m >>> n = m / 2 ^ n
-- Mathlib/RingTheory/Etale/Basic.lean
theorem of_isLocalization : FormallyEtale R Rₘ
-- Mathlib/Algebra/Order/AbsoluteValue.lean
@[simp]
protected theorem pos_iff {x : R} : 0 < abv x ↔ x ≠ 0
-- Mathlib/GroupTheory/GroupAction/Quotient.lean
@[to_additive (attr := simp)]
theorem Quotient.smul_mk [QuotientAction β H] (b : β) (a : α) :
    (b • QuotientGroup.mk a : α ⧸ H) = QuotientGroup.mk (b • a)
-- Mathlib/Data/Vector/Mem.lean
theorem not_mem_map_zero (b : β) (v : Vector α 0) (f : α → β) : b ∉ (v.map f).toList
-- Mathlib/Topology/Constructions.lean
theorem embedding_sigmaMk {i : ι} : Embedding (@Sigma.mk ι σ i)
-- Mathlib/Analysis/NormedSpace/Multilinear/Curry.lean
@[simp]
theorem ContinuousLinearMap.uncurryLeft_norm
    (f : Ei 0 →L[𝕜] ContinuousMultilinearMap 𝕜 (fun i : Fin n => Ei i.succ) G) :
    ‖f.uncurryLeft‖ = ‖f‖
-- Mathlib/Data/Matroid/Basic.lean
theorem Basis.subset (hI : M.Basis I X) : I ⊆ X
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
@[simp] theorem zipWith_replicate {a : α} {b : β} {m n : Nat} :
    zipWith f (replicate m a) (replicate n b) = replicate (min m n) (f a b)
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem finite_Ioo : (Ioo a b).Finite
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiff.of_succ {n : ℕ} (h : ContMDiff I I' n.succ f) : ContMDiff I I' n f
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem erase_zero (n : ℕ) : (0 : R[X]).erase n = 0
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
/-- To check that a function is `n` times continuously differentiable, it suffices to check that its
first `n` derivatives are differentiable. This is slightly too strong as the condition we
require on the `n`-th derivative is differentiability instead of continuity, but it has the
advantage of avoiding the discussion of continuity in the proof (and for `n = ∞` this is optimal).
-/
theorem contDiff_of_differentiable_iteratedDeriv {n : ℕ∞}
    (h : ∀ m : ℕ, (m : ℕ∞) ≤ n → Differentiable 𝕜 (iteratedDeriv m f)) : ContDiff 𝕜 n f
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousOn.piecewise {s t : Set α} {f g : α → β} [∀ a, Decidable (a ∈ t)]
    (ht : ∀ a ∈ s ∩ frontier t, f a = g a) (hf : ContinuousOn f <| s ∩ closure t)
    (hg : ContinuousOn g <| s ∩ closure tᶜ) : ContinuousOn (piecewise t f g) s
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_add_le_of_degree_le {p q : R[X]} {n : ℕ} (hp : natDegree p ≤ n)
    (hq : natDegree q ≤ n) : natDegree (p + q) ≤ n
-- Mathlib/Algebra/Opposites.lean
@[simp] lemma unop_neg [Neg α] (x : αᵐᵒᵖ) : unop (-x) = -unop x
-- Mathlib/GroupTheory/Perm/List.lean
theorem mem_of_formPerm_apply_ne (h : l.formPerm x ≠ x) : x ∈ l
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] lemma forget_map {X Y : SemiRingCat} (f : X ⟶ Y) :
    (forget SemiRingCat).map f = (f : X → Y)
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem star_apply (f : α →ᵇ β) (x : α) : star f x = star (f x)
-- Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean
lemma ext_to_iff (i j : ℤ) (hij : i + 1 = j) {A : C} (f g : A ⟶ (mappingCone φ).X i) :
    f = g ↔ f ≫ (fst φ).1.v i j hij = g ≫ (fst φ).1.v i j hij ∧
      f ≫ (snd φ).v i i (add_zero i) = g ≫ (snd φ).v i i (add_zero i)
-- Mathlib/MeasureTheory/Function/SpecialFunctions/Basic.lean
@[measurability]
theorem measurable_re : Measurable re
-- Mathlib/RingTheory/WittVector/Truncated.lean
@[simp]
theorem coeff_truncate {m : ℕ} (hm : n ≤ m) (i : Fin n) (x : TruncatedWittVector p m R) :
    (truncate hm x).coeff i = x.coeff (Fin.castLE hm i)
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
lemma delta_mul {n : ℕ} (χ : DirichletCharacter ℂ n) : δ * ↗χ = δ
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_lt_iff (a b c : Int) : a + b < c ↔ a < -b + c
-- Mathlib/Topology/IsLocalHomeomorph.lean
protected theorem IsLocalHomeomorph.isLocalHomeomorphOn (hf : IsLocalHomeomorph f) :
    IsLocalHomeomorphOn f s
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
theorem quotQuotEquivQuotOfLE_comp_quotQuotMk (h : I ≤ J) :
    RingHom.comp (↑(quotQuotEquivQuotOfLE h)) (quotQuotMk I J) = (Ideal.Quotient.mk J)
-- Mathlib/LinearAlgebra/Isomorphisms.lean
theorem quotientInfEquivSupQuotient_injective (p p' : Submodule R M) :
    Function.Injective (quotientInfToSupQuotient p p')
-- Mathlib/Order/Interval/Set/Image.lean
theorem image_subtype_val_Ici_subset (a : {x // p x}) :
    Subtype.val '' Ici a ⊆ Ici a.val
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.hasZeroObject (h : S.Exact) : HasZeroObject C
-- Mathlib/Data/Nat/Factorization/Basic.lean
@[simp]
lemma factorizationLCRight_zero_left : factorizationLCMRight 0 b = 1
-- Mathlib/Logic/Equiv/Fin.lean
theorem coe_finRotate_of_ne_last {i : Fin n.succ} (h : i ≠ Fin.last n) :
    (finRotate (n + 1) i : ℕ) = i + 1
-- Mathlib/Analysis/Asymptotics/Theta.lean
lemma IsTheta.isTheta_congr_left (h : f' =Θ[l] g') : f' =Θ[l] k ↔ g' =Θ[l] k
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem eqLocus_same (f : R →+* S) : f.eqLocus f = ⊤
-- Mathlib/Data/Matrix/RowCol.lean
theorem row_injective [Nonempty ι] : Function.Injective (row ι : (n → α) → Matrix ι n α)
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
lemma nnnorm_inr (a : A) : ‖(a : Unitization 𝕜 A)‖₊ = ‖a‖₊
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem filter_ne_eq_erase (f : Π₀ i, β i) (i : ι) : f.filter (· ≠ i) = f.erase i
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[gcongr] theorem rpow_lt_rpow {x y : ℝ≥0} {z : ℝ} (h₁ : x < y) (h₂ : 0 < z) : x ^ z < y ^ z
-- Mathlib/RingTheory/WittVector/Basic.lean
theorem intCast (n : ℤ) : mapFun f (n : 𝕎 R) = n
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Ioc_erase_right (a b : α) : (Ioc a b).erase b = Ioo a b
-- Mathlib/Topology/Separation.lean
theorem isClosed_setOf_inseparable : IsClosed { p : X × X | Inseparable p.1 p.2 }
-- Mathlib/Data/Set/Basic.lean
theorem inter_subset_ite (t s s' : Set α) : s ∩ s' ⊆ t.ite s s'
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem dualCopairing_apply {W : Submodule R M} (φ : W.dualAnnihilator) (x : M) :
    W.dualCopairing φ (Quotient.mk x) = φ x
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
nonrec theorem HasFDerivAt.const_sub (hf : HasFDerivAt f f' x) (c : F) :
    HasFDerivAt (fun x => c - f x) (-f') x
-- Mathlib/Analysis/Convex/Side.lean
theorem wOppSide_of_left_mem {s : AffineSubspace R P} {x : P} (y : P) (hx : x ∈ s) :
    s.WOppSide x y
-- Mathlib/Geometry/Manifold/ContMDiffMFDeriv.lean
/-- If a function is `C^n` on a domain with unique derivatives, with `1 ≤ n`, then its bundled
derivative is continuous there. -/
theorem ContMDiffOn.continuousOn_tangentMapWithin (hf : ContMDiffOn I I' n f s) (hmn : 1 ≤ n)
    (hs : UniqueMDiffOn I s) :
    ContinuousOn (tangentMapWithin I I' f s) (π E (TangentSpace I) ⁻¹' s)
-- Mathlib/CategoryTheory/Shift/CommShift.lean
lemma commShiftIso_zero :
    F.commShiftIso (0 : A) = CommShift.isoZero F A
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem HasFiniteFPowerSeriesOnBall.changeOrigin (hf : HasFiniteFPowerSeriesOnBall f p x n r)
    (h : (‖y‖₊ : ℝ≥0∞) < r) :
    HasFiniteFPowerSeriesOnBall f (p.changeOrigin y) (x + y) n (r - ‖y‖₊)
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `M` and `N` are linearly disjoint, if `M` is a flat `R`-module, then for any family of
`R`-linearly independent elements `{ n_i }` of `N`, they are also `M`-linearly independent,
in the sense that the `R`-linear map from `ι →₀ M` to `S` which maps `{ m_i }`
to the sum of `m_i * n_i` (`Submodule.mulRightMap M n`) has trivial kernel. -/
theorem linearIndependent_right_of_flat (H : M.LinearDisjoint N) [Module.Flat R M]
    {ι : Type*} {n : ι → N} (hn : LinearIndependent R n) : LinearMap.ker (mulRightMap M n) = ⊥
-- Mathlib/Algebra/Order/Archimedean.lean
/-- For any `y < 1` and any positive `x`, there exists `n : ℕ` with `y ^ n < x`. -/
theorem exists_pow_lt_of_lt_one (hx : 0 < x) (hy : y < 1) : ∃ n : ℕ, y ^ n < x
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
@[simp] theorem testBit_xor (x y i : Nat) :
    (x ^^^ y).testBit i = Bool.xor (x.testBit i) (y.testBit i)
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem exp_neg_mul_rpow_isLittleO_exp_neg {p b : ℝ} (hb : 0 < b) (hp : 1 < p) :
    (fun x : ℝ => exp (- b * x ^ p)) =o[atTop] fun x : ℝ => exp (-x)
-- Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean
/-- Every element `a` in a nontrivial finite-dimensional algebra `A`
over an algebraically closed field `𝕜` has non-empty spectrum. -/
theorem nonempty_of_isAlgClosed_of_finiteDimensional [IsAlgClosed 𝕜] [Nontrivial A]
    [I : FiniteDimensional 𝕜 A] (a : A) : (σ a).Nonempty
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem mulPosMono_iff_covariant_pos :
    MulPosMono α ↔ CovariantClass α>0 α (fun x y => y * x) (· ≤ ·)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_le_div_left (ha : 0 < a) (hb : 0 < b) (hc : 0 < c) : a / b ≤ a / c ↔ c ≤ b
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem eval₂_pow' (n : ℕ) :
    (p ^ n).eval₂ (algebraMap R S) x = (p.eval₂ (algebraMap R S) x) ^ n
-- Mathlib/Algebra/Group/Nat.lean
@[parity_simps] lemma even_add : Even (m + n) ↔ (Even m ↔ Even n)
-- Mathlib/Algebra/BigOperators/Associated.lean
theorem Prime.not_dvd_finsupp_prod {f : α →₀ M} {g : α → M → ℕ} {p : ℕ} (pp : Prime p)
    (hS : ∀ a ∈ f.support, ¬p ∣ g a (f a)) : ¬p ∣ f.prod g
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
@[simp]
theorem coe_nsmul (r : ℕ) (f : α →ᵇ β) : ⇑(r • f) = r • ⇑f
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simps]
instance (V : Type u) : Inhabited (SimpleGraph V)
-- Mathlib/Topology/Homotopy/Basic.lean
theorem symm_trans {f₀ f₁ f₂ : C(X, Y)} (F : HomotopyWith f₀ f₁ P) (G : HomotopyWith f₁ f₂ P) :
    (F.trans G).symm = G.symm.trans F.symm
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem isNoetherian_iff {I : FractionalIdeal R₁⁰ K} :
    IsNoetherian R₁ I ↔ ∀ J ≤ I, (J : Submodule R₁ K).FG
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpL1_sub (hf : Integrable f μ) (hg : Integrable g μ) :
    condexpL1 hm μ (f - g) = condexpL1 hm μ f - condexpL1 hm μ g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean
@[simp]
theorem algebraMap_eval_U (x : R) (n : ℤ) :
    algebraMap R A ((U R n).eval x) = (U A n).eval (algebraMap R A x)
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive]
theorem min_one (a : α) : min a 1 = 1
-- Mathlib/Algebra/DirectSum/Basic.lean
@[simp]
theorem sub_apply (g₁ g₂ : ⨁ i, β i) (i : ι) : (g₁ - g₂) i = g₁ i - g₂ i
-- Mathlib/CategoryTheory/Category/Pointed.lean
@[simp] lemma Hom.comp_toFun' {X Y Z : Pointed.{u}} (f : X ⟶ Y) (g : Y ⟶ Z) :
    (f ≫ g).toFun = g.toFun ∘ f.toFun
-- Mathlib/Algebra/Module/LocalizedModule.lean
/--
If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
there is a linear map `lift g ∘ mkLinearMap = g`.
-/
theorem lift_comp (g : M →ₗ[R] M'') (h : ∀ x : S, IsUnit ((algebraMap R (Module.End R M'')) x)) :
    (lift S g h).comp (mkLinearMap S M) = g
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Product.lean
@[simp]
theorem projLeft_map (x₀ x₁ : πₓ (TopCat.of (A × B))) (p : x₀ ⟶ x₁) :
    (projLeft A B).map p = Path.Homotopic.projLeft p
-- Mathlib/Order/Birkhoff.lean
lemma exists_birkhoff_representation.{u} (α : Type u) [Finite α] [DistribLattice α] :
    ∃ (β : Type u) (_ : DecidableEq β) (_ : Fintype β) (f : LatticeHom α (Finset β)),
      Injective f
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma isZero₂_of_isZero₁₃ (h₁ : IsZero T.obj₁) (h₃ : IsZero T.obj₃) : IsZero T.obj₂
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMin.sup (hf : IsLocalMin f a) (hg : IsLocalMin g a) :
    IsLocalMin (fun x => f x ⊔ g x) a
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[norm_cast]
theorem natCast_pow {m n : ℕ} : (↑(m ^ n) : Cardinal) = (↑m : Cardinal) ^ (↑n : Cardinal)
-- Mathlib/Algebra/Quaternion.lean
@[norm_cast, simp]
theorem coe_sub : ((x - y : R) : ℍ[R,c₁,c₂]) = x - y
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
/-- If a `E ⋙ F` has a colimit, and `E` is an equivalence, we can construct a colimit of `F`.
-/
theorem hasColimit_of_equivalence_comp (e : K ≌ J) [HasColimit (e.functor ⋙ F)] : HasColimit F
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma fromColumns_apply_inr (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R) (i : m) (j : n₂) :
    (fromColumns A₁ A₂) i (Sum.inr j) = A₂ i j
-- Mathlib/RingTheory/Adjoin/Basic.lean
theorem adjoin_eq_span : Subalgebra.toSubmodule (adjoin R s) = span R (Submonoid.closure s)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
protected theorem ext_iff {f g : CircleDeg1Lift} : f = g ↔ ∀ x, f x = g x
-- Mathlib/Data/Fin/Basic.lean
lemma succAbove_castPred_of_le (p i : Fin (n + 1)) (h : p ≤ i) (hi : i ≠ last n) :
    succAbove p (i.castPred hi) = (i.castPred hi).succ
-- Mathlib/Algebra/Order/Sub/Basic.lean
theorem le_tsub_mul {R : Type*} [CommSemiring R] [Preorder R] [Sub R] [OrderedSub R]
    [CovariantClass R R (· * ·) (· ≤ ·)] {a b c : R} : a * c - b * c ≤ (a - b) * c
-- Mathlib/Topology/Hom/Open.lean
@[simp]
theorem comp_assoc (f : γ →CO δ) (g : β →CO γ) (h : α →CO β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle as a ratio of sides. -/
theorem tan_oangle_right_of_oangle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∡ p₁ p₂ p₃ = ↑(π / 2)) :
    Real.Angle.tan (∡ p₂ p₃ p₁) = dist p₁ p₂ / dist p₃ p₂
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem mem_im_objs_iff (hφ : Function.Injective φ.obj) (d : D) :
    d ∈ (im φ hφ).objs ↔ ∃ c : C, φ.obj c = d
-- Mathlib/NumberTheory/VonMangoldt.lean
theorem vonMangoldt_eq_zero_iff {n : ℕ} : Λ n = 0 ↔ ¬IsPrimePow n
-- Mathlib/Analysis/Convex/Basic.lean
theorem AntitoneOn.convex_gt (hf : AntitoneOn f s) (hs : Convex 𝕜 s) (r : β) :
    Convex 𝕜 ({ x ∈ s | r < f x })
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
/-- `arsinh` is the left inverse of `sinh`. -/
@[simp]
theorem arsinh_sinh (x : ℝ) : arsinh (sinh x) = x
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
@[simp]
theorem mk_coe (f : L →ₗ[R] M) (h₁) : ((⟨f, h₁⟩ : LieDerivation R L M) : L → M) = f
-- Mathlib/Topology/Sets/Order.lean
theorem upper (s : ClopenUpperSet α) : IsUpperSet (s : Set α)
-- Mathlib/Control/Bitraversable/Lemmas.lean
@[higher_order tfst_comp_tfst]
theorem comp_tfst {α₀ α₁ α₂ β} (f : α₀ → F α₁) (f' : α₁ → G α₂) (x : t α₀ β) :
    Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x
-- Mathlib/Algebra/Periodic.lean
protected theorem Periodic.eq [AddZeroClass α] (h : Periodic f c) : f c = f 0
-- Mathlib/Analysis/Analytic/Composition.lean
/-- The `0`-th coefficient of `q.comp p` is `q 0`. When `p` goes from `E` to `E`, this can be
expressed as a direct equality -/
theorem comp_coeff_zero'' (q : FormalMultilinearSeries 𝕜 E F) (p : FormalMultilinearSeries 𝕜 E E) :
    (q.comp p) 0 = q 0
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem dist_triangle_right (x y z : α) : dist x y ≤ dist x z + dist y z
-- Mathlib/Analysis/BoxIntegral/Basic.lean
theorem Integrable.add (hf : Integrable I l f vol) (hg : Integrable I l g vol) :
    Integrable I l (f + g) vol
-- Mathlib/CategoryTheory/Idempotents/Basic.lean
/-- A category is idempotent complete iff all idempotent endomorphisms `p`
split as a composition `p = e ≫ i` with `i ≫ e = 𝟙 _` -/
class IsIdempotentComplete : Prop where
  /-- A category is idempotent complete iff all idempotent endomorphisms `p`
    split as a composition `p = e ≫ i` with `i ≫ e = 𝟙 _` -/
  idempotents_split :
    ∀ (X : C) (p : X ⟶ X), p ≫ p = p → ∃ (Y : C) (i : Y ⟶ X) (e : X ⟶ Y), i ≫ e = 𝟙 Y ∧ e ≫ i = p
-- Mathlib/MeasureTheory/Covering/LiminfLimsup.lean
theorem blimsup_cthickening_ae_eq_blimsup_thickening {p : ℕ → Prop} {s : ℕ → Set α} {r : ℕ → ℝ}
    (hr : Tendsto r atTop (𝓝 0)) (hr' : ∀ᶠ i in atTop, p i → 0 < r i) :
    (blimsup (fun i => cthickening (r i) (s i)) atTop p : Set α) =ᵐ[μ]
      (blimsup (fun i => thickening (r i) (s i)) atTop p : Set α)
-- Mathlib/Data/Nat/ModEq.lean
@[simp] lemma modEq_zero_iff : a ≡ b [MOD 0] ↔ a = b
-- Mathlib/CategoryTheory/ConcreteCategory/EpiMono.lean
lemma surjective_eq_epimorphisms [(forget C).PreservesEpimorphisms] :
    MorphismProperty.surjective C = epimorphisms C
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.sub_zsmul_eq [AddGroup α] [AddGroup β] (h : Antiperiodic f c) (n : ℤ) :
    f (x - n • c) = (n.negOnePow : ℤ) • f x
-- Mathlib/Algebra/Polynomial/Laurent.lean
theorem isUnit_T (n : ℤ) : IsUnit (T n : R[T;T⁻¹])
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem isCompactElement_top : CompleteLattice.IsCompactElement (⊤ : Ideal α)
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiffWithinAt.inv {f : E → 𝕜'} {n} (hf : ContDiffWithinAt 𝕜 n f s x) (hx : f x ≠ 0) :
    ContDiffWithinAt 𝕜 n (fun x => (f x)⁻¹) s x
-- Mathlib/CategoryTheory/Sites/Over.lean
lemma over_forget_coverPreserving (X : C) :
    CoverPreserving (J.over X) J (Over.forget X)
-- Mathlib/Algebra/Field/Basic.lean
protected theorem Commute.one_div_add_one_div (hab : Commute a b) (ha : a ≠ 0) (hb : b ≠ 0) :
    1 / a + 1 / b = (a + b) / (a * b)
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem isClosed_iff_zeroLocus_ideal (Z : Set (PrimeSpectrum R)) :
    IsClosed Z ↔ ∃ I : Ideal R, Z = zeroLocus I
-- Mathlib/Data/ENat/Lattice.lean
lemma iInf_coe_ne_top : ⨅ i, (f i : ℕ∞) ≠ ⊤ ↔ Nonempty ι