ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.const_smul [AddMonoid α] [Neg β] [Group γ] [DistribMulAction γ α]
    (h : Antiperiodic f c) (a : γ) : Antiperiodic (fun x => f (a • x)) (a⁻¹ • c)
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- `liminf (c + xᵢ) = c + limsup xᵢ`. -/
lemma liminf_const_add (F : Filter ι) [NeBot F] [Add R] [ContinuousAdd R]
    [CovariantClass R R (fun x y ↦ x + y) fun x y ↦ x ≤ y]  (f : ι → R) (c : R)
    (cobdd : F.IsCoboundedUnder (· ≥ ·) f) (bdd_below : F.IsBoundedUnder (· ≥ ·) f) :
    Filter.liminf (fun i ↦ c + f i) F = c + Filter.liminf f F
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean
@[simp]
theorem PreservesPushout.iso_hom : (PreservesPushout.iso G f g).hom = pushoutComparison G f g
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem monic_toSubring : Monic (toSubring p T hp) ↔ Monic p
-- Mathlib/GroupTheory/GroupAction/Group.lean
protected theorem MulAction.injective₀ (ha : a ≠ 0) : Function.Injective (a • · : β → β)
-- Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
theorem mem_ball_self {x : E} {r : ℝ} (hr : 0 < r) : x ∈ ball x r
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_finset_biUnion_congr {s : Finset ι} {t : ι → Set α} :
    μ.restrict (⋃ i ∈ s, t i) = ν.restrict (⋃ i ∈ s, t i) ↔
      ∀ i ∈ s, μ.restrict (t i) = ν.restrict (t i)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
