ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Algebra/Unitization.lean
@[simp]
theorem snd_inl [Zero A] (r : R) : (inl r : Unitization R A).snd = 0
-- Mathlib/Algebra/Associated/Basic.lean
theorem Associated.ne_zero_iff [MonoidWithZero α] {a b : α} (h : a ~ᵤ b) : a ≠ 0 ↔ b ≠ 0
-- Mathlib/Topology/Basic.lean
/-- Composition of a continuous map with dense range and a function with dense range has dense
range. -/
theorem DenseRange.comp {g : Y → Z} {f : α → Y} (hg : DenseRange g) (hf : DenseRange f)
    (cg : Continuous g) : DenseRange (g ∘ f)
-- Mathlib/Order/Antisymmetrization.lean
@[simp]
theorem toAntisymmetrization_ofAntisymmetrization (a : Antisymmetrization α r) :
    toAntisymmetrization r (ofAntisymmetrization r a) = a
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
@[simp, mfld_simps]
theorem hasMFDerivWithinAt_univ :
    HasMFDerivWithinAt I I' f univ x f' ↔ HasMFDerivAt I I' f x f'
-- Mathlib/LinearAlgebra/LinearIndependent.lean
/-- See also `CompleteLattice.independent_iff_linearIndependent_of_ne_zero`. -/
theorem LinearIndependent.independent_span_singleton (hv : LinearIndependent R v) :
    CompleteLattice.Independent fun i => R ∙ v i
-- .lake/packages/batteries/Batteries/Logic.lean
theorem Eq.congr_left {x y z : α} (h : x = y) : x = z ↔ y = z
-- Mathlib/Topology/Order/ScottTopology.lean
lemma isOpen_iff_Iic_compl_or_univ (U : Set α) :
    IsOpen U ↔ (∃ (a : α), U = (Iic a)ᶜ) ∨ U = univ
-- Mathlib/LinearAlgebra/Span.lean
theorem disjoint_span_singleton {K E : Type*} [DivisionRing K] [AddCommGroup E] [Module K E]
    {s : Submodule K E} {x : E} : Disjoint s (K ∙ x) ↔ x ∈ s → x = 0
-- .lake/packages/lean4/src/lean/lake/Lake/Config/Package.lean
/-- A package with a name known at type-level. -/
structure NPackage (name : Name) extends Package where
  name_eq : toPackage.name = name
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- ε-characterization of the closure in pseudoemetric spaces -/
theorem mem_closure_iff : x ∈ closure s ↔ ∀ ε > 0, ∃ y ∈ s, edist x y < ε
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
theorem toJordanDecomposition_zero : (0 : SignedMeasure α).toJordanDecomposition = 0
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
lemma abs_cpow_inv_two_im (x : ℂ) : |(x ^ (2⁻¹ : ℂ)).im| = sqrt ((abs x - x.re) / 2)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem BinaryBiproduct.bicone_snd : (BinaryBiproduct.bicone X Y).snd = biprod.snd
-- Mathlib/LinearAlgebra/QuadraticForm/Prod.lean
/-- `LinearMap.inr` as an isometry. -/
@[simps!]
def Isometry.inr (Q₁ : QuadraticMap R M₁ P) (Q₂ : QuadraticMap R M₂ P) : Q₂ →qᵢ (Q₁.prod Q₂)
-- Mathlib/Combinatorics/Quiver/SingleObj.lean
@[simp]
theorem pathEquivList_symm_cons (l : List α) (a : α) :
    pathEquivList.symm (a :: l) = Path.cons (pathEquivList.symm l) a
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem sumLexDualAntidistrib_symm_inl :
    (sumLexDualAntidistrib α β).symm (inl (toDual b)) = toDual (inr b)
