ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Finset/Card.lean
theorem card_erase_lt_of_mem : a ∈ s → (s.erase a).card < s.card
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
@[simp] lemma in₀₁_iff : (graph t).Adj (in₀ a) (in₁ b) ↔ ∃ c, (a, b, c) ∈ t
-- Mathlib/Data/List/Cycle.lean
theorem chain_of_pairwise : (∀ a ∈ s, ∀ b ∈ s, r a b) → Chain r s
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean
lemma odd_card_iff_odd_components : Odd (Nat.card V) ↔
    Odd (Nat.card ({(c : ConnectedComponent G) | Odd (Nat.card c.supp)}))
-- Mathlib/NumberTheory/Pell.lean
/-- Every solution is, up to a sign, a power of a given fundamental solution. -/
theorem eq_zpow_or_neg_zpow {a₁ : Solution₁ d} (h : IsFundamental a₁) (a : Solution₁ d) :
    ∃ n : ℤ, a = a₁ ^ n ∨ a = -a₁ ^ n
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_cubic_le : degree (C a * X ^ 3 + C b * X ^ 2 + C c * X + C d) ≤ 3
-- .lake/packages/lean4/src/lean/Init/Control/Lawful/Basic.lean
@[simp] theorem bind_eq (x : Id α) (f : α → id β) : x >>= f = f x
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
theorem adjointAux_inner_right (A : E →L[𝕜] F) (x : E) (y : F) :
    ⟪x, adjointAux A y⟫ = ⟪A x, y⟫
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Lagrange's **Mean Value Theorem**, applied to convex domains. -/
theorem domain_mvt {f : E → ℝ} {s : Set E} {x y : E} {f' : E → E →L[ℝ] ℝ}
    (hf : ∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) (hs : Convex ℝ s) (xs : x ∈ s) (ys : y ∈ s) :
    ∃ z ∈ segment ℝ x y, f y - f x = f' z (y - x)
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem ListBlank.nth_zero {Γ} [Inhabited Γ] (l : ListBlank Γ) : l.nth 0 = l.head
-- Mathlib/RingTheory/WittVector/Basic.lean
theorem pow (n : ℕ) : mapFun f (x ^ n) = mapFun f x ^ n
-- Mathlib/Analysis/Analytic/Composition.lean
/-- Composing the partial sums of two multilinear series coincides with the sum over all
compositions in `comp_partial_sum_target 0 N N`. This is precisely the motivation for the
definition of `comp_partial_sum_target`. -/
theorem comp_partialSum (q : FormalMultilinearSeries 𝕜 F G) (p : FormalMultilinearSeries 𝕜 E F)
    (N : ℕ) (z : E) :
    q.partialSum N (∑ i ∈ Finset.Ico 1 N, p i fun _j => z) =
      ∑ i ∈ compPartialSumTarget 0 N N, q.compAlongComposition p i.2 fun _j => z
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem coe_snd : ⇑(snd : P1 × P2 →ᵃ[k] P2) = Prod.snd
-- Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean
/-- If `C` has all colimits of diagrams `parallelPair f g`, then it has all coequalizers -/
theorem hasCoequalizers_of_hasColimit_parallelPair
    [∀ {X Y : C} {f g : X ⟶ Y}, HasColimit (parallelPair f g)] : HasCoequalizers C
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_sub {f g : α → ℝ≥0∞} (hg : Measurable g) (hg_fin : ∫⁻ a, g a ∂μ ≠ ∞)
    (h_le : g ≤ᵐ[μ] f) : ∫⁻ a, f a - g a ∂μ = ∫⁻ a, f a ∂μ - ∫⁻ a, g a ∂μ
-- Mathlib/Data/Int/Order/Units.lean
theorem neg_one_pow_ne_zero {n : ℕ} : (-1 : ℤ) ^ n ≠ 0
-- Mathlib/Data/List/Basic.lean
@[simp 1100, nolint simpNF]
theorem mem_map_of_injective {f : α → β} (H : Injective f) {a : α} {l : List α} :
    f a ∈ map f l ↔ a ∈ l
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem mfderiv_comp (hg : MDifferentiableAt I' I'' g (f x)) (hf : MDifferentiableAt I I' f x) :
    mfderiv I I'' (g ∘ f) x = (mfderiv I' I'' g (f x)).comp (mfderiv I I' f x)
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma exact_iff_isZero_leftHomology [S.HasHomology] :
    S.Exact ↔ IsZero S.leftHomology
-- Mathlib/Data/Finset/Lattice.lean
/-- Induction principle for `Finset`s in a linearly ordered type: a predicate is true on all
`s : Finset α` provided that:

* it is true on the empty `Finset`,
* for every `s : Finset α` and an element `a` strictly less than all elements of `s`, `p s`
  implies `p (insert a s)`. -/
@[elab_as_elim]
theorem induction_on_min [DecidableEq α] {p : Finset α → Prop} (s : Finset α) (h0 : p ∅)
    (step : ∀ a s, (∀ x ∈ s, a < x) → p s → p (insert a s)) : p s
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem mul_coeff_left' [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} {s : Set Γ}
    (hs : s.IsPWO) (hxs : x.support ⊆ s) :
    (x * y).coeff a =
      ∑ ij ∈ addAntidiagonal hs y.isPWO_support a, x.coeff ij.fst * y.coeff ij.snd
-- Mathlib/Topology/MetricSpace/Polish.lean
theorem _root_.IsOpen.isClopenable [TopologicalSpace α] [PolishSpace α] {s : Set α}
    (hs : IsOpen s) : IsClopenable s
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
@[simp]
theorem _root_.aemeasurable_sum_measure_iff [Countable ι] {μ : ι → Measure α} :
    AEMeasurable f (sum μ) ↔ ∀ i, AEMeasurable f (μ i)
-- Mathlib/NumberTheory/Padics/Hensel.lean
theorem limit_zero_of_norm_tendsto_zero : F.eval ncs.lim = 0
-- Mathlib/Algebra/Algebra/Quasispectrum.lean
@[simp]
lemma unitsFstOne_val_val_fst (x : (unitsFstOne R A)) : x.val.val.fst = 1
-- Mathlib/Analysis/Analytic/Within.lean
lemma AnalyticWithinOn.contDiffOn [CompleteSpace F] {f : E → F} {s : Set E}
    (h : AnalyticWithinOn 𝕜 f s) {n : ℕ∞} : ContDiffOn 𝕜 n f s
-- Mathlib/MeasureTheory/Integral/Periodic.lean
/-- If `g : ℝ → ℝ` is periodic with period `T > 0`, then for any `t : ℝ`, the function
`t ↦ ∫ x in 0..t, g x` is bounded above by `t ↦ X + ⌊t/T⌋ • Y` for appropriate constants `X` and
`Y`. -/
theorem integral_le_sSup_add_zsmul_of_pos (hT : 0 < T) (t : ℝ) :
    (∫ x in (0)..t, g x) ≤
      sSup ((fun t => ∫ x in (0)..t, g x) '' Icc 0 T) + ⌊t / T⌋ • ∫ x in (0)..T, g x
-- Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean
lemma quasiIso_of_comp_left (φ : S₁ ⟶ S₂) (φ' : S₂ ⟶ S₃)
    [hφ : QuasiIso φ] [hφφ' : QuasiIso (φ ≫ φ')] :
    QuasiIso φ'
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem PolyCnstr.denote_mul (ctx : Context) (k : Nat) (c : PolyCnstr) : (c.mul (k+1)).denote ctx = c.denote ctx
-- Mathlib/Order/Monotone/Monovary.lean
theorem MonovaryOn.comp_monotone_on_left (h : MonovaryOn f g s) (hf : Monotone f') :
    MonovaryOn (f' ∘ f) g s
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem smul_map_inv_div_map_inv_of_isMulTwoCocycle
    {f : G × G → M} (hf : IsMulTwoCocycle f) (g : G) :
    g • f (g⁻¹, g) / f (g, g⁻¹) = f (1, 1) / f (g, 1)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
@[simp]
lemma map_Δ : (W.map φ).Δ = φ W.Δ
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Kernels.lean
@[reassoc (attr := simp)]
lemma map_condition : G.map c.ι ≫ G.map f = 0
-- Mathlib/NumberTheory/Pell.lean
/-- The map sending an integer `n` to the `y`-coordinate of `a^n` for a fundamental
solution `a` is stritcly increasing. -/
theorem y_strictMono {a : Solution₁ d} (h : IsFundamental a) :
    StrictMono fun n : ℤ => (a ^ n).y
-- Mathlib/Analysis/Convex/Join.lean
theorem convexJoin_convexJoin_convexJoin_comm (s t u v : Set E) :
    convexJoin 𝕜 (convexJoin 𝕜 s t) (convexJoin 𝕜 u v) =
      convexJoin 𝕜 (convexJoin 𝕜 s u) (convexJoin 𝕜 t v)
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
theorem charpoly_monic (M : Matrix n n R) : M.charpoly.Monic
-- Mathlib/Algebra/Order/AbsoluteValue.lean
protected theorem map_one : abv 1 = 1
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- Relation `fun f g ↦ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α)` is symmetric. -/
theorem Filter.Tendsto.uniformity_symm {l : Filter β} {f : β → α × α} (h : Tendsto f l (𝓤 α)) :
    Tendsto (fun x => ((f x).2, (f x).1)) l (𝓤 α)
-- Mathlib/SetTheory/Game/PGame.lean
/-- The definition of `x ⧏ y` on pre-games, in terms of `⧏` two moves later. -/
theorem lf_def {x y : PGame} :
    x ⧏ y ↔
      (∃ i, (∀ i', x.moveLeft i' ⧏ y.moveLeft i) ∧ ∀ j, x ⧏ (y.moveLeft i).moveRight j) ∨
        ∃ j, (∀ i, (x.moveRight j).moveLeft i ⧏ y) ∧ ∀ j', x.moveRight j ⧏ y.moveRight j'
-- Mathlib/CategoryTheory/Subobject/MonoOver.lean
@[simp]
theorem mk'_arrow {X A : C} (f : A ⟶ X) [Mono f] : (mk' f).arrow = f
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma equivalenceRightFractionRel (X Y : C) [HasRightCalculusOfFractions W] :
    @_root_.Equivalence (W.RightFraction X Y) RightFractionRel
-- Mathlib/FieldTheory/Perfect.lean
lemma polynomial_expand_eq (f : R[X]) :
    expand R p f = (f.map (frobeniusEquiv R p).symm) ^ p
-- Mathlib/Order/Disjoint.lean
theorem Disjoint.inf_right (h : Disjoint a b) : Disjoint a (b ⊓ c)
-- Mathlib/CategoryTheory/Localization/HomEquiv.lean
lemma homEquiv_trans (f : L₁.obj X ⟶ L₁.obj Y) :
    homEquiv W L₂ L₃ (homEquiv W L₁ L₂ f) = homEquiv W L₁ L₃ f
-- Mathlib/Data/Fintype/Basic.lean
theorem compl_singleton (a : α) : ({a} : Finset α)ᶜ = univ.erase a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
protected theorem Adj.symm {G' : Subgraph G} {u v : V} (h : G'.Adj u v) : G'.Adj v u
-- Mathlib/ModelTheory/Complexity.lean
theorem IsAtomic.isPrenex {φ : L.BoundedFormula α n} (h : IsAtomic φ) : IsPrenex φ
-- Mathlib/Topology/NhdsSet.lean
/-- An open set belongs to its own set neighborhoods filter. -/
theorem IsOpen.mem_nhdsSet_self (ho : IsOpen s) : s ∈ 𝓝ˢ s
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[ext]
theorem ext {S T : NonUnitalStarSubalgebra R A} (h : ∀ x : A, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Topology/Algebra/Order/Field.lean
/-- The function `x ↦ x⁻¹` tends to `+∞` on the right of `0`. -/
theorem tendsto_inv_zero_atTop : Tendsto (fun x : 𝕜 => x⁻¹) (𝓝[>] (0 : 𝕜)) atTop
-- Mathlib/Analysis/Normed/Field/Basic.lean
theorem exists_lt_norm_lt {r₁ r₂ : ℝ} (h₀ : 0 ≤ r₁) (h : r₁ < r₂) : ∃ x : α, r₁ < ‖x‖ ∧ ‖x‖ < r₂
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- Any costructured arrow factors through a universal arrow. -/
@[reassoc (attr := simp)]
theorem fac (h : IsUniversal f) (g : CostructuredArrow S T) :
    S.map (h.lift g) ≫ f.hom = g.hom
-- Mathlib/MeasureTheory/Constructions/Cylinders.lean
theorem disjoint_cylinder_iff [Nonempty (∀ i, α i)] {s t : Finset ι} {S : Set (∀ i : s, α i)}
    {T : Set (∀ i : t, α i)} [DecidableEq ι] :
    Disjoint (cylinder s S) (cylinder t T) ↔
      Disjoint
        ((fun f : ∀ i : (s ∪ t : Finset ι), α i
          ↦ fun j : s ↦ f ⟨j, Finset.mem_union_left t j.prop⟩) ⁻¹' S)
        ((fun f ↦ fun j : t ↦ f ⟨j, Finset.mem_union_right s j.prop⟩) ⁻¹' T)
-- Mathlib/Data/DFinsupp/Basic.lean
theorem equivProdDFinsupp_smul [Monoid γ] [∀ i, AddMonoid (α i)] [∀ i, DistribMulAction γ (α i)]
    (r : γ) (f : Π₀ i, α i) : equivProdDFinsupp (r • f) = r • equivProdDFinsupp f
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem Iio_disjoint_Ici (h : a ≤ b) : Disjoint (Iio a) (Ici b)
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem gramSchmidtNormed_unit_length' {f : ι → E} {n : ι} (hn : gramSchmidtNormed 𝕜 f n ≠ 0) :
    ‖gramSchmidtNormed 𝕜 f n‖ = 1
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem mem_support_iff {p : MvPolynomial σ R} {m : σ →₀ ℕ} : m ∈ p.support ↔ p.coeff m ≠ 0
-- Mathlib/Data/Semiquot.lean
@[simp]
theorem mem_bind (q : Semiquot α) (f : α → Semiquot β) (b : β) :
    b ∈ bind q f ↔ ∃ a ∈ q, b ∈ f a
-- Mathlib/RingTheory/PowerBasis.lean
theorem finrank [StrongRankCondition R] (pb : PowerBasis R S) :
    FiniteDimensional.finrank R S = pb.dim
-- Mathlib/CategoryTheory/GradedObject/Monoidal.lean
@[reassoc]
lemma tensor_comp {X₁ X₂ X₃ Y₁ Y₂ Y₃ : GradedObject I C} (f₁ : X₁ ⟶ X₂) (f₂ : X₂ ⟶ X₃)
    (g₁ : Y₁ ⟶ Y₂) (g₂ : Y₂ ⟶ Y₃) [HasTensor X₁ Y₁] [HasTensor X₂ Y₂] [HasTensor X₃ Y₃] :
    tensorHom (f₁ ≫ f₂) (g₁ ≫ g₂) = tensorHom f₁ g₁ ≫ tensorHom f₂ g₂
-- Mathlib/ModelTheory/FinitelyGenerated.lean
theorem cg_iff_countable [Countable (Σl, L.Functions l)] : CG L M ↔ Countable M
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
/-- A measure `μ` has temperate growth if there is an `n : ℕ` such that `(1 + ‖x‖) ^ (- n)` is
`μ`-integrable. -/
class _root_.MeasureTheory.Measure.HasTemperateGrowth (μ : Measure D) : Prop :=
  exists_integrable : ∃ (n : ℕ), Integrable (fun x ↦ (1 + ‖x‖) ^ (- (n : ℝ))) μ
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
    ∃ l : List M, (∀ y ∈ l, y ∈ s) ∧ l.prod = x
-- Mathlib/LinearAlgebra/TensorProduct/Finiteness.lean
/-- For a finite subset `s` of `M ⊗[R] N`, there are finitely generated
submodules `M'` and `N'` of `M` and `N`, respectively, such that `s` is contained in the image
of `M' ⊗[R] N'` in `M ⊗[R] N`. -/
theorem exists_finite_submodule_of_finite (s : Set (M ⊗[R] N)) (hs : s.Finite) :
    ∃ (M' : Submodule R M) (N' : Submodule R N), Module.Finite R M' ∧ Module.Finite R N' ∧
      s ⊆ LinearMap.range (mapIncl M' N')
-- Mathlib/Algebra/Module/Submodule/Basic.lean
theorem vadd_def [VAdd M α] (g : p) (m : α) : g +ᵥ m = (g : M) +ᵥ m
-- Mathlib/Data/Finset/Lattice.lean
lemma nsmul_sup' {α'} [LinearOrderedAddCommMonoid β] {s : Finset α'}
    (hs : s.Nonempty) (f : α' → β) (n : ℕ) :
    s.sup' hs (fun a => n • f a) = n • s.sup' hs f
-- Mathlib/Analysis/Calculus/LocalExtr/LineDeriv.lean
theorem IsExtrOn.hasLineDerivWithinAt_eq_zero (h : IsExtrOn f s a)
    (hd : HasLineDerivWithinAt ℝ f f' s a b) (h' : ∀ᶠ t : ℝ in 𝓝 0, a + t • b ∈ s) : f' = 0
-- Mathlib/Dynamics/PeriodicPts.lean
theorem minimalPeriod_eq_one_iff_isFixedPt : minimalPeriod f x = 1 ↔ IsFixedPt f x
-- Mathlib/Dynamics/PeriodicPts.lean
theorem periodicOrbit_eq_nil_of_not_periodic_pt (h : x ∉ periodicPts f) :
    periodicOrbit f x = Cycle.nil
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- The measure of a closed ball can be expressed in terms of the measure of the closed unit ball.
Use instead `addHaar_closedBall`, which uses the measure of the open unit ball as a standard
form. -/
theorem addHaar_closedBall' (x : E) {r : ℝ} (hr : 0 ≤ r) :
    μ (closedBall x r) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (closedBall 0 1)
-- Mathlib/SetTheory/Cardinal/ENat.lean
lemma ofENat_injective : Injective ofENat
-- Mathlib/Order/RelIso/Set.lean
@[simp]
theorem relEmbedding_apply (r : α → α → Prop) (p a) : Subrel.relEmbedding r p a = a.1
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
theorem comp_assoc (f₃₄ : P3 →ᵃ[k] P4) (f₂₃ : P2 →ᵃ[k] P3) (f₁₂ : P1 →ᵃ[k] P2) :
    (f₃₄.comp f₂₃).comp f₁₂ = f₃₄.comp (f₂₃.comp f₁₂)
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[norm_cast]
theorem zero_lt_coe [Zero α] [LT α] (a : α) : (0 : WithTop α) < a ↔ 0 < a
-- Mathlib/Algebra/Category/Grp/Colimits.lean
@[simp]
theorem quot_add (x y) :
    (by exact Quot.mk Setoid.r (add x y) : ColimitType.{w} F) =
      -- Porting note: force Lean to treat `ColimitType F` no as `Quot _`
      (by exact Quot.mk Setoid.r x) + (by exact Quot.mk Setoid.r y)
-- Mathlib/CategoryTheory/Limits/Preserves/Ulift.lean
lemma descSet_univ : descSet hc (@Set.univ lc.pt) = Set.univ
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem emod_add_cancel_right {m n k : Int} (i) : (m + i) % n = (k + i) % n ↔ m % n = k % n
-- Mathlib/Data/Finset/Lattice.lean
theorem coe_inf_of_nonempty {s : Finset β} (h : s.Nonempty) (f : β → α) :
    (↑(s.inf f) : WithTop α) = s.inf ((↑) ∘ f)
-- Mathlib/Algebra/Field/Subfield.lean
@[simp]
theorem mk_le_mk {S S' : Subring K} (h h') : (⟨S, h⟩ : Subfield K) ≤ (⟨S', h'⟩ : Subfield K) ↔
    S ≤ S'
-- Mathlib/Data/Nat/Log.lean
@[simp]
theorem clog_one_right (b : ℕ) : clog b 1 = 0
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma cyclesMap'_eq : cyclesMap' φ h₁ h₂ = γ.φK
-- Mathlib/Data/Real/ConjExponents.lean
theorem ne_zero : p ≠ 0
-- Mathlib/Analysis/Calculus/Deriv/Mul.lean
theorem HasDerivWithinAt.smul (hc : HasDerivWithinAt c c' s x) (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun y => c y • f y) (c x • f' + c' • f x) s x
-- Mathlib/Data/Set/Card.lean
@[simp] theorem ncard_empty (α : Type*) : (∅ : Set α).ncard = 0
-- Mathlib/Topology/Sets/Closeds.lean
/-- in a `T1Space`, atoms of `TopologicalSpace.Closeds α` are precisely the
`TopologicalSpace.Closeds.singleton`s. -/
theorem Closeds.isAtom_iff [T1Space α] {s : Closeds α} :
    IsAtom s ↔ ∃ x, s = Closeds.singleton x
-- Mathlib/Algebra/Category/BialgebraCat/Basic.lean
/-- Build an isomorphism in the category `BialgebraCat R` from a
`BialgEquiv`. -/
@[simps]
def toBialgebraCatIso (e : X ≃ₐc[R] Y) : BialgebraCat.of R X ≅ BialgebraCat.of R Y
-- Mathlib/Data/Nat/Factorization/Basic.lean
@[simp]
lemma factorizationLCMLeft_zero_left : factorizationLCMLeft 0 b = 1
-- Mathlib/Algebra/Field/IsField.lean
@[simp]
theorem not_isField_of_subsingleton (R : Type u) [Semiring R] [Subsingleton R] : ¬IsField R
-- Mathlib/Order/JordanHolder.lean
@[trans]
theorem trans {s₁ s₂ s₃ : CompositionSeries X} (h₁ : Equivalent s₁ s₂) (h₂ : Equivalent s₂ s₃) :
    Equivalent s₁ s₃
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem gcd_eq_zero (xs : IntList) : xs.gcd = 0 ↔ ∀ x, x ∈ xs → x = 0
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem ofList_append (l l' : List α) : ofList (l ++ l') = append (ofList l) (ofList l')
-- Mathlib/RingTheory/Norm/Basic.lean
theorem norm_eq_prod_automorphisms [FiniteDimensional K L] [IsGalois K L] (x : L) :
    algebraMap K L (norm K x) = ∏ σ : L ≃ₐ[K] L, σ x
-- Mathlib/Logic/Small/Defs.lean
/-- Constructor for `Small α` from an explicit witness type and equivalence.
-/
theorem Small.mk' {α : Type v} {S : Type w} (e : α ≃ S) : Small.{w} α
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean
@[simp]
theorem deriv_arcsin : deriv arcsin = fun x => 1 / √(1 - x ^ 2)
-- Mathlib/Dynamics/BirkhoffSum/NormedSpace.lean
theorem dist_birkhoffAverage_apply_birkhoffAverage (f : α → α) (g : α → E) (n : ℕ) (x : α) :
    dist (birkhoffAverage 𝕜 f g n (f x)) (birkhoffAverage 𝕜 f g n x) =
      dist (g (f^[n] x)) (g x) / n
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoUniformlyOn.congr_right {g : α → β} (hf : TendstoUniformlyOn F f p s)
    (hfg : EqOn f g s) : TendstoUniformlyOn F g p s
-- Mathlib/Topology/Connected/TotallyDisconnected.lean
/-- The image of a connected component in a totally disconnected space is a singleton. -/
@[simp]
theorem Continuous.image_connectedComponent_eq_singleton {β : Type*} [TopologicalSpace β]
    [TotallyDisconnectedSpace β] {f : α → β} (h : Continuous f) (a : α) :
    f '' connectedComponent a = {f a}
-- Mathlib/Algebra/Module/Torsion.lean
theorem torsionBy_eq_span_singleton {R : Type w} [CommRing R] (a b : R) (ha : a ∈ R⁰) :
    torsionBy R (R ⧸ R ∙ a * b) a = R ∙ mk (R ∙ a * b) b
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_union' (h : Disjoint s t) (hs : MeasurableSet s) :
    μ.restrict (s ∪ t) = μ.restrict s + μ.restrict t
-- Mathlib/Data/Finset/Lattice.lean
/-- Intersection of an indexed family of sets `s : ι → Set α` is equal to the intersection of the
intersections of finite subfamilies. This version works for `ι : Sort*`. See also
`iInter_eq_iInter_finset` for a version that assumes `ι : Type*` but avoids `PLift`s in the right
hand side. -/
theorem iInter_eq_iInter_finset' (s : ι' → Set α) :
    ⋂ i, s i = ⋂ t : Finset (PLift ι'), ⋂ i ∈ t, s (PLift.down i)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem volume_image_subtype_coe {s : Set α} (hs : MeasurableSet s) (t : Set s) :
    volume ((↑) '' t : Set α) = volume t
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem prod_map_snd : (prod p q).map (snd R M M₂) = q
-- Mathlib/GroupTheory/PushoutI.lean
theorem prod_injective : Function.Injective (prod : NormalWord d → PushoutI φ)
-- Mathlib/LinearAlgebra/Eigenspace/Zero.lean
lemma IsNilpotent.charpoly_eq_X_pow_finrank (φ : Module.End R M) (h : IsNilpotent φ) :
    φ.charpoly = X ^ finrank R M
-- Mathlib/Init/Logic.lean
theorem eq_rec_compose {α β φ : Sort u} :
    ∀ (p₁ : β = φ) (p₂ : α = β) (a : α),
      (Eq.recOn p₁ (Eq.recOn p₂ a : β) : φ) = Eq.recOn (Eq.trans p₂ p₁) a
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
@[simp]
theorem abs_cpow_real (x : ℂ) (y : ℝ) : abs (x ^ (y : ℂ)) = Complex.abs x ^ y
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem mem_coe {x : L} : x ∈ (L' : Set L) ↔ x ∈ L'
-- Mathlib/Data/Set/Lattice.lean
theorem Ici_sSup (s : Set α) : Ici (sSup s) = ⋂ a ∈ s, Ici a
-- Mathlib/Analysis/Convex/Function.lean
theorem StrictConvexOn.comp_strictConcaveOn (hg : StrictConvexOn 𝕜 (f '' s) g)
    (hf : StrictConcaveOn 𝕜 s f) (hg' : StrictAntiOn g (f '' s)) (hf' : s.InjOn f) :
    StrictConvexOn 𝕜 s (g ∘ f)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem supp_inj {C D : G.ConnectedComponent} : C.supp = D.supp ↔ C = D
-- Mathlib/Order/Filter/Basic.lean
theorem frequently_imp_distrib_right {f : Filter α} [NeBot f] {p : α → Prop} {q : Prop} :
    (∃ᶠ x in f, p x → q) ↔ (∀ᶠ x in f, p x) → q
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem coeff_update_ne (p : R[X]) {n : ℕ} (a : R) {i : ℕ} (h : i ≠ n) :
    (p.update n a).coeff i = p.coeff i
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
/-- A typeclass mixin saying that scalar multiplication and Lie bracket are left commutative. -/
class SMulBracketCommClass (S L α : Type*) [SMul S α] [LieRing L] [AddCommGroup α]
    [LieRingModule L α] : Prop where
  /-- `•` and `⁅⬝, ⬝⁆`  are left commutative -/
  smul_bracket_comm : ∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆
-- Mathlib/Combinatorics/SetFamily/Shatter.lean
lemma Shatters.mono_right (h : t ⊆ s) (hs : 𝒜.Shatters s) : 𝒜.Shatters t
-- Mathlib/Order/Filter/CountableInter.lean
theorem eventually_countable_ball {ι : Type*} {S : Set ι} (hS : S.Countable)
    {p : α → ∀ i ∈ S, Prop} :
    (∀ᶠ x in l, ∀ i hi, p x i hi) ↔ ∀ i hi, ∀ᶠ x in l, p x i hi
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
theorem eLpNorm'_smul_le_mul_eLpNorm' {p q r : ℝ} {f : α → E} (hf : AEStronglyMeasurable f μ)
    {φ : α → 𝕜} (hφ : AEStronglyMeasurable φ μ) (hp0_lt : 0 < p) (hpq : p < q)
    (hpqr : 1 / p = 1 / q + 1 / r) : eLpNorm' (φ • f) p μ ≤ eLpNorm' φ q μ * eLpNorm' f r μ
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem DifferentiableWithinAt.sinh (hf : DifferentiableWithinAt ℝ f s x) :
    DifferentiableWithinAt ℝ (fun x => Real.sinh (f x)) s x
-- Mathlib/Data/Set/Card.lean
theorem ncard_diff_singleton_le (s : Set α) (a : α) : (s \ {a}).ncard ≤ s.ncard
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem partialHomeomorphSubtypeCoe_target : (s.partialHomeomorphSubtypeCoe hs).target = s
-- Mathlib/NumberTheory/ModularForms/EisensteinSeries/UniformConvergence.lean
/-- For `c, d ∈ ℝ` with `1 ≤ d ^ 2`, we have `r1 z ≤ |c * z + d| ^ 2`.  -/
lemma r1_aux_bound (c : ℝ) {d : ℝ} (hd : 1 ≤ d ^ 2) :
    r1 z ≤ (c * z.re + d) ^ 2 + (c * z.im) ^ 2
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- **Fundamental theorem of calculus-2**, on semi-infinite intervals `(-∞, a)`.
When a function has a limit `m` at `-∞`, and its derivative is integrable, then the
integral of the derivative on `(-∞, a)` is `f a - m`. Version assuming differentiability
on `(-∞, a)` and continuity at `a⁻`.

Note that such a function always has a limit at minus infinity,
see `tendsto_limUnder_of_hasDerivAt_of_integrableOn_Iic`. -/
theorem integral_Iic_of_hasDerivAt_of_tendsto (hcont : ContinuousWithinAt f (Iic a) a)
    (hderiv : ∀ x ∈ Iio a, HasDerivAt f (f' x) x) (f'int : IntegrableOn f' (Iic a))
    (hf : Tendsto f atBot (𝓝 m)) : ∫ x in Iic a, f' x = f a - m
-- Mathlib/Topology/FiberBundle/Basic.lean
@[simp, mfld_simps]
theorem localTrivAsPartialEquiv_symm :
    (Z.localTrivAsPartialEquiv i).symm = (Z.localTriv i).toPartialEquiv.symm
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Basic.lean
@[simp]
theorem charmatrix_apply_eq : charmatrix M i i = (X : R[X]) - C (M i i)
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma countablePartitionSet_mem (n : ℕ) (a : α) :
    countablePartitionSet n a ∈ countablePartition α n
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
lemma affineSpan_subset_span {s : Set V} :
    (affineSpan k s : Set V) ⊆  Submodule.span k s
-- Mathlib/CategoryTheory/Monoidal/Mon_.lean
@[simp]
theorem tensorUnit_X : (𝟙_ (Mon_ C)).X = 𝟙_ C
-- Mathlib/Algebra/Module/Submodule/LinearMap.lean
@[simp, norm_cast]
theorem coeFn_sum {ι : Type*} (t : Finset ι) (f : ι → M →ₛₗ[σ₁₂] M₂) :
    ⇑(∑ i ∈ t, f i) = ∑ i ∈ t, (f i : M → M₂)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem eq_zero_of_add_eq_zero_left (h : n + m = 0) : m = 0
-- Mathlib/Topology/Support.lean
theorem HasCompactSupport.smul_left (hf : HasCompactSupport f') : HasCompactSupport (f • f')
-- Mathlib/Algebra/Star/StarRingHom.lean
@[simp]
theorem mk_coe (f : A →⋆ₙ+* B) (h₁ h₂ h₃ h₄) :
    (⟨⟨⟨f, h₁⟩, h₂, h₃⟩, h₄⟩ : A →⋆ₙ+* B) = f