ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Polynomial/Roots.lean
@[simp]
theorem roots_C (x : R) : (C x).roots = 0
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
@[simp, reassoc]
theorem pullbackP1Iso_hom_snd (i : 𝒰.J) :
    (pullbackP1Iso 𝒰 f g i).hom ≫ pullback.snd _ _ = pullback.fst _ _ ≫ p2 𝒰 f g
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem ofFinsupp_pow (a) (n : ℕ) : (⟨a ^ n⟩ : R[X]) = ⟨a⟩ ^ n
-- Mathlib/SetTheory/Cardinal/Finite.lean
@[simp] lemma card_pos [Nonempty α] [Finite α] : 0 < Nat.card α
-- Mathlib/Analysis/Complex/UnitDisc/Basic.lean
theorem coe_injective : Injective ((↑) : 𝔻 → ℂ)
-- Mathlib/Tactic/NormNum/LegendreSymbol.lean
theorem jacobiSymNat.even_odd₅ (a b c : ℕ) (r : ℤ) (ha : a % 2 = 0) (hb : b % 8 = 5)
    (hc : a / 2 = c) (hr : jacobiSymNat c b = r) : jacobiSymNat a b = -r
-- Mathlib/Data/Rat/Defs.lean
lemma neg_def (q : ℚ) : -q = -q.num /. q.den
-- Mathlib/Logic/Small/Defs.lean
theorem not_small_type : ¬Small.{u} (Type max u v)
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem inl_natCast [AddMonoidWithOne R] [AddMonoid M] (n : ℕ) : (inl n : tsze R M) = n
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasDerivAtFilter.scomp_of_eq (hg : HasDerivAtFilter g₁ g₁' y L')
    (hh : HasDerivAtFilter h h' x L) (hy : y = h x) (hL : Tendsto h L L') :
    HasDerivAtFilter (g₁ ∘ h) (h' • g₁') x L
-- Mathlib/Analysis/Complex/AbsMax.lean
/-- **Maximum modulus principle**: if `f : E → F` is complex differentiable in a neighborhood of `c`
and the norm `‖f z‖` has a local maximum at `c`, then `‖f z‖` is locally constant in a neighborhood
of `c`. -/
theorem norm_eventually_eq_of_isLocalMax {f : E → F} {c : E}
    (hd : ∀ᶠ z in 𝓝 c, DifferentiableAt ℂ f z) (hc : IsLocalMax (norm ∘ f) c) :
    ∀ᶠ y in 𝓝 c, ‖f y‖ = ‖f c‖
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem ae_lt_of_lt_essInf (hx : x < essInf f μ)
    (hf : IsBoundedUnder (· ≥ ·) (ae μ) f := by isBoundedDefault) :
    ∀ᵐ y ∂μ, x < f y
-- Mathlib/Analysis/Convex/EGauge.lean
lemma egauge_ball_one_le_of_one_lt_norm (hc : 1 < ‖c‖) (x : E) :
    egauge 𝕜 (ball 0 1) x ≤ ‖c‖₊ * ‖x‖₊
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
lemma Exact.op (h : S.Exact) : S.op.Exact
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
@[simp]
theorem valuation_p_pow_mul (n : ℕ) (c : ℤ_[p]) (hc : c ≠ 0) :
    ((p : ℤ_[p]) ^ n * c).valuation = n + c.valuation
-- Mathlib/Data/Nat/Factorial/Basic.lean
lemma two_pow_mul_factorial_le_factorial_two_mul (n : ℕ) : 2 ^ n * n ! ≤ (2 * n) !
-- Mathlib/MeasureTheory/Measure/Restrict.lean
/-- If `s` is a measurable set, then the outer measure of `t` with respect to the restriction of
the measure to `s` equals the outer measure of `t ∩ s`. This is an alternate version of
`Measure.restrict_apply`, requiring that `s` is measurable instead of `t`. -/
@[simp]
theorem restrict_apply' (hs : MeasurableSet s) : μ.restrict s t = μ (t ∩ s)
-- Mathlib/Data/Nat/Pairing.lean
theorem left_le_pair (a b : ℕ) : a ≤ pair a b
-- Mathlib/Data/Set/NAry.lean
/-- image2 is monotone with respect to `⊆`. -/
theorem image2_subset (hs : s ⊆ s') (ht : t ⊆ t') : image2 f s t ⊆ image2 f s' t'
-- Mathlib/Algebra/Lie/SkewAdjoint.lean
theorem mem_skewAdjointMatricesLieSubalgebra_unit_smul (u : Rˣ) (J A : Matrix n n R) :
    A ∈ skewAdjointMatricesLieSubalgebra (u • J) ↔ A ∈ skewAdjointMatricesLieSubalgebra J