-- Mathlib/Data/Bundle.lean
@[simp]
theorem TotalSpace.range_mk (b : B) : range ((↑) : E b → TotalSpace F E) = π F E ⁻¹' {b}
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem derivWithin (hxs : UniqueDiffWithinAt 𝕜 s x) :
    derivWithin (fun x => p.eval x) s x = p.derivative.eval x
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem IsIntegral.of_subring {x : B} (T : Subring R) (hx : IsIntegral T x) : IsIntegral R x
-- Mathlib/Order/Filter/Basic.lean
theorem Tendsto.congr' {f₁ f₂ : α → β} {l₁ : Filter α} {l₂ : Filter β} (hl : f₁ =ᶠ[l₁] f₂)
    (h : Tendsto f₁ l₁ l₂) : Tendsto f₂ l₁ l₂
-- Mathlib/NumberTheory/Multiplicity.lean
theorem Int.pow_add_pow {x y : ℤ} (hxy : ↑p ∣ x + y) (hx : ¬↑p ∣ x) {n : ℕ} (hn : Odd n) :
    multiplicity (↑p) (x ^ n + y ^ n) = multiplicity (↑p) (x + y) + multiplicity p n
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp, norm_cast]
theorem coe_prodMap' {D : Type*} [Semiring D] [TopologicalSpace D] [Algebra R D] (f₁ : A →A[R] B)
    (f₂ : C →A[R] D) : ⇑(f₁.prodMap f₂) = Prod.map f₁ f₂
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean
@[simp] lemma logHomeomorph_symm : logHomeomorph.symm = expHomeomorph
-- Mathlib/Order/Monotone/Monovary.lean
@[symm]
protected theorem Monovary.symm (h : Monovary f g) : Monovary g f
-- Mathlib/Topology/Order/Monotone.lean
/-- If an antitone function sending `top` to `bot` is continuous at the indexed infimum over
a `Sort`, then it sends this indexed infimum to the indexed supremum of the composition. -/
theorem Antitone.map_iInf_of_continuousAt {ι : Sort*} {f : α → β} {g : ι → α}
    (Cf : ContinuousAt f (iInf g)) (Af : Antitone f) (ftop : f ⊤ = ⊥) : f (iInf g) = iSup (f ∘ g)
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem bihimp_self : a ⇔ a = ⊤
-- Mathlib/RingTheory/Norm/Basic.lean
theorem prod_embeddings_eq_finrank_pow [Algebra L F] [IsScalarTower K L F] [IsAlgClosed E]
    [Algebra.IsSeparable K F] [FiniteDimensional K F] (pb : PowerBasis K L) :
    ∏ σ : F →ₐ[K] E, σ (algebraMap L F pb.gen) =
      ((@Finset.univ _ (PowerBasis.AlgHom.fintype pb)).prod
        fun σ : L →ₐ[K] E => σ pb.gen) ^ finrank L F
-- Mathlib/LinearAlgebra/SModEq.lean
protected theorem rfl : x ≡ x [SMOD U]
-- Mathlib/Order/Heyting/Regular.lean
theorem isRegular_bot : IsRegular (⊥ : α)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem mem_restrict : J₁ ∈ π.restrict J ↔ ∃ J' ∈ π, (J₁ : WithBot (Box ι)) = ↑J ⊓ ↑J'
-- Mathlib/Dynamics/PeriodicPts.lean
theorem iterate_injOn_Iio_minimalPeriod : (Iio <| minimalPeriod f x).InjOn (f^[·] x)
-- Mathlib/Data/NNRat/Defs.lean
@[simp] lemma num_pow (q : ℚ≥0) (n : ℕ) : (q ^ n).num = q.num ^ n
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem orderIsoMapComap_symm_apply' (e : M ≃ₛₗ[τ₁₂] M₂) (p : Submodule R₂ M₂) :
    (orderIsoMapComap e).symm p = map e.symm p
-- Mathlib/GroupTheory/Abelianization.lean
@[simp]
theorem lift_of : lift of = MonoidHom.id (Abelianization G)
-- Mathlib/CategoryTheory/Limits/Opposites.lean
/-- Turn a limit of `F : J ⥤ Cᵒᵖ` into a colimit of `F.leftOp : Jᵒᵖ ⥤ C`. -/
@[simps]
def isColimitCoconeLeftOpOfCone (F : J ⥤ Cᵒᵖ) {c : Cone F} (hc : IsLimit c) :
    IsColimit (coconeLeftOpOfCone c)
