ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Logic/Equiv/Basic.lean
theorem uniqueProd_apply [Unique β] (x : β × α) : uniqueProd α β x = x.2
-- Mathlib/Data/Finset/Image.lean
@[simp 1100]
theorem mem_map_equiv {f : α ≃ β} {b : β} : b ∈ s.map f.toEmbedding ↔ f.symm b ∈ s
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma nndist_le_pi_nndist (f g : ∀ b, π b) (b : β) : nndist (f b) (g b) ≤ nndist f g
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[norm_cast] -- Porting note (#10618): simp can prove this (removed `@[simp]`)
theorem coe_intCast : ∀ n : ℤ, ((n : s) : R) = n
-- Mathlib/Geometry/Euclidean/Inversion/Calculus.lean
protected nonrec theorem ContDiff.inversion (hc : ContDiff ℝ n c) (hR : ContDiff ℝ n R)
    (hx : ContDiff ℝ n x) (hne : ∀ a, x a ≠ c a) :
    ContDiff ℝ n (fun a ↦ inversion (c a) (R a) (x a))
-- Mathlib/Data/Matroid/Basic.lean
theorem exists_basis' (M : Matroid α) (X : Set α) : ∃ I, M.Basis' I X
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- The radius of the Cartesian product of two formal series is the minimum of their radii. -/
lemma FormalMultilinearSeries.radius_prod_eq_min
    (p : FormalMultilinearSeries 𝕜 E F) (q : FormalMultilinearSeries 𝕜 E G) :
    (p.prod q).radius = min p.radius q.radius
-- Mathlib/Data/Real/EReal.lean
lemma div_right_distrib_of_nonneg {a b c : EReal} (h : 0 ≤ a) (h' : 0 ≤ b) :
    (a + b) / c = (a / c) + (b / c)
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[simp]
theorem isTheta_exp_comp_exp_comp {f g : α → ℝ} :
    ((fun x => exp (f x)) =Θ[l] fun x => exp (g x)) ↔
      IsBoundedUnder (· ≤ ·) l fun x => |f x - g x|
-- Mathlib/Algebra/Order/Interval/Set/Monoid.lean
@[simp]
theorem image_add_const_Ioi : (fun x => x + a) '' Ioi b = Ioi (b + a)
-- Mathlib/GroupTheory/GroupAction/FixedPoints.lean
@[to_additive]
theorem fixedBy_mul (m₁ m₂ : M) : fixedBy α m₁ ∩ fixedBy α m₂ ⊆ fixedBy α (m₁ * m₂)
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
theorem pairwise_disjoint_Ioo_intCast : Pairwise (Disjoint on fun n : ℤ => Ioo (n : α) (n + 1))
-- Mathlib/Order/Lattice.lean
theorem le_sup_of_le_left (h : c ≤ a) : c ≤ a ⊔ b
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
lemma cons_val_four (x : α) (u : Fin m.succ.succ.succ.succ → α) :
    vecCons x u 4 = vecHead (vecTail (vecTail (vecTail u)))
-- Mathlib/MeasureTheory/Function/UniformIntegrable.lean
/-- A finite sequence of Lp functions is uniformly integrable. -/
theorem unifIntegrable_finite [Finite ι] (hp_one : 1 ≤ p) (hp_top : p ≠ ∞) {f : ι → α → β}
    (hf : ∀ i, Memℒp (f i) p μ) : UnifIntegrable f p μ
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
@[simp]
theorem measure_empty : μ ∅ = 0
-- Mathlib/Data/List/Basic.lean
theorem getLast_reverse {l : List α} (hl : l.reverse ≠ [])
    (hl' : 0 < l.length := (by
      contrapose! hl
      simpa [length_eq_zero] using hl)) :
    l.reverse.getLast hl = l.get ⟨0, hl'⟩
-- Mathlib/Order/Chain.lean
theorem isChain_univ_iff : IsChain r (univ : Set α) ↔ IsTrichotomous α r
-- Mathlib/InformationTheory/Hamming.lean
theorem hammingNorm_smul [Zero α] [∀ i, SMulWithZero α (β i)] {k : α}
    (hk : ∀ i, IsSMulRegular (β i) k) (x : ∀ i, β i) : hammingNorm (k • x) = hammingNorm x
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
lemma eventually_bi_mul_le_r : ∀ᶠ (n : ℕ) in atTop, ∀ i, (b (min_bi b) / 2) * n ≤ r i n
-- Mathlib/Algebra/Ring/Parity.lean
lemma Odd.of_mul_right (h : Odd (m * n)) : Odd n
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem comp_toLinearMap (φ₁ : B →ₗc[R] C) (φ₂ : A →ₗc[R] B) :
    φ₁.comp φ₂ = (φ₁ : B →ₗ[R] C) ∘ₗ (φ₂ : A →ₗ[R] B)
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
protected theorem congr_arg {x x'} : x = x' → e x = e x'
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem natCast_re (n : ℕ) : (n : ℤ√d).re = n
-- Mathlib/Data/Set/Lattice.lean
theorem biUnion_image : ⋃ x ∈ f '' s, g x = ⋃ y ∈ s, g (f y)
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem symmDiff_symmDiff_inf : a ∆ b ∆ (a ⊓ b) = a ⊔ b
-- Mathlib/Order/Cover.lean
theorem WCovBy.of_image (f : α ↪o β) (h : f a ⩿ f b) : a ⩿ b
-- Mathlib/Computability/TMToPartrec.lean
@[simp]
theorem codeSupp_case (f g k) :
    codeSupp (Code.case f g) k =
      trStmts₁ (trNormal (Code.case f g) k) ∪ (codeSupp f k ∪ codeSupp g k)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The `spanPoints` of a set is nonempty if and only if that set is. -/
@[simp]
theorem spanPoints_nonempty (s : Set P) : (spanPoints k s).Nonempty ↔ s.Nonempty
-- Mathlib/Algebra/GradedMonoid.lean
@[simps one]
instance One.gOne [Zero ι] [One R] : GradedMonoid.GOne fun _ : ι => R
-- Mathlib/LinearAlgebra/DirectSum/Finsupp.lean
lemma finsuppLeft_smul' (s : S) (t : (ι →₀ M) ⊗[R] N) :
    finsuppLeft R M N ι (s • t) = s • finsuppLeft R M N ι t
-- Mathlib/Topology/Separation.lean
theorem disjoint_nhds_nhds_iff_not_inseparable : Disjoint (𝓝 x) (𝓝 y) ↔ ¬Inseparable x y
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem refl_apply (x : α) : refl α x = x
-- Mathlib/Computability/Halting.lean
/-- The **Halting problem** is not computable -/
theorem halting_problem (n) : ¬ComputablePred fun c => (eval c n).Dom
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem le_multiplicity_iff_replicate_le_normalizedFactors {a b : R} {n : ℕ} (ha : Irreducible a)
    (hb : b ≠ 0) :
    ↑n ≤ multiplicity a b ↔ replicate n (normalize a) ≤ normalizedFactors b
-- Mathlib/CategoryTheory/Limits/Shapes/Reflexive.lean
theorem hasCoequalizer_of_common_section [HasReflexiveCoequalizers C] {A B : C} {f g : A ⟶ B}
    (r : B ⟶ A) (rf : r ≫ f = 𝟙 _) (rg : r ≫ g = 𝟙 _) : HasCoequalizer f g
-- Mathlib/Data/Finset/Basic.lean
theorem not_disjoint_iff_nonempty_inter : ¬Disjoint s t ↔ (s ∩ t).Nonempty
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
lemma IsPointwiseRightKanExtensionAt.isIso_hom_app
    {X : C} (h : E.IsPointwiseRightKanExtensionAt (L.obj X)) [L.Full] [L.Faithful] :
    IsIso (E.hom.app X)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem one_lt_inv (h₁ : 0 < a) (h₂ : a < 1) : 1 < a⁻¹
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toFinset_nsmul (s : Multiset α) : ∀ n ≠ 0, (n • s).toFinset = s.toFinset
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma nonsingular_iff_variableChange (x y : R) :
    W.Nonsingular x y ↔ (W.variableChange ⟨1, x, 0, y⟩).toAffine.Nonsingular 0 0
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
lemma epi_homologyMap_of_epi_cyclesMap'
    [S₁.HasHomology] [S₂.HasHomology] (h : Epi (cyclesMap φ)) :
    Epi (homologyMap φ)
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem symm_toHomeomorph (h : M ≃ₘ^n⟮I, J⟯ N) : h.symm.toHomeomorph = h.toHomeomorph.symm
-- Mathlib/NumberTheory/LSeries/RiemannZeta.lean
/-- The Riemann zeta function is differentiable away from `s = 1`. -/
theorem differentiableAt_riemannZeta {s : ℂ} (hs' : s ≠ 1) : DifferentiableAt ℂ riemannZeta s
-- Mathlib/Algebra/Homology/ShortComplex/Abelian.lean
@[reassoc (attr := simp)]
lemma cokernel_π_comp_cokernelToAbelianCoimage :
    cokernel.π S.f ≫ S.cokernelToAbelianCoimage = Abelian.coimage.π S.g
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_plift_false : #(PLift False) = 0
-- Mathlib/Data/Multiset/Bind.lean
@[simp]
theorem card_product : card (s ×ˢ t) = card s * card t
-- Mathlib/Analysis/InnerProductSpace/Symmetric.lean
/-- The **Hellinger--Toeplitz theorem**: if a symmetric operator is defined on a complete space,
  then it is automatically continuous. -/
theorem IsSymmetric.continuous [CompleteSpace E] {T : E →ₗ[𝕜] E} (hT : IsSymmetric T) :
    Continuous T
-- Mathlib/LinearAlgebra/CliffordAlgebra/Equivs.lean
@[simp]
theorem ofQuaternion_mk (a₁ a₂ a₃ a₄ : R) :
    ofQuaternion (⟨a₁, a₂, a₃, a₄⟩ : ℍ[R,c₁,c₂]) =
      algebraMap R _ a₁ + a₂ • ι (Q c₁ c₂) (1, 0) + a₃ • ι (Q c₁ c₂) (0, 1) +
        a₄ • (ι (Q c₁ c₂) (1, 0) * ι (Q c₁ c₂) (0, 1))
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem ord_term {o : Ordinal} (ho : o < Ordinal.type ((·<·) : I → I → Prop)) (i : I) :
    ord I i = o ↔ term I ho = i
-- Mathlib/CategoryTheory/Monoidal/Tor.lean
@[simp]
lemma Tor'_obj_map (n : ℕ) {X Y : C} (Z : C) (f : X ⟶ Y) :
    ((Tor' C n).obj Z).map f = (NatTrans.leftDerived ((tensoringRight C).map f) n).app Z
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderSpecialization_sUnion (S : Set (Set X))
    (H : ∀ s ∈ S, StableUnderSpecialization s) : StableUnderSpecialization (⋃₀ S)
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem modular_S_smul (z : ℍ) : ModularGroup.S • z = mk (-z : ℂ)⁻¹ z.im_inv_neg_coe_pos
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem_singleton (since := "2024-06-12")]
theorem get_singleton (a : α) (n : Fin 1) : get [a] n = a
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem mod_val (a b : Fin n) : (a % b).val = a.val % b.val
-- Mathlib/Order/Filter/Basic.lean
theorem mem_kernMap_iff_compl {s : Set β} : s ∈ kernMap m f ↔ ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ
-- Mathlib/Order/Lattice.lean
theorem inf_inf_distrib_right (a b c : α) : a ⊓ b ⊓ c = a ⊓ c ⊓ (b ⊓ c)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoDiv_sub (a b : α) : toIcoDiv hp a (b - p) = toIcoDiv hp a b - 1
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
@[simp]
theorem infty_coeFn_one : ⇑(1 : lp B ∞) = 1
-- Mathlib/GroupTheory/Abelianization.lean
theorem commutator_eq_closure : commutator G = Subgroup.closure (commutatorSet G)
-- Mathlib/Data/PFunctor/Univariate/M.lean
theorem head_eq_head' : ∀ (x : M F) (n : ℕ), head x = head' (x.approx <| n + 1)
-- Mathlib/Analysis/Analytic/Basic.lean
/-- If `f` has formal power series `∑ n, pₙ` on a ball of radius `r`, then for `y, z` in any smaller
ball, the norm of the difference `f y - f z - p 1 (fun _ ↦ y - z)` is bounded above by
`C * (max ‖y - x‖ ‖z - x‖) * ‖y - z‖`. -/
theorem HasFPowerSeriesOnBall.image_sub_sub_deriv_le (hf : HasFPowerSeriesOnBall f p x r)
    (hr : r' < r) :
    ∃ C, ∀ᵉ (y ∈ EMetric.ball x r') (z ∈ EMetric.ball x r'),
      ‖f y - f z - p 1 fun _ => y - z‖ ≤ C * max ‖y - x‖ ‖z - x‖ * ‖y - z‖
-- Mathlib/Probability/Kernel/MeasurableIntegral.lean
theorem measurable_kernel_prod_mk_right [IsSFiniteKernel κ] {s : Set (β × α)}
    (hs : MeasurableSet s) : Measurable fun y => κ y ((fun x => (x, y)) ⁻¹' s)
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
@[simp]
lemma reflection_image_eq :
    P.reflection i '' (range P.root) = range P.root
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem coe_associatedHom :
    ⇑(associatedHom S : QuadraticMap R M N →ₗ[S] BilinMap R M N) = associated
-- Mathlib/Data/List/OfFn.lean
theorem last_ofFn {n : ℕ} (f : Fin n → α) (h : ofFn f ≠ [])
    (hn : n - 1 < n := Nat.pred_lt <| ofFn_eq_nil_iff.not.mp h) :
    getLast (ofFn f) h = f ⟨n - 1, hn⟩
-- Mathlib/Analysis/Calculus/ParametricIntegral.lean
/-- Differentiation under integral of `x ↦ ∫ F x a` at a given point `x₀`, assuming
`F x₀` is integrable, `x ↦ F x a` is differentiable on a ball around `x₀` for ae `a` with
derivative norm uniformly bounded by an integrable function (the ball radius is independent of `a`),
and `F x` is ae-measurable for `x` in a possibly smaller neighborhood of `x₀`. -/
theorem hasFDerivAt_integral_of_dominated_of_fderiv_le {F' : H → α → H →L[𝕜] E} (ε_pos : 0 < ε)
    (hF_meas : ∀ᶠ x in 𝓝 x₀, AEStronglyMeasurable (F x) μ) (hF_int : Integrable (F x₀) μ)
    (hF'_meas : AEStronglyMeasurable (F' x₀) μ)
    (h_bound : ∀ᵐ a ∂μ, ∀ x ∈ ball x₀ ε, ‖F' x a‖ ≤ bound a)
    (bound_integrable : Integrable (bound : α → ℝ) μ)
    (h_diff : ∀ᵐ a ∂μ, ∀ x ∈ ball x₀ ε, HasFDerivAt (F · a) (F' x a) x) :
    HasFDerivAt (fun x ↦ ∫ a, F x a ∂μ) (∫ a, F' x₀ a ∂μ) x₀
-- Mathlib/NumberTheory/ArithmeticFunction.lean
/-- Möbius inversion for functions to a `CommGroupWithZero`. -/
theorem prod_eq_iff_prod_pow_moebius_eq_of_nonzero [CommGroupWithZero R] {f g : ℕ → R}
    (hf : ∀ n : ℕ, 0 < n → f n ≠ 0) (hg : ∀ n : ℕ, 0 < n → g n ≠ 0) :
    (∀ n > 0, ∏ i ∈ n.divisors, f i = g n) ↔
      ∀ n > 0, ∏ x ∈ n.divisorsAntidiagonal, g x.snd ^ μ x.fst = f n
-- Mathlib/Algebra/GCDMonoid/Finset.lean
@[simp]
theorem gcd_empty : (∅ : Finset β).gcd f = 0
-- Mathlib/Data/Finset/NoncommProd.lean
theorem mul_noncommProd_erase [DecidableEq α] (s : Multiset α) {a : α} (h : a ∈ s) (comm)
    (comm' := fun x hx y hy hxy ↦ comm (s.mem_of_mem_erase hx) (s.mem_of_mem_erase hy) hxy) :
    a * (s.erase a).noncommProd comm' = s.noncommProd comm
-- Mathlib/Data/Set/Lattice.lean
lemma kernImage_preimage_union {s : Set α} {t : Set β} :
    kernImage f (f ⁻¹' t ∪ s) = t ∪ kernImage f s
-- Mathlib/Order/Bounds/Basic.lean
theorem IsGLB.nonempty [NoMaxOrder α] (hs : IsGLB s a) : s.Nonempty
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
lemma subgraphOfAdj_le_of_adj {v w : V} (H : G.Subgraph) (h : H.Adj v w) :
    G.subgraphOfAdj (H.adj_sub h) ≤ H
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
theorem zero_mem' (U : (Opens (ProjectiveSpectrum.top 𝒜))ᵒᵖ) :
    (isLocallyFraction 𝒜).pred (0 : ∀ x : U.unop, at x.1)
-- Mathlib/Topology/Instances/AddCircle.lean
theorem addOrderOf_eq_pos_iff {u : AddCircle p} {n : ℕ} (h : 0 < n) :
    addOrderOf u = n ↔ ∃ m < n, m.gcd n = 1 ∧ ↑(↑m / ↑n * p) = u
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem mul_le : I * J ≤ K ↔ ∀ r ∈ I, ∀ s ∈ J, r * s ∈ K
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
theorem exp_arsinh (x : ℝ) : exp (arsinh x) = x + √(1 + x ^ 2)
-- Mathlib/Analysis/Complex/Basic.lean
theorem lipschitz_equivRealProd : LipschitzWith 1 equivRealProd
-- Mathlib/Topology/FiberBundle/Basic.lean
theorem isOpen_source (e : Pretrivialization F (π F E)) :
    IsOpen[a.totalSpaceTopology] e.source
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
protected theorem map_mul (f : A →ₛₙₐ[φ] B) (x y : A) : f (x * y) = f x * f y
-- Mathlib/Algebra/Order/GroupWithZero/Unbundled.lean
theorem PosMulReflectLE.toPosMulStrictMono [PosMulReflectLE α] : PosMulStrictMono α
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem cos_arccos {x : ℝ} (hx₁ : -1 ≤ x) (hx₂ : x ≤ 1) : cos (arccos x) = x
-- Mathlib/FieldTheory/Finite/Basic.lean
/-- A non-zero `a : F` is a square if and only if `a ^ (#F / 2) = 1`. -/
theorem isSquare_iff (hF : ringChar F ≠ 2) {a : F} (ha : a ≠ 0) :
    IsSquare a ↔ a ^ (Fintype.card F / 2) = 1
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem isDedekindDomainInv_iff [Algebra A K] [IsFractionRing A K] :
    IsDedekindDomainInv A ↔ ∀ I ≠ (⊥ : FractionalIdeal A⁰ K), I * I⁻¹ = 1
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
theorem dist_conj_conj (z w : ℂ) : dist (conj z) (conj w) = dist z w
-- Mathlib/LinearAlgebra/Span.lean
theorem span_eq_bot : span R (s : Set M) = ⊥ ↔ ∀ x ∈ s, (x : M) = 0
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
@[simp]
theorem expMapCircle_two_pi : expMapCircle (2 * π) = 1
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_of_le_one (h : a ≤ 1) : |a|ₘ = a⁻¹
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
@[simp]
theorem sup_mul_inf (I J : Ideal A) : (I ⊔ J) * (I ⊓ J) = I * J
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem Submodule.topologicalClosure_coe (s : Submodule R M) :
    (s.topologicalClosure : Set M) = closure (s : Set M)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ_1728_of_two_ne_zero [h2 : NeZero (2 : F)] :
    ofJ 1728 = @ofJ1728 _ _ (invertibleOfNonzero h2.out)
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
/-- `∨` distributes over `∧` (on the left). -/
theorem or_and_left : a ∨ (b ∧ c) ↔ (a ∨ b) ∧ (a ∨ c)
-- Mathlib/LinearAlgebra/TensorPower.lean
theorem mul_algebraMap₀ {n} (r : R) (a : ⨂[R]^n M) :
    cast R M (add_zero _) (a ₜ* algebraMap₀ r) = r • a
-- Mathlib/Data/Set/Lattice.lean
theorem iUnion_dite (f : ∀ i, p i → Set α) (g : ∀ i, ¬p i → Set α) :
    ⋃ i, (if h : p i then f i h else g i h) = (⋃ (i) (h : p i), f i h) ∪ ⋃ (i) (h : ¬p i), g i h
-- Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean
lemma isHomLift_iff : IsHomLift 𝒴.p f (F.map φ) ↔ IsHomLift 𝒳.p f φ
-- Mathlib/Order/SupIndep.lean
theorem setIndependent_singleton (a : α) : SetIndependent ({a} : Set α)
-- Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean
lemma quasiIso_iff_comp_left (φ : S₁ ⟶ S₂) (φ' : S₂ ⟶ S₃) [hφ : QuasiIso φ] :
    QuasiIso (φ ≫ φ') ↔ QuasiIso φ'
-- Mathlib/CategoryTheory/Limits/VanKampen.lean
theorem hasStrictInitial_of_isUniversal [HasInitial C]
    (H : IsUniversalColimit (BinaryCofan.mk (𝟙 (⊥_ C)) (𝟙 (⊥_ C)))) : HasStrictInitialObjects C
-- Mathlib/Algebra/GCDMonoid/Basic.lean
lemma neg_gcd' [GCDMonoid α] {a b : α} : Associated (gcd (-a) b) (gcd a b)
-- Mathlib/Order/Filter/Germ/Basic.lean
@[to_additive (attr := simp, norm_cast)]
theorem const_pow [Pow G M] (a : G) (n : M) : (↑(a ^ n) : Germ l G) = (↑a : Germ l G) ^ n
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem isOneCoboundary_of_oneCoboundaries (f : oneCoboundaries (Rep.ofDistribMulAction k G A)) :
    IsOneCoboundary (A := A) f.1.1
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem comp (f : ι' → ι) (hf : Function.Injective f) : AlgebraicIndependent R (x ∘ f)
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem sum_card : Cardinal.sum (fun i => #(Sequence₂ a₀ a₁ a₂ i)) = #a₀ + #a₁ + #a₂
-- Mathlib/Analysis/Calculus/FDeriv/Equiv.lean
theorem comp_right_hasFDerivAt_iff' {f : F → G} {x : E} {f' : E →L[𝕜] G} :
    HasFDerivAt (f ∘ iso) f' x ↔ HasFDerivAt f (f'.comp (iso.symm : F →L[𝕜] E)) (iso x)
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_union_Ioi : Iio a ∪ Ioi a = {a}ᶜ
-- Mathlib/CategoryTheory/Bicategory/Extension.lean
/-- Construct a morphism between whiskered lifts. -/
@[simps! right]
def whiskerHom (i : s ⟶ t) {x : B} (h : x ⟶ c) :
    s.whisker h ⟶ t.whisker h
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_map_polarization' (T : V →ₗ[ℂ] V) (x y : V) :
    ⟪T x, y⟫_ℂ =
      (⟪T (x + y), x + y⟫_ℂ - ⟪T (x - y), x - y⟫_ℂ -
            Complex.I * ⟪T (x + Complex.I • y), x + Complex.I • y⟫_ℂ +
          Complex.I * ⟪T (x - Complex.I • y), x - Complex.I • y⟫_ℂ) /
        4
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem Iso.inv_inv (f : X ≅ Y) : inv f.inv = f.hom
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem coe_algebraMap [CommSemiring R] [Semiring k] [Algebra R k] [AddMonoid G] :
    (algebraMap R k[G] : R → k[G]) = single 0 ∘ algebraMap R k
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem toNat_of_nonneg {a : Int} (h : 0 ≤ a) : (toNat a : Int) = a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem edgeSet_subgraphOfAdj {v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).edgeSet = {s(v, w)}
-- Mathlib/Order/Filter/Basic.lean
theorem iSup_sets_eq {f : ι → Filter α} : (iSup f).sets = ⋂ i, (f i).sets
-- Mathlib/Topology/Connected/Basic.lean
theorem IsConnected.prod [TopologicalSpace β] {s : Set α} {t : Set β} (hs : IsConnected s)
    (ht : IsConnected t) : IsConnected (s ×ˢ t)
-- Mathlib/RingTheory/Regular/IsSMulRegular.lean
lemma IsSMulRegular.lTensor : IsSMulRegular (M ⊗[R] M') r
-- Mathlib/LinearAlgebra/Matrix/Trace.lean
theorem trace_mul_cycle [NonUnitalCommSemiring R] (A : Matrix m n R) (B : Matrix n p R)
    (C : Matrix p m R) : trace (A * B * C) = trace (C * A * B)
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem cmp_mul_neg_right [ExistsAddOfLE α] [MulPosStrictMono α]
    [ContravariantClass α α (swap (· + ·)) (· < ·)] [CovariantClass α α (swap (· + ·)) (· < ·)]
    {a : α} (ha : a < 0) (b c : α) : cmp (b * a) (c * a) = cmp c b
-- Mathlib/Topology/Separation/NotNormal.lean
/-- Let `s` be a closed set in a separable normal space. If the induced topology on `s` is discrete,
then `s` has cardinality less than continuum.

The proof follows
https://en.wikipedia.org/wiki/Moore_plane#Proof_that_the_Moore_plane_is_not_normal -/
theorem IsClosed.mk_lt_continuum [NormalSpace X] {s : Set X} (hs : IsClosed s)
    [DiscreteTopology s] : #s < 𝔠
-- Mathlib/RingTheory/FiniteType.lean
theorem comp {g : B →+* C} {f : A →+* B} (hg : g.FiniteType) (hf : f.FiniteType) :
    (g.comp f).FiniteType
-- Mathlib/Algebra/CharP/Defs.lean
lemma ringChar_zero_iff_CharZero : ringChar R = 0 ↔ CharZero R
-- Mathlib/Data/Fin/Basic.lean
lemma predAbove_pred_of_le (p i : Fin (n + 1)) (h : p ≤ i) (hp : p ≠ 0)
    (hi := Fin.ne_of_gt $ Fin.lt_of_lt_of_le (Fin.pos_iff_ne_zero.2 hp) h) :
  (pred p hp).predAbove i = pred i hi
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
@[simp]
theorem extend_top {α : Type*} {P : α → Prop} : extend (fun _ _ => ∞ : ∀ s : α, P s → ℝ≥0∞) = ⊤
-- Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean
lemma nonsingular_iff_affine_of_Z_ne_zero {P : Fin 3 → F} (hPz : P z ≠ 0) :
    W.Nonsingular P ↔ W.toAffine.Nonsingular (P x / P z) (P y / P z)
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem drop_sublist (n) (l : List α) : drop n l <+ l
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Basic.lean
/-- The matrix [a, -b; b, a] (inspired by multiplication by a complex number); it is an element of
$GL_2(R)$ if `a ^ 2 + b ^ 2` is nonzero. -/
@[simps! (config := .asFn) val]
def planeConformalMatrix {R} [Field R] (a b : R) (hab : a ^ 2 + b ^ 2 ≠ 0) :
    Matrix.GeneralLinearGroup (Fin 2) R
-- Mathlib/Data/Finset/Card.lean
theorem filter_card_eq {p : α → Prop} [DecidablePred p] (h : (s.filter p).card = s.card) (x : α)
    (hx : x ∈ s) : p x
-- Mathlib/Topology/Instances/ENNReal.lean
lemma truncateToReal_nonneg {t x : ℝ≥0∞} : 0 ≤ truncateToReal t x
-- Mathlib/GroupTheory/HNNExtension.lean
@[simp]
theorem lift_of (f : G →* H) (x : H) (hx : ∀ a : A, x * f ↑a = f (φ a : G) * x) (g : G) :
    lift f x hx (of g) = f g
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast] lemma coe_nonempty : (s : Set α).Nonempty ↔ s ≠ ⊥
-- Mathlib/Computability/Primrec.lean
protected theorem swap : Nat.Primrec (unpaired (swap Nat.pair))
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem Dense.borel_eq_generateFrom_Ioc_mem {α : Type*} [TopologicalSpace α] [LinearOrder α]
    [OrderTopology α] [SecondCountableTopology α] [DenselyOrdered α] [NoMaxOrder α] {s : Set α}
    (hd : Dense s) :
    borel α = .generateFrom { S : Set α | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Ioc l u = S }
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotQuotEquivComm_symmₐ : (quotQuotEquivCommₐ R I J).symm = quotQuotEquivCommₐ R J I
-- Mathlib/Algebra/Group/Basic.lean
theorem zpow_eq_zpow_emod {x : G} (m : ℤ) {n : ℤ} (h : x ^ n = 1) :
    x ^ m = x ^ (m % n)
-- Mathlib/Order/CompleteLattice.lean
theorem disjoint_sSup_right {a : Set α} {b : α} (d : Disjoint b (sSup a)) {i} (hi : i ∈ a) :
    Disjoint b i
-- Mathlib/Probability/ProbabilityMassFunction/Constructions.lean
@[simp]
theorem map_apply : (map f p) b = ∑' a, if b = f a then p a else 0
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
theorem rCond_of_bRiemann_eq_false {ι} (l : IntegrationParams) (hl : l.bRiemann = false)
    {r : (ι → ℝ) → Ioi (0 : ℝ)} : l.RCond r
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_nat_mul_pi_sub (x : ℝ) (n : ℕ) : cos (n * π - x) = (-1) ^ n * cos x
-- Mathlib/Data/Int/Cast/Lemmas.lean
@[simp] lemma coe_castAddHom : ⇑(castAddHom α) = fun x : ℤ => (x : α)
-- Mathlib/Data/Real/Irrational.lean
theorem of_div_rat (h : Irrational (x / q)) : Irrational x
-- Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean
theorem lintegral_lt_top_of_nnreal (f : X →ᵇ ℝ≥0) : ∫⁻ x, f x ∂μ < ∞
-- Mathlib/Analysis/Convex/Between.lean
theorem Sbtw.not_rotate [NoZeroSMulDivisors R V] {x y z : P} (h : Sbtw R x y z) : ¬Wbtw R z x y
-- Mathlib/Topology/Category/TopCat/Opens.lean
theorem map_functor_eq' {X U : TopCat} (f : U ⟶ X) (hf : OpenEmbedding f) (V) :
    ((Opens.map f).obj <| hf.isOpenMap.functor.obj V) = V
-- Mathlib/Data/Finmap.lean
theorem mem_def {a : α} {s : Finmap β} : a ∈ s ↔ a ∈ s.entries.keys
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem smoothOn_snd {s : Set (M × N)} : SmoothOn (I.prod J) J Prod.snd s
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
theorem limit.map_post {D : Type u'} [Category.{v'} D] [HasLimitsOfShape J D] (H : C ⥤ D) :
    /- H (limit F) ⟶ H (limit G) ⟶ limit (G ⋙ H) vs
     H (limit F) ⟶ limit (F ⋙ H) ⟶ limit (G ⋙ H) -/
    H.map (limMap α) ≫ limit.post G H = limit.post F H ≫ limMap (whiskerRight α H)
-- Mathlib/CategoryTheory/Triangulated/HomologicalFunctor.lean
lemma homologySequence_epi_shift_map_mor₁_iff :
    Epi ((F.shift n₀).map T.mor₁) ↔ (F.shift n₀).map T.mor₂ = 0