-- Mathlib/Data/ENNReal/Inv.lean
theorem exists_nat_mul_gt (ha : a ≠ 0) (hb : b ≠ ∞) : ∃ n : ℕ, b < n * a
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
protected theorem NeBot.le_one_iff (h : f.NeBot) : f ≤ 1 ↔ f = 1
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem toSubalgebra_subtype : S.toSubalgebra.val = S.subtype.toAlgHom
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
theorem Memℒp.integral_indicator_norm_ge_nonneg_le (hf : Memℒp f 1 μ) {ε : ℝ} (hε : 0 < ε) :
    ∃ M : ℝ, 0 ≤ M ∧ (∫⁻ x, ‖{ x | M ≤ ‖f x‖₊ }.indicator f x‖₊ ∂μ) ≤ ENNReal.ofReal ε
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem mem_trivialization_at_source (b : B) (x : E b) :
    ⟨b, x⟩ ∈ (a.pretrivializationAt b).source
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem toSet_sInter {x : ZFSet.{u}} (h : x.Nonempty) : (⋂₀ x).toSet = ⋂₀ (toSet '' x.toSet)
-- Mathlib/RingTheory/PolynomialAlgebra.lean
@[simp] theorem matPolyEquiv_symm_X :
    matPolyEquiv.symm X = diagonal fun _ : n => (X : R[X])
-- Mathlib/Topology/Sets/Closeds.lean
@[simp, norm_cast]
theorem coe_eq_univ {s : Closeds α} : (s : Set α) = univ ↔ s = ⊤
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma disjoint_weightSpaceOf [NoZeroSMulDivisors R M] {x : L} {φ₁ φ₂ : R} (h : φ₁ ≠ φ₂) :
    Disjoint (weightSpaceOf M φ₁ x) (weightSpaceOf M φ₂ x)
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem mk_coe' (e : R ≃+* S) (f h₁ h₂ h₃ h₄) :
    (⟨⟨f, ⇑e, h₁, h₂⟩, h₃, h₄⟩ : S ≃+* R) = e.symm
-- Mathlib/Topology/Semicontinuous.lean
theorem upperSemicontinuous_iff_IsClosed_hypograph {f : α → γ} :
    UpperSemicontinuous f ↔ IsClosed {p : α × γ | p.2 ≤ f p.1}
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive (attr := simp)]
lemma Submonoid.ofUnits_units_le (S : Submonoid M) : S.units.ofUnits ≤ S
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Log2.lean
theorem log2_le_self (n : Nat) : Nat.log2 n ≤ n
-- Mathlib/Order/Atoms.lean
theorem isCoatom_iff' [OrderTop α] [OrderTop β] [IsCoatomic β] {l : α → β} {u : β → α}
    (gi : GaloisCoinsertion l u) (htop : l ⊤ = ⊤) (h_coatom : ∀ b, IsCoatom b → l (u b) = b)
    (a : α) : IsCoatom (l a) ↔ IsCoatom a
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem norm_int_le_pow_iff_dvd {k : ℤ} {n : ℕ} :
    ‖(k : ℤ_[p])‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ (p ^ n : ℤ) ∣ k