-- Mathlib/Combinatorics/Colex.lean
lemma lt_iff_max'_mem {s t : Colex α} :
    s < t ↔ ∃ h : s ≠ t, (ofColex s ∆ ofColex t).max' (max_mem_aux h) ∈ ofColex t
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem sshiftRight_eq {x : BitVec n} {i : Nat} :
    x.sshiftRight i = BitVec.ofInt n (x.toInt >>> i)
-- Mathlib/GroupTheory/CoprodI.lean
theorem rcons_eq_smul {i} (p : Pair M i) :
    rcons p = of p.head • p.tail
-- Mathlib/Topology/Category/Stonean/Limits.lean
@[reassoc (attr := simp)]
lemma pullback.lift_fst {W : Stonean} (a : W ⟶ X) (b : W ⟶ Y) (w : a ≫ f = b ≫ i) :
    pullback.lift f hi a b w ≫ pullback.fst f hi = a
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem map_id (p : G.Walk u v) : p.map Hom.id = p
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
theorem det_ne_zero [Nontrivial R] (g : SpecialLinearGroup n R) : det ↑ₘg ≠ 0
-- Mathlib/AlgebraicGeometry/Restrict.lean
theorem Scheme.restrictFunctor_map_base {U V : X.Opens} (i : U ⟶ V) :
    (X.restrictFunctor.map i).1.val.base = (Opens.toTopCat _).map i
-- Mathlib/Combinatorics/Additive/ErdosGinzburgZiv.lean
private lemma totalDegree_f₁_add_totalDegree_f₂ {a : ι → ZMod p} :
    (f₁ s a).totalDegree + (f₂ s a).totalDegree < 2 * p - 1
-- Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean
@[simp]
theorem toExterior_ι (m : M) :
    TensorAlgebra.toExterior (TensorAlgebra.ι R m) = ExteriorAlgebra.ι R m
-- Mathlib/CategoryTheory/Triangulated/Functor.lean
lemma isTriangulated_of_precomp
    [(F ⋙ G).IsTriangulated] [F.IsTriangulated] [F.mapArrow.EssSurj] :
    G.IsTriangulated
-- Mathlib/Data/Real/Archimedean.lean
theorem sSup_of_not_bddAbove {s : Set ℝ} (hs : ¬BddAbove s) : sSup s = 0
-- Mathlib/Data/Set/Subsingleton.lean
theorem nontrivial_of_mem_mem_ne {x y} (hx : x ∈ s) (hy : y ∈ s) (hxy : x ≠ y) : s.Nontrivial
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem natDegree_C_mul (a0 : a ≠ 0) : (C a * p).natDegree = p.natDegree
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem monomial_mul_X_pow (n : ℕ) (r : R) (k : ℕ) :
    monomial n r * X ^ k = monomial (n + k) r
-- Mathlib/Topology/Order/Basic.lean
theorem lt_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 b, a < x
-- Mathlib/Algebra/GroupWithZero/Basic.lean
theorem right_ne_zero_of_mul_eq_one (h : a * b = 1) : b ≠ 0
-- Mathlib/Data/Multiset/Basic.lean
theorem coe_foldr_swap (f : α → β → β) (H : LeftCommutative f) (b : β) (l : List α) :
    foldr f H b l = l.foldl (fun x y => f y x) b
-- Mathlib/RingTheory/LaurentSeries.lean
@[simp, norm_cast]
theorem coe_pow (n : ℕ) : ((f ^ n : RatFunc F) : LaurentSeries F) = (f : LaurentSeries F) ^ n
-- Mathlib/Order/Basic.lean
theorem lt_of_eq_of_lt' : b = c → a < b → a < c
-- Mathlib/LinearAlgebra/CliffordAlgebra/Fold.lean
@[simp]
theorem foldr_reverse (f : M →ₗ[R] N →ₗ[R] N) (hf) (n : N) (x : CliffordAlgebra Q) :
    foldr Q f hf n (reverse x) = foldl Q f hf n x