theorem HasStrictDerivAt.const_sub (c : F) (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => c - f x) (-f') x
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem zeroLocus_univ : zeroLocus 𝒜 (Set.univ : Set A) = ∅
-- Mathlib/NumberTheory/DirichletCharacter/Basic.lean
lemma conductor_mem_conductorSet : conductor χ ∈ conductorSet χ
-- Mathlib/Data/Set/Finite.lean
protected lemma Infinite.preimage (hs : s.Infinite) (hf : s ⊆ range f) : (f ⁻¹' s).Infinite
-- Mathlib/Data/Complex/Basic.lean
@[simp] lemma im_ofNat (n : ℕ) [n.AtLeastTwo] : (no_index (OfNat.ofNat n) : ℂ).im = 0
-- Mathlib/Analysis/RCLike/Basic.lean
theorem conj_eq_iff_real {z : K} : conj z = z ↔ ∃ r : ℝ, z = (r : K)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioc_def (a b : α) : { x | a < x ∧ x ≤ b } = Ioc a b
-- Mathlib/Algebra/Star/Order.lean
/-- To construct a `StarOrderedRing` instance it suffices to show that `x ≤ y` if and only if
`y = x + star s * s` for some `s : R`.

This is provided for convenience because it holds in some common scenarios (e.g.,`ℝ≥0`, `C(X, ℝ≥0)`)
and obviates the hassle of `AddSubmonoid.closure_induction` when creating those instances.

If you are working with a `NonUnitalRing` and not a `NonUnitalSemiring`, see
`StarOrderedRing.of_nonneg_iff` for a more convenient version.
 -/
lemma of_le_iff [NonUnitalSemiring R] [PartialOrder R] [StarRing R]
    (h_le_iff : ∀ x y : R, x ≤ y ↔ ∃ s, y = x + star s * s) : StarOrderedRing R
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem not_inr_lt_inl [LT α] [LT β] {a : α} {b : β} : ¬inr b < inl a
-- Mathlib/Algebra/Lie/Weights/Killing.lean
lemma restrict_killingForm (H : LieSubalgebra R L) :
    (killingForm R L).restrict H = LieModule.traceForm R H L
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
/-- `ζ - 1` is prime if `ζ` is a primitive `2 ^ (k + 1)`-th root of unity.
  See `zeta_sub_one_prime` for a general statement. -/
theorem zeta_sub_one_prime_of_two_pow [IsCyclotomicExtension {(2 : ℕ+) ^ (k + 1)} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑((2 : ℕ+) ^ (k + 1))) :
    Prime (hζ.toInteger - 1)
-- Mathlib/Data/ENNReal/Operations.lean
theorem le_sub_of_add_le_right (hb : b ≠ ∞) : a + b ≤ c → a ≤ c - b
-- Mathlib/Analysis/Normed/Group/Quotient.lean
theorem image_norm_nonempty {S : AddSubgroup M} (x : M ⧸ S) :
    (norm '' { m | mk' S m = x }).Nonempty
-- Mathlib/SetTheory/Ordinal/Topology.lean
theorem nhds_eq_pure : 𝓝 a = pure a ↔ ¬IsLimit a
-- Mathlib/Topology/Order.lean
lemma generateFrom_insert_of_generateOpen {α : Type*} {s : Set (Set α)} {t : Set α}
    (ht : GenerateOpen s t) : generateFrom (insert t s) = generateFrom s
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean
theorem set_walk_length_toFinset_eq (n : ℕ) (u v : V) :
    {p : G.Walk u v | p.length = n}.toFinset = G.finsetWalkLength n u v
-- Mathlib/Data/ENNReal/Basic.lean
theorem natCast_lt_coe {n : ℕ} : n < (r : ℝ≥0∞) ↔ n < r
-- Mathlib/Algebra/Quaternion.lean
/-- `QuaternionAlgebra.imI` as a `LinearMap`-/
@[simps]
def imIₗ : ℍ[R,c₁,c₂] →ₗ[R] R
-- Mathlib/FieldTheory/Adjoin.lean
/-- If `y : L` is a root of `minpoly K x`, then `minpoly K y = minpoly K x`. -/
theorem eq_of_root {x y : L} (hx : IsAlgebraic K x)
    (h_ev : (Polynomial.aeval y) (minpoly K x) = 0) : minpoly K y = minpoly K x
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem hasMFDerivWithinAt_const (c : M') (s : Set M) (x : M) :
    HasMFDerivWithinAt I I' (fun _ : M => c) s x (0 : TangentSpace I x →L[𝕜] TangentSpace I' c)
-- Mathlib/Logic/Equiv/List.lean
@[simp, nolint unusedHavesSuffices] -- Porting note: false positive
theorem list_ofNat_succ (v : ℕ) :
    ofNat (List α) (succ v) = ofNat α v.unpair.1 :: ofNat (List α) v.unpair.2
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem isCoprime_num_denom (x : RatFunc K) : IsCoprime x.num x.denom
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
nonrec theorem isThin_iff : S.IsThin ↔ ∀ c : S.objs, Subsingleton (S.arrows c c)
-- Mathlib/Data/Fintype/Basic.lean
theorem insert_inj_on' (s : Finset α) : Set.InjOn (fun a => insert a s) (sᶜ : Finset α)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem all_eq_not_any_not (p : α → Bool) (as : Array α) (start stop) :
    all as p start stop = !(any as (!p ·) start stop)
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
theorem dist_lineMap_right (p₁ p₂ : P) (c : 𝕜) :
    dist (lineMap p₁ p₂ c) p₂ = ‖1 - c‖ * dist p₁ p₂
-- Mathlib/Data/Set/Image.lean
theorem preimage_preimage {g : β → γ} {f : α → β} {s : Set γ} :
    f ⁻¹' (g ⁻¹' s) = (fun x => g (f x)) ⁻¹' s
-- Mathlib/Data/String/Basic.lean
theorem asString_toList (s : String) : s.toList.asString = s
-- Mathlib/GroupTheory/SpecificGroups/Cyclic.lean
/-- A group is called *cyclic* if it is generated by a single element. -/
class IsAddCyclic (α : Type u) [AddGroup α] : Prop where
  exists_generator : ∃ g : α, ∀ x, x ∈ AddSubgroup.zmultiples g
-- .lake/packages/lean4/src/lean/Init/Core.lean
private theorem rel.refl {s : Setoid α} (q : Quotient s) : rel q q
-- Mathlib/NumberTheory/PellMatiyasevic.lean
@[simp]
theorem d_pos : 0 < d a1
-- Mathlib/RingTheory/OreLocalization/Ring.lean
protected theorem inv_zero : (0 : R[R⁰⁻¹])⁻¹ = 0
-- Mathlib/Data/Finset/Lattice.lean
theorem max_eq_bot {s : Finset α} : s.max = ⊥ ↔ s = ∅
-- Mathlib/Data/Set/Card.lean
theorem Finite.eq_insert_of_subset_of_encard_eq_succ (hs : s.Finite) (h : s ⊆ t)
    (hst : t.encard = s.encard + 1) : ∃ a, t = insert a s
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem gcd_add_mul_left_left (m n k : ℕ) : gcd (m + n * k) n = gcd m n
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- Given a pullback square assembled from a commuting square on the top and
a pullback square on the bottom, the top square is a pullback square.

The objects in the statement fit into the following diagram:
```
X₁₁ - h₁₁ -> X₁₂
|            |
v₁₁          v₁₂
↓            ↓
X₂₁ - h₂₁ -> X₂₂
|            |
v₂₁          v₂₂
↓            ↓
X₃₁ - h₃₁ -> X₃₂
```
-/
theorem of_bot {X₁₁ X₁₂ X₂₁ X₂₂ X₃₁ X₃₂ : C} {h₁₁ : X₁₁ ⟶ X₁₂} {h₂₁ : X₂₁ ⟶ X₂₂} {h₃₁ : X₃₁ ⟶ X₃₂}
    {v₁₁ : X₁₁ ⟶ X₂₁} {v₁₂ : X₁₂ ⟶ X₂₂} {v₂₁ : X₂₁ ⟶ X₃₁} {v₂₂ : X₂₂ ⟶ X₃₂}
    (s : IsPullback h₁₁ (v₁₁ ≫ v₂₁) (v₁₂ ≫ v₂₂) h₃₁) (p : h₁₁ ≫ v₁₂ = v₁₁ ≫ h₂₁)
    (t : IsPullback h₂₁ v₂₁ v₂₂ h₃₁) : IsPullback h₁₁ v₁₁ v₁₂ h₂₁
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem le_ceil_map_map_zero : ⌈f 0⌉ + ⌊g 0⌋ ≤ ⌈(f * g) 0⌉
-- Mathlib/Data/Set/Subsingleton.lean
lemma eq_singleton_or_nontrivial (ha : a ∈ s) : s = {a} ∨ s.Nontrivial
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
lemma _root_.Real.spectralRadius_mem_spectrum {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] {a : A} (ha : (spectrum ℝ a).Nonempty)
    (ha' : SpectrumRestricts a ContinuousMap.realToNNReal) :
    (spectralRadius ℝ a).toReal ∈ spectrum ℝ a
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
/-- Composition on the left by a (continuous) homomorphism of topological semirings, as a
`RingHom`.  Similar to `RingHom.compLeft`. -/
@[simps!]
protected def _root_.RingHom.compLeftContinuous (α : Type*) {β : Type*} {γ : Type*}
    [TopologicalSpace α]
    [TopologicalSpace β] [Semiring β] [TopologicalSemiring β] [TopologicalSpace γ] [Semiring γ]
    [TopologicalSemiring γ] (g : β →+* γ) (hg : Continuous g) : C(α, β) →+* C(α, γ)
-- Mathlib/NumberTheory/SumPrimeReciprocals.lean
/-- The sum over the reciprocals of the primes diverges. -/
theorem not_summable_one_div_on_primes :
    ¬ Summable (indicator {p | p.Prime} (fun n : ℕ ↦ (1 : ℝ) / n))
-- Mathlib/Topology/Sheaves/Stalks.lean
lemma Γgerm_res_apply (F : X.Presheaf C) {U : Opens X} {i : U ⟶ ⊤} (x : U) [ConcreteCategory C]
    (s) : germ F x (F.map i.op s) = Γgerm F x.val s
-- Mathlib/Analysis/Normed/MulAction.lean
theorem nnnorm_smul_le (r : α) (x : β) : ‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
/-- The simple (aka pure) elements span the tensor product. -/
theorem span_tmul_eq_top : Submodule.span R { t : M ⊗[R] N | ∃ m n, m ⊗ₜ n = t } = ⊤
-- Mathlib/Topology/Order/LeftRight.lean
theorem nhdsWithin_Ici_neBot {a b : α} (H₂ : a ≤ b) : NeBot (𝓝[Ici a] b)
-- Mathlib/Data/Nat/Prime/Defs.lean
theorem dvd_prime_two_le {p m : ℕ} (pp : Prime p) (H : 2 ≤ m) : m ∣ p ↔ m = p
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
/-- The **Akra-Bazzi theorem**: `T ∈ O(n^p (1 + ∑_u^n g(u) / u^{p+1}))` -/
theorem isBigO_asympBound : T =O[atTop] asympBound g a b
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem DifferentiableWithinAt.ccosh (hf : DifferentiableWithinAt ℂ f s x) :
    DifferentiableWithinAt ℂ (fun x => Complex.cosh (f x)) s x
-- Mathlib/Algebra/Group/Invertible/Defs.lean
@[simp]
theorem invOf_invOf [Monoid α] (a : α) [Invertible a] [Invertible (⅟ a)] : ⅟ (⅟ a) = a
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
@[measurability]
theorem Measurable.max {f g : δ → α} (hf : Measurable f) (hg : Measurable g) :
    Measurable fun a => max (f a) (g a)
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[simp]
theorem cancel_left {g : β →*₀o γ} {f₁ f₂ : α →*₀o β} (hg : Function.Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/Analysis/SumOverResidueClass.lean
/-- If `f : ℕ → ℝ` is decreasing and has a negative term, then `f` restricted to a residue
class is not summable. -/
lemma not_summable_indicator_mod_of_antitone_of_neg {m : ℕ} [hm : NeZero m] {f : ℕ → ℝ}
    (hf : Antitone f) {n : ℕ} (hn : f n < 0) (k : ZMod m) :
    ¬ Summable ({n : ℕ | (n : ZMod m) = k}.indicator f)
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem toReal_one : toReal 1 = 1
-- Mathlib/Analysis/Seminorm.lean
theorem finset_sup_smul (p : ι → Seminorm 𝕜 E) (s : Finset ι) (C : ℝ≥0) :
    s.sup (C • p) = C • s.sup p
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] theorem zero_shiftRight : ∀ n, 0 >>> n = 0
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem two_nsmul_toReal_eq_two_mul_sub_two_pi {θ : Angle} :
    ((2 : ℕ) • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal
-- Mathlib/Analysis/Convex/Segment.lean
theorem openSegment_eq_image (x y : E) :
    openSegment 𝕜 x y = (fun θ : 𝕜 => (1 - θ) • x + θ • y) '' Ioo (0 : 𝕜) 1
-- Mathlib/FieldTheory/Separable.lean
theorem Separable.of_mul_left {f g : R[X]} (h : (f * g).Separable) : f.Separable
-- Mathlib/Order/Filter/AtTopBot.lean
theorem tendsto_add_atTop_iff_nat {f : ℕ → α} {l : Filter α} (k : ℕ) :
    Tendsto (fun n => f (n + k)) atTop l ↔ Tendsto f atTop l
-- Mathlib/Order/SuccPred/LinearLocallyFinite.lean
theorem isGLB_Ioc_of_isGLB_Ioi {i j k : ι} (hij_lt : i < j) (h : IsGLB (Set.Ioi i) k) :
    IsGLB (Set.Ioc i j) k
-- Mathlib/LinearAlgebra/PerfectPairing.lean
@[simp] lemma flip_apply (m : M) (n : N) : e.flip m n = e n m
-- Mathlib/LinearAlgebra/Contraction.lean
/-- As a matrix, `dualTensorHom` evaluated on a basis element of `M* ⊗ N` is a matrix with a
single one and zeros elsewhere -/
theorem toMatrix_dualTensorHom {m : Type*} {n : Type*} [Fintype m] [Finite n] [DecidableEq m]
    [DecidableEq n] (bM : Basis m R M) (bN : Basis n R N) (j : m) (i : n) :
    toMatrix bM bN (dualTensorHom R M N (bM.coord j ⊗ₜ bN i)) = stdBasisMatrix i j 1
-- Mathlib/MeasureTheory/Constructions/Polish/Basic.lean
/-- **Suslin's Theorem**: in a Hausdorff topological space, an analytic set with an analytic
complement is measurable. -/
theorem AnalyticSet.measurableSet_of_compl [T2Space α] [MeasurableSpace α] [OpensMeasurableSpace α]
    {s : Set α} (hs : AnalyticSet s) (hsc : AnalyticSet sᶜ) : MeasurableSet s
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_quadratic_le : degree (C a * X ^ 2 + C b * X + C c) ≤ 2
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem LinearEquiv.lift_rank_map_eq (f : M ≃ₗ[R] M') (p : Submodule R M) :
    lift.{v} (Module.rank R (p.map (f : M →ₗ[R] M'))) = lift.{v'} (Module.rank R p)
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
@[simp]
theorem isBigO_one_iff : f =O[l] (fun _x => 1 : α → F) ↔
    IsBoundedUnder (· ≤ ·) l fun x => ‖f x‖
-- Mathlib/Data/Set/Function.lean
theorem SurjOn.forall {p : β → Prop} (hf : s.SurjOn f t) (hf' : s.MapsTo f t) :
    (∀ y ∈ t, p y) ↔ (∀ x ∈ s, p (f x))
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_principal {s : Set α} : f =O[𝓟 s] g ↔ ∃ c, ∀ x ∈ s, ‖f x‖ ≤ c * ‖g x‖
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem ones_blocksFun (n : ℕ) (i : Fin (ones n).length) : (ones n).blocksFun i = 1
-- Mathlib/Order/CompactlyGenerated/Basic.lean
protected theorem Directed.disjoint_iSup_left (h : Directed (· ≤ ·) f) :
    Disjoint (⨆ i, f i) a ↔ ∀ i, Disjoint (f i) a
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
/-- The Legendre symbol depends only on `a` mod `p`. -/
protected theorem mod (a : ℤ) : legendreSym p a = legendreSym p (a % p)
-- Mathlib/RingTheory/OreLocalization/OreSet.lean
/-- The Ore condition of a fraction, expressed in terms of `oreNum` and `oreDenom`. -/
@[to_additive AddOreLocalization.add_ore_eq
  "The Ore condition of a difference, expressed in terms of `oreMin` and `oreSubtra`."]
theorem ore_eq (r : R) (s : S) : oreDenom r s * r = oreNum r s * s
-- Mathlib/Analysis/Normed/Group/CocompactMap.lean
theorem CocompactMapClass.norm_le [FunLike 𝓕 E F] [CocompactMapClass 𝓕 E F] (ε : ℝ) :
    ∃ r : ℝ, ∀ x : E, r < ‖x‖ → ε < ‖f x‖
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
@[simp]
theorem mem_basicOpen (f : R) (x : PrimeSpectrum R) : x ∈ basicOpen f ↔ f ∉ x.asIdeal
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem mul_inv_cancel_of_le_one [h : IsDedekindDomain A] {I : Ideal A} (hI0 : I ≠ ⊥)
    (hI : (I * (I : FractionalIdeal A⁰ K)⁻¹)⁻¹ ≤ 1) : I * (I : FractionalIdeal A⁰ K)⁻¹ = 1
-- Mathlib/Data/Fin/Basic.lean
protected theorem mul_one' [NeZero n] (k : Fin n) : k * 1 = k
-- Mathlib/Analysis/InnerProductSpace/Adjoint.lean
/-- The adjoint of the composition of two operators is the composition of the two adjoints
in reverse order. -/
@[simp]
theorem adjoint_comp (A : F →L[𝕜] G) (B : E →L[𝕜] F) : (A ∘L B)† = B† ∘L A†
-- Mathlib/RingTheory/Polynomial/Cyclotomic/Roots.lean
theorem cyclotomic.roots_to_finset_eq_primitiveRoots [NeZero (n : R)] :
    (⟨(cyclotomic n R).roots, roots_cyclotomic_nodup⟩ : Finset _) = primitiveRoots n R
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem beq_self_right : ∀(a b : Bool), ((a == b) == b) = a
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- If a functor `L : C ⥤ D` is a left adjoint, it is initial. -/
theorem initial_of_adjunction {L : C ⥤ D} {R : D ⥤ C} (adj : L ⊣ R) : Initial L
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem lsub_lt_ord {ι} {f : ι → Ordinal} {c : Ordinal} (hι : #ι < c.cof) :
    (∀ i, f i < c) → lsub.{u, u} f < c
-- Mathlib/Data/Finsupp/Defs.lean
@[simp, norm_cast]
theorem coe_mk (f : α → M) (s : Finset α) (h : ∀ a, a ∈ s ↔ f a ≠ 0) : ⇑(⟨s, f, h⟩ : α →₀ M) = f
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Power2.lean
theorem one_isPowerOfTwo : isPowerOfTwo 1
-- Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean
private lemma pairMap_of_snd_mem_fst {t : Finset σ × σ} (h : t.snd ∈ t.fst) :
    pairMap σ t = (t.fst.erase t.snd, t.snd)
-- Mathlib/Probability/Kernel/Disintegration/StandardBorel.lean
lemma compProd_fst_condKernelReal (κ : Kernel α (γ × ℝ)) [IsFiniteKernel κ] :
    fst κ ⊗ₖ condKernelReal κ = κ
-- Mathlib/Algebra/Lie/Rank.lean
lemma isRegular_iff_finrank_engel_eq_rank (x : L) :
    IsRegular K x ↔ finrank K (engel K x) = rank K L
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem snd_prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : (snd R B C).comp (prod f g) = g
-- Mathlib/Algebra/Ring/Regular.lean
/-- Right `Mul` by a `k : α` over `[Ring α]` is injective, if `k` is not a zero divisor.
The typeclass that restricts all terms of `α` to have this property is `NoZeroDivisors`. -/
theorem isRightRegular_of_non_zero_divisor [NonUnitalNonAssocRing α] (k : α)
    (h : ∀ x : α, x * k = 0 → x = 0) : IsRightRegular k
-- Mathlib/Topology/Instances/TrivSqZeroExt.lean
theorem nhds_inl [Zero M] (x : R) : 𝓝 (inl x : tsze R M) = (𝓝 x).prod (𝓝 0)
-- Mathlib/FieldTheory/SeparableClosure.lean
/-- If `E` and `K` are isomorphic as `F`-algebras, then they have the same
inseparable degree over `F`. -/
theorem lift_insepDegree_eq_of_equiv (i : E ≃ₐ[F] K) :
    Cardinal.lift.{w} (insepDegree F E) = Cardinal.lift.{v} (insepDegree F K)
-- Mathlib/Order/Partition/Finpartition.lean
theorem card_bot (s : Finset α) : (⊥ : Finpartition s).parts.card = s.card
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
@[simp]
theorem Subalgebra.finrank_bot : finrank F (⊥ : Subalgebra F E) = 1
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
theorem cardinal_le_rank' {s : Set M}
    (hs : LinearIndependent R (fun x => x : s → M)) : #s ≤ Module.rank R M
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
@[simp] lemma deleteEdges_edgeSet (G G' : SimpleGraph V) : G.deleteEdges G'.edgeSet = G \ G'
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurable_from_prod_countable' [Countable β]
    {_ : MeasurableSpace γ} {f : α × β → γ} (hf : ∀ y, Measurable fun x => f (x, y))
    (h'f : ∀ y y' x, y' ∈ measurableAtom y → f (x, y') = f (x, y)) :
    Measurable f
-- Mathlib/Data/List/Nodup.lean
@[simp]
theorem count_eq_one_of_mem [DecidableEq α] {a : α} {l : List α} (d : Nodup l) (h : a ∈ l) :
    count a l = 1
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Ico_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ico a b = Ioc (b / c) (a / c)
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive (attr := simp)]
theorem coe_id : ⇑(OrderMonoidHom.id α) = id
-- Mathlib/Order/BooleanAlgebra.lean
@[simp]
theorem sup_inf_sdiff (x y : α) : x ⊓ y ⊔ x \ y = x
-- Mathlib/Order/Basic.lean
theorem Pi.le_def [∀ i, LE (π i)] {x y : ∀ i, π i} :
    x ≤ y ↔ ∀ i, x i ≤ y i
-- Mathlib/NumberTheory/SumTwoSquares.lean
/-- If a prime `p` divides `n` such that `-1` is a square modulo `n`, then `p % 4 ≠ 3`. -/
theorem Nat.Prime.mod_four_ne_three_of_dvd_isSquare_neg_one {p n : ℕ} (hpp : p.Prime) (hp : p ∣ n)
    (hs : IsSquare (-1 : ZMod n)) : p % 4 ≠ 3
-- Mathlib/Analysis/Normed/Group/Basic.lean
theorem hasCompactSupport_norm_iff : (HasCompactSupport fun x => ‖f x‖) ↔ HasCompactSupport f
-- Mathlib/Analysis/SpecialFunctions/ExpDeriv.lean
@[simp]
theorem deriv_exp : deriv exp = exp
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem coe_injective (h : degree f ≠ 0) : Function.Injective ((↑) : K → AdjoinRoot f)
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
/-- Assumes right covariance. -/
theorem Right.mul_pos [MulPosStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b
-- Mathlib/Data/Nat/PartENat.lean
theorem withTopEquiv_top : withTopEquiv ⊤ = ⊤
-- Mathlib/Topology/Order/ProjIcc.lean
theorem ContinuousAt.IccExtend {x : γ} (f : γ → Icc a b → β) {g : γ → α}
    (hf : ContinuousAt (↿f) (x, projIcc a b h (g x))) (hg : ContinuousAt g x) :
    ContinuousAt (fun a => IccExtend h (f a) (g a)) x
-- Mathlib/Analysis/Convex/Body.lean
@[simp] -- Porting note: add norm_cast; we leave it out for now to reproduce mathlib3 behavior.
theorem coe_smul (c : ℝ) (K : ConvexBody V) : (↑(c • K) : Set V) = c • (K : Set V)
-- Mathlib/Topology/Irreducible.lean
theorem isPreirreducible_iff_closure : IsPreirreducible (closure s) ↔ IsPreirreducible s
-- Mathlib/Probability/CondCount.lean
theorem condCount_isProbabilityMeasure {s : Set Ω} (hs : s.Finite) (hs' : s.Nonempty) :
    IsProbabilityMeasure (condCount s)
-- Mathlib/Algebra/Group/Action/Defs.lean
lemma Function.End.one_def : (1 : Function.End α) = id
-- Mathlib/Algebra/ModEq.lean
@[simp]
protected theorem add_iff_left :
    a₁ ≡ b₁ [PMOD p] → (a₁ + a₂ ≡ b₁ + b₂ [PMOD p] ↔ a₂ ≡ b₂ [PMOD p])
-- Mathlib/LinearAlgebra/Ray.lean
/-- The action via `LinearEquiv.apply_distribMulAction` corresponds to `Module.Ray.map`. -/
@[simp]
theorem Module.Ray.linearEquiv_smul_eq_map (e : M ≃ₗ[R] M) (v : Module.Ray R M) :
    e • v = Module.Ray.map e v
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addY_of_X_eq {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 = Q x * P z ^ 2) : W.addY P Q = addU P Q ^ 3
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Expand `⟪x + y, x + y⟫` -/
theorem inner_add_add_self (x y : E) : ⟪x + y, x + y⟫ = ⟪x, x⟫ + ⟪x, y⟫ + ⟪y, x⟫ + ⟪y, y⟫
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- A specialization of the spectral mapping theorem for polynomials in a Banach algebra over `ℂ`
to monic monomials. -/
protected theorem map_pow (n : ℕ) :
    spectrum ℂ (a ^ n) = (· ^ n) '' spectrum ℂ a
-- Mathlib/Topology/Instances/AddCircle.lean
theorem addOrderOf_div_of_gcd_eq_one' {m : ℤ} {n : ℕ} (hn : 0 < n) (h : m.natAbs.gcd n = 1) :
    addOrderOf (↑(↑m / ↑n * p) : AddCircle p) = n
-- Mathlib/RingTheory/Localization/Integral.lean
lemma isAlgebraic_of_isFractionRing {R S} (K L) [CommRing R] [CommRing S] [Field K] [CommRing L]
    [Algebra R S] [Algebra R K] [Algebra R L] [Algebra S L] [Algebra K L] [IsScalarTower R S L]
    [IsScalarTower R K L] [IsFractionRing S L]
    [Algebra.IsIntegral R S] : Algebra.IsAlgebraic K L
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
@[simp]
lemma Cocone.toCostructuredArrow_comp_proj {F : J ⥤ C} (c : Cocone F) :
    c.toCostructuredArrow ⋙ CostructuredArrow.proj _ _ = 𝟭 J
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem optParam_eq (α : Sort u) (default : α) : optParam α default = α
-- Mathlib/Algebra/Polynomial/Div.lean
theorem exists_eq_pow_rootMultiplicity_mul_and_not_dvd (p : R[X]) (hp : p ≠ 0) (a : R) :
    ∃ q : R[X], p = (X - C a) ^ p.rootMultiplicity a * q ∧ ¬ (X - C a) ∣ q
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem star_im (z : ℤ√d) : (star z).im = -z.im
-- Mathlib/Logic/Equiv/PartialEquiv.lean
protected theorem invOn : InvOn e.symm e e.source e.target
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasDerivWithinAt.sinh (hf : HasDerivWithinAt f f' s x) :
    HasDerivWithinAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') s x
-- Mathlib/Data/Finset/Sym.lean
theorem monotone_sym2 : Monotone (Finset.sym2 : Finset α → _)
-- Mathlib/Data/Nat/Defs.lean
@[simp] lemma min_eq_zero_iff : min m n = 0 ↔ m = 0 ∨ n = 0
-- Mathlib/Order/JordanHolder.lean
theorem isMaximal_of_eq_inf (x b : X) {a y : X} (ha : x ⊓ y = a) (hxy : x ≠ y) (hxb : IsMaximal x b)
    (hyb : IsMaximal y b) : IsMaximal a y
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem isClosed_zeroLocus (s : Set A) : IsClosed (zeroLocus 𝒜 s)
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem coeff_update_apply (p : R[X]) (n : ℕ) (a : R) (i : ℕ) :
    (p.update n a).coeff i = if i = n then a else p.coeff i