-- Mathlib/Data/Nat/Choose/Central.lean
/-- The central binomial coefficient is the largest binomial coefficient.
-/
theorem choose_le_centralBinom (r n : ℕ) : choose (2 * n) r ≤ centralBinom n
-- Mathlib/RingTheory/Kaehler/Basic.lean
theorem KaehlerDifferential.map_compDer :
    (KaehlerDifferential.map R S A B).compDer (KaehlerDifferential.D R A) =
      ((KaehlerDifferential.D S B).restrictScalars R).compAlgebraMap A
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem xor_self : ∀ (x : Bool), xor x x = false
-- Mathlib/Algebra/Star/Order.lean
theorem conjugate_le_conjugate' {a b : R} (hab : a ≤ b) (c : R) :
    c * a * star c ≤ c * b * star c
-- Mathlib/Data/Multiset/Range.lean
@[simp]
theorem range_zero : range 0 = 0
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[mono]
protected lemma Preconnected.mono  {G G' : SimpleGraph V} (h : G ≤ G') (hG : G.Preconnected) :
    G'.Preconnected
-- Mathlib/Algebra/Homology/TotalComplex.lean
@[reassoc]
lemma D₁_D₂ (i₁₂ i₁₂' i₁₂'' : I₁₂) :
    K.D₁ c₁₂ i₁₂ i₁₂' ≫ K.D₂ c₁₂ i₁₂' i₁₂'' = - K.D₂ c₁₂ i₁₂ i₁₂' ≫ K.D₁ c₁₂ i₁₂' i₁₂''
-- Mathlib/Algebra/Order/AddTorsor.lean
@[to_additive]
theorem Monotone.smul {γ : Type*} [Preorder G] [Preorder P] [Preorder γ] [SMul G P]
    [IsOrderedSMul G P] {f : γ → G} {g : γ → P} (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x • g x
-- Mathlib/ModelTheory/Satisfiability.lean
@[trans]
theorem SemanticallyEquivalent.trans {φ ψ θ : L.BoundedFormula α n}
    (h1 : T.SemanticallyEquivalent φ ψ) (h2 : T.SemanticallyEquivalent ψ θ) :
    T.SemanticallyEquivalent φ θ
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[to_additive]
theorem eq_mk'_iff_mul_eq {x} {y : S} {z} : z = f.mk' x y ↔ z * f.toMap y = f.toMap x
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_star : cfcₙ (fun x ↦ star (f x)) a = star (cfcₙ f a)
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem preimage_Icc {a b : α} (hb : 0 ≤ b) :
    (Nat.cast : ℕ → α) ⁻¹' Set.Icc a b = Set.Icc ⌈a⌉₊ ⌊b⌋₊
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- Updating an element and taking the beginning commute. -/
@[simp]
theorem init_update_castSucc : init (update q (castSucc i) y) = update (init q) i y
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem isCoprime_one_right : IsCoprime x 1
-- Mathlib/Data/NNRat/Defs.lean
@[simp] lemma num_ofNat (n : ℕ) [n.AtLeastTwo] : num (no_index (OfNat.ofNat n)) = OfNat.ofNat n
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
theorem isKernelCompMono_lift {c : KernelFork f} (i : IsLimit c) {Z} (g : Y ⟶ Z) [hg : Mono g]
    {h : X ⟶ Z} (hh : h = f ≫ g) (s : KernelFork h) :
    (isKernelCompMono i g hh).lift s = i.lift (Fork.ofι s.ι (by
      rw [← cancel_mono g, Category.assoc, ← hh]
      simp))
-- Mathlib/Topology/Inseparable.lean
theorem Specializes.antisymm (h₁ : x ⤳ y) (h₂ : y ⤳ x) : x ~ᵢ y
-- Mathlib/Topology/Instances/NNReal.lean
theorem nhds_zero_basis : (𝓝 (0 : ℝ≥0)).HasBasis (fun a : ℝ≥0 => 0 < a) fun a => Iio a
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp] lemma δ_neg (z : Cochain F G n) : δ n m (-z) = - δ n m z
-- .lake/packages/batteries/Batteries/Data/List/Perm.lean
theorem Perm.map (f : α → β) {l₁ l₂ : List α} (p : l₁ ~ l₂) : map f l₁ ~ map f l₂
-- Mathlib/Topology/Maps/Basic.lean
theorem basis_nhds {p : ι → Prop} {s : ι → Set Y} (hf : Inducing f) {x : X}
    (h_basis : (𝓝 (f x)).HasBasis p s) : (𝓝 x).HasBasis p (preimage f ∘ s)
-- Mathlib/Data/Real/Sqrt.lean
/-- The natural floor of the real square root is the same as the natural square root. -/
@[simp]
theorem nat_floor_real_sqrt_eq_nat_sqrt {a : ℕ} : ⌊√(a : ℝ)⌋₊ = Nat.sqrt a
-- Mathlib/Data/DList/Defs.lean
theorem toList_push (x : α) (l : DList α) : toList (push l x) = toList l ++ [x]
-- Mathlib/RingTheory/Algebraic.lean
/-- This is slightly more general than `IsAlgebraic.algebraMap` in that it
  allows noncommutative intermediate rings `A`. -/
protected theorem IsAlgebraic.algHom (f : A →ₐ[R] B) {a : A}
    (h : IsAlgebraic R a) : IsAlgebraic R (f a)
-- Mathlib/Order/Interval/Set/Image.lean
lemma directedOn_ge_Ico (a b : α) : DirectedOn (· ≥ ·) (Ico a b)
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_relabel {φ : L.Formula α} {g : α → β} {v : β → M} :
    (φ.relabel g).Realize v ↔ φ.Realize (v ∘ g)
-- Mathlib/Probability/Martingale/Convergence.lean
/-- If a stochastic process has bounded upcrossing from below `a` to above `b`,
then it does not frequently visit both below `a` and above `b`. -/
theorem not_frequently_of_upcrossings_lt_top (hab : a < b) (hω : upcrossings a b f ω ≠ ∞) :
    ¬((∃ᶠ n in atTop, f n ω < a) ∧ ∃ᶠ n in atTop, b < f n ω)
-- Mathlib/Data/Nat/Factorization/PrimePow.lean
theorem isPrimePow_pow_iff {n k : ℕ} (hk : k ≠ 0) : IsPrimePow (n ^ k) ↔ IsPrimePow n
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem univ_id : univ.{u, u + 1} = @type Ordinal (· < ·) _
-- Mathlib/Algebra/Lie/Weights/RootSystem.lean
lemma chainLength_nsmul {x} (hx : x ∈ rootSpace H (chainTop α β)) :
    chainLength α β • x = ⁅coroot α, x⁆
-- Mathlib/LinearAlgebra/Projectivization/Subspace.lean
/-- If a set of points in projective space is contained in a subspace, and that subspace is
contained in the span of the set of points, then the span of the set of points is equal to
the subspace. -/
theorem span_eq_of_le {S : Set (ℙ K V)} {W : Subspace K V} (hS : S ⊆ W) (hW : W ≤ span S) :
    span S = W
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
@[simp]
theorem mk_re (z : ℂ) (h : 0 < z.im) : (mk z h).re = z.re
-- Mathlib/Init/Data/Nat/Lemmas.lean
@[elab_as_elim]
protected theorem strong_induction_on {p : Nat → Prop} (n : Nat)
    (h : ∀ n, (∀ m, m < n → p m) → p n) : p n
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast] lemma ofReal_nnratCast (q : ℚ≥0) : ofReal' q = q
-- Mathlib/Analysis/Convex/Basic.lean
theorem MonotoneOn.convex_ge (hf : MonotoneOn f s) (hs : Convex 𝕜 s) (r : β) :
    Convex 𝕜 ({ x ∈ s | r ≤ f x })