-- Mathlib/Analysis/Analytic/Composition.lean
theorem length_gather (a : Composition n) (b : Composition a.length) :
    length (a.gather b) = b.length
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.natCast_atTop {R : Type*} [StrictOrderedSemiring R] [Archimedean R]
    {f : R → E} {g : R → F} (h : f =O[atTop] g) :
    (fun (n : ℕ) => f n) =O[atTop] (fun n => g n)
-- Mathlib/Data/Finset/Image.lean
theorem image_union [DecidableEq α] {f : α → β} (s₁ s₂ : Finset α) :
    (s₁ ∪ s₂).image f = s₁.image f ∪ s₂.image f
-- Mathlib/Computability/Primrec.lean
theorem nat_rec {f : α → β} {g : α → ℕ × β → β} (hf : Primrec f) (hg : Primrec₂ g) :
    Primrec₂ fun a (n : ℕ) => n.rec (motive := fun _ => β) (f a) fun n IH => g a (n, IH)
-- Mathlib/Probability/ProbabilityMassFunction/Binomial.lean
theorem binomial_apply (p : ℝ≥0∞) (h : p ≤ 1) (n : ℕ) (i : Fin (n + 1)) :
    binomial p h n i = p^(i : ℕ) * (1-p)^((Fin.last n - i) : ℕ) * (n.choose i : ℕ)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem equiv_iff {t₁ t₂ : Ordnode α} (h₁ : Sized t₁) (h₂ : Sized t₂) :
    Equiv t₁ t₂ ↔ toList t₁ = toList t₂
-- Mathlib/Order/LiminfLimsup.lean
@[simp]
theorem blimsup_true (f : Filter β) (u : β → α) : (blimsup u f fun _ => True) = limsup u f
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_sub' {f g : α → ℝ≥0∞} (hg : AEMeasurable g μ) (hg_fin : ∫⁻ a, g a ∂μ ≠ ∞)
    (h_le : g ≤ᵐ[μ] f) : ∫⁻ a, f a - g a ∂μ = ∫⁻ a, f a ∂μ - ∫⁻ a, g a ∂μ
-- Mathlib/Computability/EpsilonNFA.lean
@[simp]
theorem step_zero (s a) : (0 : εNFA α σ).step s a = ∅
-- Mathlib/Data/Finset/NoncommProd.lean
@[simp]
theorem noncommFoldr_empty (h) (b : β) : noncommFoldr f (0 : Multiset α) h b = b
-- Mathlib/NumberTheory/LSeries/Convolution.lean
/-- The L-series of the (convolution) product of two `ℂ`-valued arithmetic functions `f` and `g`
equals the product of their L-series in their common half-plane of absolute convergence. -/
lemma LSeries_mul {f g : ArithmeticFunction ℂ} {s : ℂ}
    (hf : abscissaOfAbsConv ↗f < s.re) (hg : abscissaOfAbsConv ↗g < s.re) :
    LSeries ↗(f * g) s = LSeries ↗f s * LSeries ↗g s
-- Mathlib/Logic/Function/Basic.lean
/-- A binary injective function is injective when only the right argument varies. -/
protected theorem right (hf : Injective2 f) (a : α) : Function.Injective (f a)
-- Mathlib/CategoryTheory/FiberedCategory/BasedCategory.lean
/-- The identity natural transformation is a `BasedNatTrans`. -/
@[simps]
def id (F : 𝒳 ⥤ᵇ 𝒴) : BasedNatTrans F F
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem single_blocksFun {n : ℕ} (h : 0 < n) (i : Fin (single n h).length) :
    (single n h).blocksFun i = n
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean
@[simp]
theorem explicitCokernelπ_desc_apply {X Y Z : SemiNormedGrp.{u}} {f : X ⟶ Y} {g : Y ⟶ Z}
    {cond : f ≫ g = 0} (x : Y) : explicitCokernelDesc cond (explicitCokernelπ f x) = g x
-- Mathlib/CategoryTheory/EssentiallySmall.lean
/--
A thin category is essentially small if and only if the underlying type of its skeleton is small.
-/
theorem essentiallySmall_iff_of_thin {C : Type u} [Category.{v} C] [Quiver.IsThin C] :
    EssentiallySmall.{w} C ↔ Small.{w} (Skeleton C)