-- Mathlib/Algebra/DualQuaternion.lean
@[simp]
theorem re_fst_dualNumberEquiv (q : Quaternion (DualNumber R)) :
    (dualNumberEquiv q).fst.re = q.re.fst
-- Mathlib/Order/RelIso/Basic.lean
/-- A relation homomorphism with respect to a given pair of relations `r` and `s`
is a function `f : α → β` such that `r a b → s (f a) (f b)`. -/
structure RelHom {α β : Type*} (r : α → α → Prop) (s : β → β → Prop) where
  /-- The underlying function of a `RelHom` -/
  toFun : α → β
  /-- A `RelHom` sends related elements to related elements -/
  map_rel' : ∀ {a b}, r a b → s (toFun a) (toFun b)
-- Mathlib/Topology/Algebra/InfiniteSum/Real.lean
theorem summable_sigma_of_nonneg {β : α → Type*} {f : (Σ x, β x) → ℝ} (hf : ∀ x, 0 ≤ f x) :
    Summable f ↔ (∀ x, Summable fun y => f ⟨x, y⟩) ∧ Summable fun x => ∑' y, f ⟨x, y⟩
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem sSup_continuous (s : Set <| α →o β) (hs : ∀ f ∈ s, Continuous f) : Continuous (sSup s)
-- Mathlib/Analysis/Complex/RealDeriv.lean
theorem ContDiffAt.real_of_complex {n : ℕ∞} (h : ContDiffAt ℂ n e z) :
    ContDiffAt ℝ n (fun x : ℝ => (e x).re) z
-- Mathlib/Order/OmegaCompletePartialOrder.lean
/-- A family of continuous functions yields a continuous family of functions. -/
@[simps]
def flip {α : Type*} (f : α → β →𝒄 γ) : β →𝒄 α → γ
-- Mathlib/Algebra/Group/Semiconj/Basic.lean
@[to_additive (attr := simp)] lemma inv_symm_left_iff : SemiconjBy a⁻¹ y x ↔ SemiconjBy a x y
-- Mathlib/Data/QPF/Univariate/Basic.lean
theorem supp_eq_of_isUniform (h : q.IsUniform) {α : Type u} (a : q.P.A) (f : q.P.B a → α) :
    supp (abs ⟨a, f⟩) = f '' univ
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma fromAffine_zero [Nontrivial R] : fromAffine 0 = (0 : W'.Point)
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiffOn_snd {s : Set (M × N)} : ContMDiffOn (I.prod J) J n Prod.snd s
-- Mathlib/FieldTheory/AbelRuffini.lean
theorem gal_X_pow_sub_C_isSolvable_aux (n : ℕ) (a : F)
    (h : (X ^ n - 1 : F[X]).Splits (RingHom.id F)) : IsSolvable (X ^ n - C a).Gal
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma leftHomologyMap'_eq : leftHomologyMap' φ h₁ h₂ = γ.φH
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
protected theorem eq (h : AEDisjoint μ s t) : μ (s ∩ t) = 0
-- Mathlib/Data/Matroid/Basic.lean
theorem basis'_iff_basis_inter_ground : M.Basis' I X ↔ M.Basis I (X ∩ M.E)
-- Mathlib/Data/List/Basic.lean
theorem getElem_pmap {p : α → Prop} (f : ∀ a, p a → β) {l : List α} (h : ∀ a ∈ l, p a) {n : ℕ}
    (hn : n < (pmap f l h).length) :
    (pmap f l h)[n] =
      f (l[n]'(@length_pmap _ _ p f l h ▸ hn))
        (h _ (getElem_mem l n (@length_pmap _ _ p f l h ▸ hn)))
-- Mathlib/CategoryTheory/Monad/Algebra.lean
/-- An Eilenberg-Moore algebra for a monad `T`.
    cf Definition 5.2.3 in [Riehl][riehl2017]. -/
structure Algebra (T : Monad C) : Type max u₁ v₁ where
  /-- The underlying object associated to an algebra. -/
  A : C
  /-- The structure morphism associated to an algebra. -/
  a : (T : C ⥤ C).obj A ⟶ A
  /-- The unit axiom associated to an algebra. -/
  unit : T.η.app A ≫ a = 𝟙 A := by aesop_cat
  /-- The associativity axiom associated to an algebra. -/
  assoc : T.μ.app A ≫ a = (T : C ⥤ C).map a ≫ a := by aesop_cat
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_comp_add_div (hc : c ≠ 0) (d) :
    (∫ x in a..b, f (d + x / c)) = c • ∫ x in d + a / c..d + b / c, f x
-- Mathlib/Topology/Algebra/InfiniteSum/Group.lean
@[to_additive]
theorem multipliable_iff_of_multipliable_div (hfg : Multipliable fun b ↦ f b / g b) :
    Multipliable f ↔ Multipliable g
-- Mathlib/Algebra/Star/SelfAdjoint.lean
theorem mem_iff {x : R} : x ∈ selfAdjoint R ↔ star x = x
-- Mathlib/Algebra/Group/Submonoid/MulOpposite.lean
@[to_additive]
theorem le_op_iff {S₁ : Submonoid Mᵐᵒᵖ} {S₂ : Submonoid M} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂
-- Mathlib/RingTheory/Noetherian.lean
theorem isNoetherian_of_ker_bot [IsNoetherian R P] (f : M →ₗ[R] P) (hf : LinearMap.ker f = ⊥) :
    IsNoetherian R M
-- Mathlib/Data/List/Forall2.lean
@[simp]
theorem forall₂_eq_eq_eq : Forall₂ ((· = ·) : α → α → Prop) = Eq
-- Mathlib/Tactic/CategoryTheory/MonoidalComp.lean
@[simps]
instance refl (X : C) : MonoidalCoherence X X
-- Mathlib/Algebra/Order/Hom/Ring.lean
theorem comp_assoc (f : γ →+*o δ) (g : β →+*o γ) (h : α →+*o β) :
    (f.comp g).comp h = f.comp (g.comp h)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem revPosOfAux_eq (s c) : revPosOfAux s c = revFindAux s (· == c)
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive (attr := simp)]
theorem subsingleton_iff : Subsingleton (Submonoid M) ↔ Subsingleton M
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem coe_eq_zero (l : List α) : (l : Multiset α) = 0 ↔ l = []
-- Mathlib/MeasureTheory/Integral/TorusIntegral.lean
/-- In dimension one, `torusIntegral` is the same as `circleIntegral`
(up to the natural equivalence between `ℂ` and `Fin 1 → ℂ`). -/
theorem torusIntegral_dim1 (f : ℂ¹ → E) (c : ℂ¹) (R : ℝ¹) :
    (∯ x in T(c, R), f x) = ∮ z in C(c 0, R 0), f fun _ => z
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma op_hom_leftUnitor (X : C) : (λ_ X).hom.op = (λ_ (op X)).inv
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem DifferentiableOn.diffContOnCl (h : DifferentiableOn 𝕜 f (closure s)) : DiffContOnCl 𝕜 f s
-- Mathlib/Combinatorics/Hall/Finite.lean
/-- Here we combine the two inductive steps into a full strong induction proof,
completing the proof the harder direction of **Hall's Marriage Theorem**.
-/
theorem hall_hard_inductive (ht : ∀ s : Finset ι, s.card ≤ (s.biUnion t).card) :
    ∃ f : ι → α, Function.Injective f ∧ ∀ x, f x ∈ t x
-- Mathlib/Topology/PartialHomeomorph.lean
theorem symm_map_nhds_eq {x} (hx : x ∈ e.source) : map e.symm (𝓝 (e x)) = 𝓝 x
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
@[simp]
theorem empty (v : VectorMeasure α M) : v ∅ = 0
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem byContradiction [dec : Decidable p] (h : ¬p → False) : p
-- Mathlib/Algebra/Polynomial/Laurent.lean
theorem T_add (m n : ℤ) : (T (m + n) : R[T;T⁻¹]) = T m * T n
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace.lean
lemma stalkMap_germ_apply (U : Opens Y) (x : (Opens.map f.val.base).obj U) (y) :
    f.stalkMap x.val (Y.presheaf.germ ⟨f.val.base x.val, x.property⟩ y) =
      X.presheaf.germ x (f.val.c.app (op U) y)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_sq_pi_over_two_pow (n : ℕ) :
    sin (π / 2 ^ (n + 1)) ^ 2 = 1 - (sqrtTwoAddSeries 0 n / 2) ^ 2
-- Mathlib/MeasureTheory/Integral/Bochner.lean
theorem setIntegral_dirac [MeasurableSpace α] [MeasurableSingletonClass α] (f : α → E) (a : α)
    (s : Set α) [Decidable (a ∈ s)] :
    ∫ x in s, f x ∂Measure.dirac a = if a ∈ s then f a else 0
-- .lake/packages/lean4/src/lean/Init/Ext.lean
@[ext] theorem Prod.ext : {x y : Prod α β} → x.fst = y.fst → x.snd = y.snd → x = y
-- Mathlib/RingTheory/AlgebraicIndependent.lean
@[simp]
theorem AlgebraicIndependent.mvPolynomialOptionEquivPolynomialAdjoin_apply
    (hx : AlgebraicIndependent R x) (y) :
    hx.mvPolynomialOptionEquivPolynomialAdjoin y =
      Polynomial.map (hx.aevalEquiv : MvPolynomial ι R →+* adjoin R (range x))
        (aeval (fun o : Option ι => o.elim Polynomial.X fun s : ι => Polynomial.C (X s)) y)
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean
lemma induce_connected_adj_union {v w : V} {s t : Set V}
    (sconn : (G.induce s).Connected) (tconn : (G.induce t).Connected)
    (hv : v ∈ s) (hw : w ∈ t) (ha : G.Adj v w) :
    (G.induce (s ∪ t)).Connected
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
lemma toComplex_injective : Function.Injective GaussianInt.toComplex
-- Mathlib/RingTheory/MvPolynomial/Basic.lean
theorem mem_restrictDegree (p : MvPolynomial σ R) (n : ℕ) :
    p ∈ restrictDegree σ R n ↔ ∀ s ∈ p.support, ∀ i, (s : σ →₀ ℕ) i ≤ n
-- Mathlib/Topology/Algebra/Module/StrongTopology.lean
theorem uniformSpace_mono [UniformSpace F] [UniformAddGroup F] (h : 𝔖₂ ⊆ 𝔖₁) :
    instUniformSpace σ F 𝔖₁ ≤ instUniformSpace σ F 𝔖₂
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem mem_annihilator {r} : r ∈ N.annihilator ↔ ∀ n ∈ N, r • n = (0 : M)
-- Mathlib/NumberTheory/Modular.lean
theorem coe_T_zpow_smul_eq {n : ℤ} : (↑(T ^ n • z) : ℂ) = z + n
-- Mathlib/Order/Filter/Lift.lean
theorem le_lift {f : Filter α} {g : Set α → Filter β} {h : Filter β} :
    h ≤ f.lift g ↔ ∀ s ∈ f, h ≤ g s
-- Mathlib/RingTheory/QuotientNilpotent.lean
theorem Ideal.isRadical_iff_quotient_reduced {R : Type*} [CommRing R] (I : Ideal R) :
    I.IsRadical ↔ IsReduced (R ⧸ I)
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_tsum [Countable β] {f : β → α → ℝ≥0∞} (hf : ∀ i, AEMeasurable (f i) μ) :
    ∫⁻ a, ∑' i, f i a ∂μ = ∑' i, ∫⁻ a, f i a ∂μ
-- Mathlib/Algebra/Order/Sub/Canonical.lean
@[simp]
theorem add_tsub_tsub_cancel (h : c ≤ a) : a + b - (a - c) = b + c
-- Mathlib/Geometry/Euclidean/Basic.lean
@[simp]
theorem orthogonalProjection_mem_subspace_eq_self {s : AffineSubspace ℝ P} [Nonempty s]
    [HasOrthogonalProjection s.direction] (p : s) : orthogonalProjection s p = p
-- Mathlib/Algebra/BigOperators/Pi.lean
@[to_additive]
theorem Fintype.prod_apply {α : Type*} {β : α → Type*} {γ : Type*} [Fintype γ]
    [∀ a, CommMonoid (β a)] (a : α) (g : γ → ∀ a, β a) : (∏ c, g c) a = ∏ c, g c a
-- Mathlib/CategoryTheory/Limits/Final.lean
theorem initial_iff_initial_comp [Initial F] : Initial G ↔ Initial (F ⋙ G)
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_mul_factorial_mul_factorial : ∀ {n k}, k ≤ n → choose n k * k ! * (n - k)! = n !
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem lift_monotone : Monotone lift
-- Mathlib/Data/List/Basic.lean
@[deprecated get?_eq_get (since := "2023-01-05")]
theorem nthLe_get? {l : List α} {n} (h) : get? l n = some (nthLe l n h)
-- Mathlib/Order/GaloisConnection.lean
theorem le_u {a : α} {b : β} : l a ≤ b → a ≤ u b
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
@[simp]
theorem measurableSet_preimage (e : α ≃ᵐ β) {s : Set β} :
    MeasurableSet (e ⁻¹' s) ↔ MeasurableSet s
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem mul_left_mono (I : FractionalIdeal S P) : Monotone (I * ·)
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- This lemma is superceded by `unifIntegrable_of` which do not require `C` to be positive. -/
theorem unifIntegrable_of' (hp : 1 ≤ p) (hp' : p ≠ ∞) {f : ι → α → β}
    (hf : ∀ i, StronglyMeasurable (f i))
    (h : ∀ ε : ℝ, 0 < ε → ∃ C : ℝ≥0, 0 < C ∧
      ∀ i, eLpNorm ({ x | C ≤ ‖f i x‖₊ }.indicator (f i)) p μ ≤ ENNReal.ofReal ε) :
    UnifIntegrable f p μ
-- Mathlib/GroupTheory/Archimedean.lean
/-- If a nontrivial additive subgroup of a linear ordered additive commutative group is disjoint
with the interval `Set.Ioo 0 a` for some positive `a`, then the set of positive elements of this
group admits the least element. -/
theorem AddSubgroup.exists_isLeast_pos {H : AddSubgroup G} (hbot : H ≠ ⊥) {a : G} (h₀ : 0 < a)
    (hd : Disjoint (H : Set G) (Ioo 0 a)) : ∃ b, IsLeast { g : G | g ∈ H ∧ 0 < g } b
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem fderiv_deriv : (fderiv 𝕜 f x : 𝕜 → F) 1 = deriv f x
-- Mathlib/Order/SuccPred/Basic.lean
theorem Ioo_succ_right_of_not_isMax (hb : ¬IsMax b) : Ioo a (succ b) = Ioc a b
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem imp_iff_right {a : Prop} (ha : a) : (a → b) ↔ b
-- Mathlib/Probability/Independence/Conditional.lean
@[symm]
theorem CondIndepSets.symm {s₁ s₂ : Set (Set Ω)}
    (h : CondIndepSets m' hm' s₁ s₂ μ) : CondIndepSets m' hm' s₂ s₁ μ
-- Mathlib/Algebra/Module/LinearMap/End.lean
/-- Each element of the monoid defines a linear map.

This is a stronger version of `DistribMulAction.toAddMonoidHom`. -/
@[simps]
def toLinearMap (s : S) : M →ₗ[R] M
-- Mathlib/NumberTheory/Padics/PadicIntegers.lean
theorem valuation_nonneg (x : ℤ_[p]) : 0 ≤ x.valuation
-- Mathlib/Algebra/Order/Hom/Basic.lean
/-- `MulLEAddHomClass F α β` states that `F` is a type of subadditive morphisms. -/
@[to_additive SubadditiveHomClass]
class MulLEAddHomClass (F α β : Type*) [Mul α] [Add β] [LE β] [FunLike F α β] : Prop where
  /-- the image of a product is less or equal than the sum of the images. -/
  map_mul_le_add (f : F) : ∀ a b, f (a * b) ≤ f a + f b
-- Mathlib/Algebra/Polynomial/RingDivision.lean
lemma aeval_ne_zero_of_isCoprime [CommSemiring R] [Nontrivial S] [Semiring S] [Algebra R S]
    {p q : R[X]} (h : IsCoprime p q) (s : S) : aeval s p ≠ 0 ∨ aeval s q ≠ 0
-- Mathlib/NumberTheory/Padics/PadicVal.lean
/-- A rewrite lemma for `padicValRat p (q⁻¹)` with condition `q ≠ 0`. -/
protected theorem inv (q : ℚ) : padicValRat p q⁻¹ = -padicValRat p q
-- Mathlib/Topology/FiberBundle/Basic.lean
theorem open_source' (i : ι) : IsOpen (Z.localTrivAsPartialEquiv i).source