-- Mathlib/Data/List/Pi.lean
lemma _root_.Multiset.pi_coe (l : List ι) (fs : ∀ i, List (α i)) :
    (l : Multiset ι).pi (fs ·) = (↑(pi l fs) : Multiset (∀ i ∈ l, α i))
-- Mathlib/Data/Finset/NAry.lean
lemma inf'_image₂_right (g : γ → δ) (h : (image₂ f s t).Nonempty) :
    inf' (image₂ f s t) h g =
      inf' t h.of_image₂_right fun y ↦ inf' s h.of_image₂_left (g <| f · y)
-- Mathlib/Data/Rat/Cast/Order.lean
@[mono]
theorem cast_strictMono : StrictMono ((↑) : ℚ → K)
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/FDeriv.lean
theorem image_mem_toPartialHomeomorph_target (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    f a ∈ (hf.toPartialHomeomorph f).target
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
protected theorem _root_.Disjoint.aedisjoint (h : Disjoint s t) : AEDisjoint μ s t
-- Mathlib/Topology/MetricSpace/PiNat.lean
theorem mem_cylinder_iff_eq {x y : ∀ n, E n} {n : ℕ} :
    y ∈ cylinder x n ↔ cylinder y n = cylinder x n
-- Mathlib/RingTheory/DedekindDomain/FiniteAdeleRing.lean
@[simp]
lemma ProdAdicCompletions.algebraMap_apply (r : R) :
    algebraMap R (K_hat R K) r v = (algebraMap R K r : v.adicCompletion K)
-- Mathlib/Data/Sign.lean
@[simp]
theorem coe_one : ↑(1 : SignType) = (1 : α)
-- Mathlib/Data/Int/Defs.lean
protected lemma one_nonneg : 0 ≤ (1 : ℤ)
-- Mathlib/SetTheory/Game/Domineering.lean
theorem card_of_mem_right {b : Board} {m : ℤ × ℤ} (h : m ∈ right b) : 2 ≤ Finset.card b
-- Mathlib/Algebra/AddTorsor.lean
theorem vsub_sub_vsub_comm (p₁ p₂ p₃ p₄ : P) : p₁ -ᵥ p₂ - (p₃ -ᵥ p₄) = p₁ -ᵥ p₃ - (p₂ -ᵥ p₄)
-- Mathlib/Logic/Function/Basic.lean
/-- A relation `r : α → β → Prop` is "function-like"
(for each `a` there exists a unique `b` such that `r a b`)
if and only if it is `(f · = ·)` for some function `f`. -/
lemma forall_existsUnique_iff {r : α → β → Prop} :
    (∀ a, ∃! b, r a b) ↔ ∃ f : α → β, ∀ {a b}, r a b ↔ f a = b
-- Mathlib/Data/Finset/Pointwise.lean
@[simp]
theorem smul_finset_neg : a • -t = -(a • t)
-- Mathlib/Algebra/Order/Module/Defs.lean
lemma PosSMulReflectLE.lift [PosSMulReflectLE α γ]
    (hf : ∀ {b₁ b₂}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂)
    (smul : ∀ (a : α) b, f (a • b) = a • f b) : PosSMulReflectLE α β
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
@[simp]
theorem setToL1_zero_left (hT : DominatedFinMeasAdditive μ (0 : Set α → E →L[ℝ] F) C)
    (f : α →₁[μ] E) : setToL1 hT f = 0
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem dvd_count_of_dvd_count_mul [DecidableEq (Associates α)] {a b : Associates α} (hb : b ≠ 0)
    {p : Associates α} (hp : Irreducible p) (hab : ∀ d, d ∣ a → d ∣ b → ¬Prime d) {k : ℕ}
    (habk : k ∣ count p (a * b).factors) : k ∣ count p a.factors
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.real_toNNReal {f : α → ℝ} (hf : Integrable f μ) :
    Integrable (fun x => ((f x).toNNReal : ℝ)) μ
-- Mathlib/Topology/Sets/Opens.lean
@[ext] -- Porting note (#11215): TODO: replace with `∀ x, x ∈ U ↔ x ∈ V`
theorem ext {U V : Opens α} (h : (U : Set α) = V) : U = V
-- Mathlib/CategoryTheory/Category/Bipointed.lean
@[simp]
theorem pointedToBipointedSnd_comp_swap :
    pointedToBipointedSnd ⋙ Bipointed.swap = pointedToBipointedFst
-- Mathlib/Data/Sigma/Order.lean
@[simp]
theorem mk_lt_mk_iff [∀ i, LT (α i)] {i : ι} {a b : α i} : (⟨i, a⟩ : Sigma α) < ⟨i, b⟩ ↔ a < b
-- Mathlib/Topology/Inseparable.lean
lemma stableUnderGeneralization_sInter (S : Set (Set X))
    (H : ∀ s ∈ S, StableUnderGeneralization s) : StableUnderGeneralization (⋂₀ S)
-- Mathlib/Logic/Encodable/Lattice.lean
theorem iSup_decode₂ [CompleteLattice α] (f : β → α) :
    ⨆ (i : ℕ) (b ∈ decode₂ β i), f b = (⨆ b, f b)
-- Mathlib/CategoryTheory/Idempotents/Karoubi.lean
theorem decomp_p (P : Karoubi C) : (toKaroubi C).map P.p = decompId_p P ≫ decompId_i P
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
theorem rightUnitor_inv_hom {X : Action V G} : Hom.hom (ρ_ X).inv = (ρ_ X.V).inv
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem comp_add [ContinuousAdd M₂] [ContinuousAdd M₃] (g : M₂ →SL[σ₂₃] M₃)
    (f₁ f₂ : M₁ →SL[σ₁₂] M₂) : g.comp (f₁ + f₂) = g.comp f₁ + g.comp f₂
-- .lake/packages/lean4/src/lean/Init/Data/AC.lean
theorem Context.evalList_append
  (ctx : Context α)
  (l r : List Nat)
  (h₁ : l ≠ [])
  (h₂ : r ≠ [])
  : evalList α ctx (l.append r) = ctx.op (evalList α ctx l) (evalList α ctx r)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivAtFilter.add (hf : HasDerivAtFilter f f' x L)
    (hg : HasDerivAtFilter g g' x L) : HasDerivAtFilter (fun y => f y + g y) (f' + g') x L
-- Mathlib/Topology/MetricSpace/Basic.lean
theorem subsingleton_closedBall (x : γ) {r : ℝ} (hr : r ≤ 0) : (closedBall x r).Subsingleton
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem neg_neg {X Y : C} (a : X ⟶ Y) : - -a = a
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem fundamentalDomain_subset_parallelepiped [Fintype ι] :
    fundamentalDomain b ⊆ parallelepiped b
-- Mathlib/Combinatorics/SimpleGraph/Coloring.lean
theorem isEmpty_of_colorable_zero (h : G.Colorable 0) : IsEmpty V
-- Mathlib/Algebra/GeomSum.lean
theorem one_sub_dvd_one_sub_pow [Ring α] (x : α) (n : ℕ) :
    1 - x ∣ 1 - x ^ n
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem sumLexAssoc_symm_apply_inr_inl : (sumLexAssoc α β γ).symm (inr (inl b)) = inl (inr b)
-- Mathlib/Data/Real/Basic.lean
private irreducible_def neg : ℝ → ℝ
-- Mathlib/Algebra/Ring/Int.lean
lemma even_or_odd (n : ℤ) : Even n ∨ Odd n
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem quasiconcaveOn_iff_min_le : QuasiconcaveOn 𝕜 s f ↔ Convex 𝕜 s ∧ ∀ ⦃x⦄, x ∈ s → ∀ ⦃y⦄,
    y ∈ s → ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → min (f x) (f y) ≤ f (a • x + b • y)
-- Mathlib/Order/Interval/Set/OrdConnected.lean
protected theorem Icc_subset (s : Set α) [hs : OrdConnected s] {x y} (hx : x ∈ s) (hy : y ∈ s) :
    Icc x y ⊆ s
-- Mathlib/CategoryTheory/Bicategory/Functor/Prelax.lean
@[simp]
lemma mkOfHomFunctors_mapFunctor (F : B → C) (F' : (a : B) → (b : B) → (a ⟶ b) ⥤ (F a ⟶ F b))
    (a b : B) : (mkOfHomFunctors F F').mapFunctor a b = F' a b
-- Mathlib/Order/Bounded.lean
theorem bounded_lt_inter_lt [LinearOrder α] [NoMaxOrder α] (a : α) :
    Bounded (· < ·) (s ∩ { b | a < b }) ↔ Bounded (· < ·) s
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem comap_le_comap_iff_of_surjective (p q : Submodule R₂ M₂) : p.comap f ≤ q.comap f ↔ p ≤ q
-- Mathlib/Algebra/Homology/ImageToKernel.lean
theorem imageToKernel_zero_right [HasImages V] {w} :
    imageToKernel f (0 : B ⟶ C) w =
      (imageSubobject f).arrow ≫ inv (kernelSubobject (0 : B ⟶ C)).arrow
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem mul_im (z w : ℂ) : (z * w).im = z.re * w.im + z.im * w.re
-- Mathlib/Algebra/Group/Hom/End.lean
lemma mulRight_eq_mulLeft : mulRight = (mulLeft : R →+ AddMonoid.End R)
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
lemma isAtom_top : IsAtom (⊤ : LieIdeal R L)
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
/-- Uniqueness property of `BoxIntegral.Prepartition.biUnionIndex`. -/
theorem biUnionIndex_of_mem (hJ : J ∈ π) {J'} (hJ' : J' ∈ πi J) : π.biUnionIndex πi J' = J
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem mul_rpow_of_nonneg (x y : ℝ≥0∞) {z : ℝ} (hz : 0 ≤ z) : (x * y) ^ z = x ^ z * y ^ z
-- Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean
/-- When `R` is a field `F`, then a nontrivial additive character is primitive -/
theorem IsPrimitive.of_ne_one {F : Type u} [Field F] {ψ : AddChar F R'} (hψ : ψ ≠ 1) :
    IsPrimitive ψ
-- Mathlib/LinearAlgebra/Alternating/DomCoprod.lean
/-- A helper lemma for `MultilinearMap.domCoprod_alternization`. -/
theorem MultilinearMap.domCoprod_alternization_coe [DecidableEq ιa] [DecidableEq ιb]
    (a : MultilinearMap R' (fun _ : ιa => Mᵢ) N₁) (b : MultilinearMap R' (fun _ : ιb => Mᵢ) N₂) :
    MultilinearMap.domCoprod (MultilinearMap.alternatization a)
      (MultilinearMap.alternatization b) =
      ∑ σa : Perm ιa, ∑ σb : Perm ιb,
        Equiv.Perm.sign σa • Equiv.Perm.sign σb •
          MultilinearMap.domCoprod (a.domDomCongr σa) (b.domDomCongr σb)
-- Mathlib/Data/Multiset/Basic.lean
theorem card_pos {s : Multiset α} : 0 < card s ↔ s ≠ 0
-- Mathlib/Data/Multiset/Basic.lean
theorem rel_refl_of_refl_on {m : Multiset α} {r : α → α → Prop} : (∀ x ∈ m, r x x) → Rel r m m
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
@[simp]
theorem cthickening_cthickening (hε : 0 ≤ ε) (hδ : 0 ≤ δ) (s : Set E) :
    cthickening ε (cthickening δ s) = cthickening (ε + δ) s
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem Ioc_subset_Ioo_right (h : b₁ < b₂) : Ioc a b₁ ⊆ Ioo a b₂
-- Mathlib/LinearAlgebra/Trace.lean
theorem trace_comp_comm :
    compr₂ (llcomp R M N M) (trace R M) = compr₂ (llcomp R N M N).flip (trace R N)
-- Mathlib/Data/List/AList.lean
@[simp]
theorem empty_entries : (∅ : AList β).entries = []
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
@[simp]
theorem reverse_reverse [h : HasInvolutiveReverse V] {a b : V} (f : a ⟶ b) :
    reverse (reverse f) = f
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iic_union_Ici : Iic a ∪ Ici a = univ
-- Mathlib/Logic/Relation.lean
@[elab_as_elim]
theorem head_induction_on {P : ∀ a : α, TransGen r a b → Prop} {a : α} (h : TransGen r a b)
    (base : ∀ {a} (h : r a b), P a (single h))
    (ih : ∀ {a c} (h' : r a c) (h : TransGen r c b), P c h → P a (h.head h')) : P a h
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma stieltjesOfMeasurableRat_le_one (hf : Measurable f) (a : α) (x : ℝ) :
    stieltjesOfMeasurableRat f hf a x ≤ 1
-- Mathlib/Probability/Martingale/Basic.lean
protected theorem pos {f : ι → Ω → ℝ} (hf : Submartingale f ℱ μ) : Submartingale (f⁺) ℱ μ
-- Mathlib/Order/Interval/Set/OrdConnectedComponent.lean
theorem mem_ordConnectedComponent_ordConnectedProj (s : Set α) (x : s) :
    ↑x ∈ ordConnectedComponent s (ordConnectedProj s x)
-- Mathlib/Data/Set/Image.lean
theorem mem_compl_image [BooleanAlgebra α] (t : α) (S : Set α) :
    t ∈ HasCompl.compl '' S ↔ tᶜ ∈ S
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
/-- The function `x * log (1 + t / x)` tends to `t` at `+∞`. -/
theorem tendsto_mul_log_one_plus_div_atTop (t : ℝ) :
    Tendsto (fun x => x * log (1 + t / x)) atTop (𝓝 t)
-- Mathlib/Analysis/Calculus/TangentCone.lean
theorem UniqueDiffWithinAt.congr_pt (h : UniqueDiffWithinAt 𝕜 s x) (hy : x = y) :
    UniqueDiffWithinAt 𝕜 s y
-- Mathlib/Data/Matrix/Basic.lean
protected theorem map_ofNat [AddMonoidWithOne α] [AddMonoidWithOne β]
    {f : α → β} (h : f 0 = 0) (d : ℕ) [d.AtLeastTwo] :
    (no_index (OfNat.ofNat d) : Matrix n n α).map f = diagonal (fun _ => f (OfNat.ofNat d))
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem dual_top : dual (⊤ : NonemptyInterval α) = ⊤
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
theorem chain_adj_support {u v w : V} (h : G.Adj u v) :
    ∀ (p : G.Walk v w), List.Chain G.Adj u p.support
-- Mathlib/Algebra/Polynomial/Induction.lean
/-- If the coefficients of a polynomial belong to an ideal, then that ideal contains
the ideal spanned by the coefficients of the polynomial. -/
theorem span_le_of_C_coeff_mem (cf : ∀ i : ℕ, C (f.coeff i) ∈ I) :
    Ideal.span { g | ∃ i, g = C (f.coeff i) } ≤ I
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp, norm_cast]
theorem mem_coe : x ∈ (I : Set (ι → ℝ)) ↔ x ∈ I
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
theorem imCLM_apply (z : ℂ) : (imCLM : ℂ → ℝ) z = z.im
-- Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean
nonrec theorem ContMDiffOn.clm_postcomp {f : M → F₂ →L[𝕜] F₃} {s : Set M}
    (hf : ContMDiffOn I 𝓘(𝕜, F₂ →L[𝕜] F₃) n f s) :
    ContMDiffOn I 𝓘(𝕜, (F₁ →L[𝕜] F₂) →L[𝕜] (F₁ →L[𝕜] F₃)) n
      (fun y ↦ (f y).postcomp F₁ : M → (F₁ →L[𝕜] F₂) →L[𝕜] (F₁ →L[𝕜] F₃)) s
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- A geometric series in a normed field is summable iff the norm of the common ratio is less than
one. -/
@[simp]
theorem summable_geometric_iff_norm_lt_one : (Summable fun n : ℕ ↦ ξ ^ n) ↔ ‖ξ‖ < 1