ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/batteries/Batteries/Control/ForInStep/Lemmas.lean
@[simp] theorem ForInStep.bind_yield_bindList [Monad m]
    (f : α → β → m (ForInStep β)) (s : ForInStep β) (l) :
    (s.bind fun a => (yield a).bindList f l) = s.bindList f l
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem neg_mem (h : A ∈ symplecticGroup l R) : -A ∈ symplecticGroup l R
-- Mathlib/Algebra/Category/Ring/Basic.lean
lemma ext {X Y : CommRingCat} {f g : X ⟶ Y} (w : ∀ x : X, f x = g x) : f = g
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem leftOp_id : NatTrans.leftOp (𝟙 F : F ⟶ F) = 𝟙 F.leftOp
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Ioc (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c)
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem inv_comp_eq (α : X ⟶ Y) [IsIso α] {f : X ⟶ Z} {g : Y ⟶ Z} : inv α ≫ f = g ↔ f = α ≫ g
-- Mathlib/RingTheory/Filtration.lean
/-- The trivial stable `I`-filtration of `N`. -/
@[simps]
def _root_.Ideal.stableFiltration (I : Ideal R) (N : Submodule R M) : I.Filtration M
-- Mathlib/Data/Real/EReal.lean
theorem natCast_ne_bot (n : ℕ) : (n : EReal) ≠ ⊥
-- Mathlib/SetTheory/Game/Basic.lean
/-- `x * 0` is equivalent to `0`. -/
theorem mul_zero_equiv (x : PGame) : x * 0 ≈ 0
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
/-- Compatible families of elements for a presheaf of types `P` and a presieve `R`
    are in 1-1 correspondence with compatible families for the same presheaf and
    the sieve generated by `R`, through extension and restriction. -/
@[simps]
noncomputable def compatibleEquivGenerateSieveCompatible :
    { x : FamilyOfElements P R // x.Compatible } ≃
      { x : FamilyOfElements P (generate R : Presieve X) // x.Compatible }
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp] protected theorem zero : IsSelfAdjoint (0 : R)
-- Mathlib/Data/Set/Lattice.lean
theorem biInter_image : ⋂ x ∈ f '' s, g x = ⋂ y ∈ s, g (f y)
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Fundamental theorem of calculus: if `f : ℝ → E` is integrable on `a..b` and `f` is continuous
at `b`, then the derivative of `u ↦ ∫ x in a..u, f x` at `b` equals `f b`. -/
theorem deriv_integral_right (hf : IntervalIntegrable f volume a b)
    (hmeas : StronglyMeasurableAtFilter f (𝓝 b)) (hb : ContinuousAt f b) :
    deriv (fun u => ∫ x in a..u, f x) b = f b
-- Mathlib/RingTheory/MatrixAlgebra.lean
@[simp]
theorem matrixEquivTensor_apply_symm (a : A) (M : Matrix n n R) :
    (matrixEquivTensor R A n).symm (a ⊗ₜ M) = M.map fun x => a * algebraMap R A x
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem norm_of_mem_sphere {x : Fin n → ℕ} (hx : x ∈ sphere n d k) :
    ‖(WithLp.equiv 2 _).symm ((↑) ∘ x : Fin n → ℝ)‖ = √↑k
-- Mathlib/Order/Sublattice.lean
@[simp] lemma comap_id (L : Sublattice α) : L.comap (LatticeHom.id _) = L
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- Two morphisms out of a universal `T`-structured arrow are equal if their image under `T` are
equal after precomposing the universal arrow. -/
theorem hom_ext (h : IsUniversal f) {c : C} {η η' : f.right ⟶ c}
    (w : f.hom ≫ T.map η = f.hom ≫ T.map η') : η = η'
-- Mathlib/Algebra/DirectSum/Internal.lean
theorem coe_of_mul_apply {i : ι} (r : A i) (r' : ⨁ i, A i) (n : ι) [Decidable (i ≤ n)] :
    ((of (fun i => A i) i r * r') n : R) = if i ≤ n then (r * r' (n - i) : R) else 0
-- Mathlib/Topology/Hom/Open.lean
@[simp]
theorem cancel_left {g : β →CO γ} {f₁ f₂ : α →CO β} (hg : Injective g) :
    g.comp f₁ = g.comp f₂ ↔ f₁ = f₂
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem sumCoords_reindex : (b.reindex e).sumCoords = b.sumCoords
-- Mathlib/Algebra/Group/AddChar.lean
lemma eq_one_iff : ψ = 1 ↔ ∀ x, ψ x = 1
-- Mathlib/Data/Finsupp/Basic.lean
theorem mem_frange {f : α →₀ M} {y : M} : y ∈ f.frange ↔ y ≠ 0 ∧ ∃ x, f x = y
-- Mathlib/GroupTheory/Perm/Sign.lean
theorem signAux_swap : ∀ {n : ℕ} {x y : Fin n} (_hxy : x ≠ y), signAux (swap x y) = -1
-- Mathlib/Topology/FiberBundle/Basic.lean
/-- The inclusion of a fiber into the total space is a continuous map. -/
@[continuity]
theorem continuous_totalSpaceMk (b : B) :
    Continuous (TotalSpace.mk b : Z.Fiber b → Bundle.TotalSpace F Z.Fiber)
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/PullbackCone.lean
/-- To check whether two morphisms are equalized by the maps of a pullback cone, it suffices to
check it for `fst t` and `snd t` -/
theorem equalizer_ext (t : PullbackCone f g) {W : C} {k l : W ⟶ t.pt} (h₀ : k ≫ fst t = l ≫ fst t)
    (h₁ : k ≫ snd t = l ≫ snd t) : ∀ j : WalkingCospan, k ≫ t.π.app j = l ≫ t.π.app j
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem gcd_isUnit_iff_isRelPrime [GCDMonoid α] {a b : α} :
    IsUnit (gcd a b) ↔ IsRelPrime a b
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean
theorem condexpIndSMul_smul (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : ℝ) (x : G) :
    condexpIndSMul hm hs hμs (c • x) = c • condexpIndSMul hm hs hμs x
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_pair (x y : α) : formPerm [x, y] = swap x y
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
theorem foldr_loop_zero (f : Fin n → α → α) (x) : foldr.loop n f ⟨0, Nat.zero_le _⟩ x = x
-- Mathlib/NumberTheory/Zsqrtd/QuadraticReciprocity.lean
theorem prime_of_nat_prime_of_mod_four_eq_three (p : ℕ) [hp : Fact p.Prime] (hp3 : p % 4 = 3) :
    Prime (p : ℤ[i])
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
theorem eqId_iff_len_le : A.EqId ↔ Δ.unop.len ≤ A.1.unop.len
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
@[simp]
theorem eLpNorm_exponent_zero {f : α → F} : eLpNorm f 0 μ = 0
-- Mathlib/Data/Fintype/Sum.lean
@[simp]
theorem Fintype.card_sum [Fintype α] [Fintype β] :
    Fintype.card (α ⊕ β) = Fintype.card α + Fintype.card β
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metrizable.lean
/-- A limit (over a general filter) of measurable functions valued in a (pseudo) metrizable space is
measurable. -/
theorem measurable_of_tendsto_metrizable' {ι} {f : ι → α → β} {g : α → β} (u : Filter ι) [NeBot u]
    [IsCountablyGenerated u] (hf : ∀ i, Measurable (f i)) (lim : Tendsto f u (𝓝 g)) :
    Measurable g
-- Mathlib/Order/Filter/Prod.lean
@[simp]
theorem prod_eq_bot : f ×ˢ g = ⊥ ↔ f = ⊥ ∨ g = ⊥
-- Mathlib/Topology/FiberBundle/Basic.lean
theorem mem_localTrivAsPartialEquiv_target (p : B × F) :
    p ∈ (Z.localTrivAsPartialEquiv i).target ↔ p.1 ∈ Z.baseSet i
-- Mathlib/LinearAlgebra/AnnihilatingPolynomial.lean
/-- It is useful to refer to ideal membership sometimes
 and the annihilation condition other times. -/
theorem mem_annIdeal_iff_aeval_eq_zero {a : A} {p : R[X]} : p ∈ annIdeal R a ↔ aeval a p = 0
-- Mathlib/CategoryTheory/Idempotents/Karoubi.lean
theorem coe_X (X : C) : (X : Karoubi C).X = X
-- Mathlib/CategoryTheory/Limits/Filtered.lean
/-- Class for having all cofiltered limits of a given size. -/
@[pp_with_univ]
class HasCofilteredLimitsOfSize : Prop where
  /-- For all filtered types of size `w`, we have limits -/
  HasLimitsOfShape : ∀ (I : Type w) [Category.{w'} I] [IsCofiltered I], HasLimitsOfShape I C
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem absolutelyContinuous_map_mul_right (g : G) : μ ≪ map (· * g) μ
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
/-- Given two model_with_corners `I` on `(E, H)` and `I'` on `(E', H')`, we define the model with
corners `I.prod I'` on `(E × E', ModelProd H H')`. This appears in particular for the manifold
structure on the tangent bundle to a manifold modelled on `(E, H)`: it will be modelled on
`(E × E, H × E)`. See note [Manifold type tags] for explanation about `ModelProd H H'`
vs `H × H'`. -/
@[simps (config := .lemmasOnly)]
def ModelWithCorners.prod {𝕜 : Type u} [NontriviallyNormedField 𝕜] {E : Type v}
    [NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type w} [TopologicalSpace H]
    (I : ModelWithCorners 𝕜 E H) {E' : Type v'} [NormedAddCommGroup E'] [NormedSpace 𝕜 E']
    {H' : Type w'} [TopologicalSpace H'] (I' : ModelWithCorners 𝕜 E' H') :
    ModelWithCorners 𝕜 (E × E') (ModelProd H H')
-- Mathlib/Combinatorics/SimpleGraph/Turan.lean
theorem turanGraph_cliqueFree : (turanGraph n r).CliqueFree (r + 1)
-- Mathlib/RingTheory/Adjoin/PowerBasis.lean
/-- Let `B : PowerBasis S A` be such that `IsIntegral R B.gen`, and let `x y : A` be elements with
integral coordinates in the base `B.basis`. Then `IsIntegral R ((B.basis.repr (x * y) i)` for all
`i` if `minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)`. This is the case if `R` is a GCD
domain and `S` is its fraction ring. -/
theorem repr_mul_isIntegral [IsDomain S] {x y : A} (hx : ∀ i, IsIntegral R (B.basis.repr x i))
    (hy : ∀ i, IsIntegral R (B.basis.repr y i))
    (hmin : minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)) :
    ∀ i, IsIntegral R (B.basis.repr (x * y) i)
-- Mathlib/MeasureTheory/Measure/Haar/Unique.lean
/-- An invariant σ-finite measure is absolutely continuous with respect to a Haar measure in a
second countable group. -/
@[to_additive
"An invariant measure is absolutely continuous with respect to an additive Haar measure. "]
theorem absolutelyContinuous_isHaarMeasure [LocallyCompactSpace G]
    [SecondCountableTopology G] (μ ν : Measure G)
    [SigmaFinite μ] [IsMulLeftInvariant μ] [IsHaarMeasure ν] : μ ≪ ν
-- Mathlib/Algebra/Lie/Weights/Chain.lean
@[simp] lemma chainBotCoeff_zero : chainBotCoeff 0 β = 0
-- Mathlib/SetTheory/Game/Nim.lean
theorem nim_def (o : Ordinal) :
    have : IsWellOrder (Quotient.out o).α (· < ·) := inferInstance
    nim o =
      PGame.mk o.out.α o.out.α (fun o₂ => nim (Ordinal.typein (· < ·) o₂)) fun o₂ =>
        nim (Ordinal.typein (· < ·) o₂)
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
lemma nullHomotopicMap_eq : nullHomotopicMap K = π K ≫ ι₀ K - 𝟙 _
-- Mathlib/Topology/UniformSpace/Equiv.lean
@[simp]
theorem symm_apply_apply (h : α ≃ᵤ β) (x : α) : h.symm (h x) = x
-- Mathlib/Data/DFinsupp/WellFounded.lean
theorem Pi.Lex.wellFounded [IsStrictTotalOrder ι r] [Finite ι] (hs : ∀ i, WellFounded (s i)) :
    WellFounded (Pi.Lex r (fun {i} ↦ s i))
-- Mathlib/Topology/Constructions.lean
theorem Pi.continuous_postcomp' {X : ι → Type*} [∀ i, TopologicalSpace (X i)]
    {g : ∀ i, π i → X i} (hg : ∀ i, Continuous (g i)) :
    Continuous (fun (f : (∀ i, π i)) (i : ι) ↦ g i (f i))
-- Mathlib/Order/Sublattice.lean
lemma comap_inf (L M : Sublattice β) (f : LatticeHom α β) :
    (L ⊓ M).comap f = L.comap f ⊓ M.comap f
-- Mathlib/Analysis/ODE/PicardLindelof.lean
theorem continuous_vComp : Continuous f.vComp
-- Mathlib/Analysis/Quaternion.lean
@[simp, norm_cast]
theorem summable_coe {f : α → ℝ} : (Summable fun a => (f a : ℍ)) ↔ Summable f
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem beq_nil_cons [BEq α] [BEq β] : ((.nil : AssocList α β) == .cons a b t) = false
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[deprecated Differentiable.sub_iff_right (since := "2024-07-11")]
theorem differentiable_const_sub_iff (c : F) :
    (Differentiable 𝕜 fun y => c - f y) ↔ Differentiable 𝕜 f
-- Mathlib/Data/Subtype.lean
protected theorem ext_iff {a1 a2 : { x // p x }} : a1 = a2 ↔ (a1 : α) = (a2 : α)
-- Mathlib/Order/BooleanAlgebra.lean
theorem Disjoint.sdiff_eq_of_sup_eq (hi : Disjoint x z) (hs : x ⊔ z = y) : y \ x = z
-- Mathlib/MeasureTheory/OuterMeasure/AE.lean
theorem diff_null_ae_eq_self (ht : μ t = 0) : (s \ t : Set α) =ᵐ[μ] s
-- Mathlib/Algebra/Algebra/Hom.lean
lemma algebraMapSubmonoid_le_comap (f : A →ₐ[R] B) :
    algebraMapSubmonoid A M ≤ (algebraMapSubmonoid B M).comap f.toRingHom
-- Mathlib/Data/NNReal/Basic.lean
theorem div_le_of_le_mul' {a b c : ℝ≥0} (h : a ≤ b * c) : a / b ≤ c
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem comap_map_eq (f : R →+* S) (s : Subring R) :
    (s.map f).comap f = s ⊔ closure (f ⁻¹' {0})
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- If two functions `f` and `g` admit Taylor series `p` and `q` in a set `s`, then the cartesian
product of `f` and `g` admits the cartesian product of `p` and `q` as a Taylor series. -/
theorem HasFTaylorSeriesUpToOn.prod (hf : HasFTaylorSeriesUpToOn n f p s) {g : E → G}
    {q : E → FormalMultilinearSeries 𝕜 E G} (hg : HasFTaylorSeriesUpToOn n g q s) :
    HasFTaylorSeriesUpToOn n (fun y => (f y, g y)) (fun y k => (p y k).prod (q y k)) s
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem smul_toProd (s : S) (a : 𝓜(𝕜, A)) : (s • a).toProd = s • a.toProd
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
protected theorem rfl : μ ≪ μ
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] protected theorem sub_zero (x : BitVec n) : x - 0#n = x
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive nnnorm_ne_zero_iff]
theorem nnnorm_ne_zero_iff' : ‖a‖₊ ≠ 0 ↔ a ≠ 1
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem inf_subgroupOf_right (H K : Subgroup G) : (H ⊓ K).subgroupOf K = H.subgroupOf K
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@[simp] theorem LinearMap.id_fgModuleCat_comp
    {R} [Ring R] {G : Type u} [AddCommGroup G] [Module R G] {H : FGModuleCat.{u} R}
    (f : G →ₗ[R] H) : LinearMap.comp (𝟙 H) f = f
-- Mathlib/Algebra/MonoidAlgebra/Division.lean
theorem of'_modOf (g : G) : of' k G g %ᵒᶠ g = 0
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
theorem aeval_algHom (f : A →ₐ[R] B) (x : A) : aeval (f x) = f.comp (aeval x)
-- Mathlib/CategoryTheory/Sites/LocallyInjective.lean
lemma mono_of_injective
    (hφ : ∀ (X : Cᵒᵖ), Function.Injective (φ.val.app X)) : Mono φ
-- Mathlib/Order/WithBot.lean
theorem lt_iff_exists_coe {a b : WithTop α} : a < b ↔ ∃ p : α, a = p ∧ ↑p < b
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem coe_eq_pi : (I : Set (ι → ℝ)) = pi univ fun i ↦ Ioc (I.lower i) (I.upper i)
-- Mathlib/LinearAlgebra/Dimension/Localization.lean
/-- The **rank-nullity theorem** for commutative domains. Also see `rank_quotient_add_rank`. -/
theorem rank_quotient_add_rank_of_isDomain [IsDomain R] (M' : Submodule R M) :
    Module.rank R (M ⧸ M') + Module.rank R M' = Module.rank R M
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem aleph_le_beth (o : Ordinal) : aleph o ≤ beth o
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
/-- The square
```
  X --inl--> X ⊞ Y
  |            |
  0           snd
  |            |
  v            v
  0 ---0-----> Y
```
is a pushout square.
-/
theorem inl_snd (X Y : C) [HasBinaryBiproduct X Y] :
    IsPushout biprod.inl (0 : X ⟶ 0) biprod.snd (0 : 0 ⟶ Y)
-- Mathlib/Data/Quot.lean
theorem sound' {a b : α} : @Setoid.r _ s₁ a b → @Quotient.mk'' α s₁ a = Quotient.mk'' b
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem toTopologicalSpace_sInf {s : Set (UniformSpace α)} :
    (sInf s).toTopologicalSpace = ⨅ i ∈ s, @UniformSpace.toTopologicalSpace α i
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
lemma mem_subgroup_orbit_iff {H : Subgroup G} {x : α} {a b : orbit G x} :
    a ∈ MulAction.orbit H b ↔ (a : α) ∈ MulAction.orbit H (b : α)
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.add_const (hf : ConvexOn 𝕜 s f) (b : β) :
    ConvexOn 𝕜 s (f + fun _ => b)
-- Mathlib/RingTheory/Localization/Basic.lean
@[simp]
theorem mk'_self' {x : M} : mk' S (x : R) x = 1
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
private lemma ofTensorProduct_iso : IsIso (ModuleCat.ofHom (ofTensorProduct I M))
-- Mathlib/Algebra/DirectSum/Basic.lean
lemma of_apply {i : ι} (j : ι) (x : β i) : of β i x j = if h : i = j then Eq.recOn h x else 0
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- Convert a `Bicone` over a function on `WalkingPair` to a BinaryBicone. -/
@[simps]
def toBinaryBiconeFunctor {X Y : C} : Bicone (pairFunction X Y) ⥤ BinaryBicone X Y
-- Mathlib/Data/PNat/Equiv.lean
/-- An equivalence between `ℕ+` and `ℕ` given by `PNat.natPred` and `Nat.succPNat`. -/
@[simps (config := .asFn)]
def _root_.Equiv.pnatEquivNat : ℕ+ ≃ ℕ
-- Mathlib/Algebra/GeomSum.lean
theorem geom_sum_Ico' [DivisionRing α] {x : α} (hx : x ≠ 1) {m n : ℕ} (hmn : m ≤ n) :
    ∑ i ∈ Finset.Ico m n, x ^ i = (x ^ m - x ^ n) / (1 - x)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_fst_zip :
    ∀ (l₁ : List α) (l₂ : List β), l₁.length ≤ l₂.length → map Prod.fst (zip l₁ l₂) = l₁
-- Mathlib/Analysis/SpecialFunctions/Exp.lean
@[simp]
theorem range_exp : range exp = Set.Ioi 0
-- Mathlib/Algebra/Order/Group/Indicator.lean
@[to_additive]
lemma mulIndicator_apply_le' (hfg : a ∈ s → f a ≤ y) (hg : a ∉ s → 1 ≤ y) :
    mulIndicator s f a ≤ y
-- Mathlib/Data/Fin/Basic.lean
theorem pred_castSucc_lt_iff {a b : Fin (n + 1)} (ha : castSucc a ≠ 0) :
    (castSucc a).pred ha < b ↔ a ≤ b
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
theorem toLin'Flip_apply (A : BilinForm R M) (x : M) : toLinHomFlip (M := M) A x = fun y => A y x
-- Mathlib/Algebra/Order/Ring/Cast.lean
lemma cast_one_le_of_pos (h : 0 < a) : (1 : R) ≤ a
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
/-- The map from Lie derivations to linear endormophisms is injective. -/
lemma toLinearMapLieHom_injective : Function.Injective (toLinearMapLieHom R L)
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
lemma fromRows_inj : Function.Injective2 (@fromRows R m₁ m₂ n)
-- Mathlib/Analysis/Convex/Side.lean
theorem not_sOppSide_bot (x y : P) : ¬(⊥ : AffineSubspace R P).SOppSide x y
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem leftMoves_mk {xl xr xL xR} : (⟨xl, xr, xL, xR⟩ : PGame).LeftMoves = xl
-- .lake/packages/lean4/src/lean/Init/SimpLemmas.lean
@[simp] theorem true_and (p : Prop) : (True ∧ p) = p
-- Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
theorem ae_nonneg_of_forall_setIntegral_nonneg_of_sigmaFinite [SigmaFinite μ] {f : α → ℝ}
    (hf_int_finite : ∀ s, MeasurableSet s → μ s < ∞ → IntegrableOn f s μ)
    (hf_zero : ∀ s, MeasurableSet s → μ s < ∞ → 0 ≤ ∫ x in s, f x ∂μ) : 0 ≤ᵐ[μ] f
-- Mathlib/Tactic/PushNeg.lean
theorem not_nonempty_eq (s : Set β) : (¬ s.Nonempty) = (s = ∅)
-- Mathlib/Topology/UniformSpace/CompleteSeparated.lean
theorem UniformEmbedding.toClosedEmbedding [UniformSpace α] [UniformSpace β] [CompleteSpace α]
    [T0Space β] {f : α → β} (hf : UniformEmbedding f) :
    ClosedEmbedding f
-- Mathlib/Algebra/Order/Ring/Rat.lean
@[simp] lemma num_nonpos {a : ℚ} : a.num ≤ 0 ↔ a ≤ 0
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem neg_nil : (- ([] : IntList)) = []
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
@[simp]
theorem flip_separatingRight {B : M₁ →ₛₗ[I₁] M₂ →ₛₗ[I₂] M} :
    B.flip.SeparatingRight ↔ B.SeparatingLeft
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
theorem restrict_prod_eq_prod_univ (s : Set α) :
    (μ.restrict s).prod ν = (μ.prod ν).restrict (s ×ˢ univ)
-- Mathlib/FieldTheory/Adjoin.lean
/-- `minpoly.algEquiv` sends the generator of `K⟮x⟯` to the generator of `K⟮y⟯`. -/
theorem algEquiv_apply {x y : L} (hx : IsAlgebraic K x) (h_mp : minpoly K x = minpoly K y) :
    algEquiv hx h_mp (AdjoinSimple.gen K x) = AdjoinSimple.gen K y
-- Mathlib/Data/Multiset/Dedup.lean
theorem Subset.dedup_add_right {s t : Multiset α} (h : s ⊆ t) :
    dedup (s + t) = dedup t
-- Mathlib/RingTheory/Localization/LocalizationLocalization.lean
/-- If `M ≤ N` are submonoids of `R`, then the natural map `M⁻¹S →+* N⁻¹S` commutes with the
localization maps -/
theorem localization_isScalarTower_of_submonoid_le (M N : Submonoid R) (h : M ≤ N)
    [IsLocalization M S] [IsLocalization N T] :
    @IsScalarTower R S T _ (localizationAlgebraOfSubmonoidLe S T M N h).toSMul _
-- Mathlib/Order/OmegaCompletePartialOrder.lean
/-- The `ωSup` operator for continuous functions, which takes the pointwise countable supremum
of the functions in the `ω`-chain. -/
@[simps!]
protected def ωSup (c : Chain (α →𝒄 β)) : α →𝒄 β
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- Post-composition by a uniform inducing function is
a uniform inducing function for the uniform structures of uniform convergence.

More precisely, if `f : γ → β` is uniform inducing,
then `(f ∘ ·) : (α →ᵤ γ) → (α →ᵤ β)` is uniform inducing. -/
protected theorem postcomp_uniformInducing [UniformSpace γ] {f : γ → β} (hf : UniformInducing f) :
    UniformInducing (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β)
-- Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean
theorem mem_nonZeroDivisors_iff {r : M} : r ∈ M⁰ ↔ ∀ x, x * r = 0 → x = 0
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem coe_toNonUnitalAlgHom {f : A →⋆ₙₐ[R] B} : (f.toNonUnitalAlgHom : A → B) = f
-- Mathlib/Data/Rat/Cast/Lemmas.lean
@[simp, norm_cast]
theorem cast_pow {K} [DivisionSemiring K] (q : ℚ≥0) (n : ℕ) :
    NNRat.cast (q ^ n) = (NNRat.cast q : K) ^ n
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_finset_sum' (hT : DominatedFinMeasAdditive μ T C) {ι} (s : Finset ι)
    {f : ι → α → E} (hf : ∀ i ∈ s, Integrable (f i) μ) :
    setToFun μ T hT (∑ i ∈ s, f i) = ∑ i ∈ s, setToFun μ T hT (f i)
-- Mathlib/Analysis/Complex/Basic.lean
lemma exists_norm_eq_mul_self (z : ℂ) : ∃ c, ‖c‖ = 1 ∧ ‖z‖ = c * z
-- Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean
theorem Gamma_strictMonoOn_Ici : StrictMonoOn Gamma (Ici 2)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem get?_cons_zero : @get? α (a::l) 0 = some a
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
/-- Precomposing `f` with `Prod.snd` is `C^n` -/
theorem ContDiff.snd' {f : F → G} (hf : ContDiff 𝕜 n f) : ContDiff 𝕜 n fun x : E × F => f x.2
-- Mathlib/Algebra/Module/GradedModule.lean
/-- A graded version of `Module`. -/
class Gmodule [AddMonoid ιA] [VAdd ιA ιB] [∀ i, AddMonoid (A i)] [∀ i, AddMonoid (M i)] [GMonoid A]
    extends GdistribMulAction A M where
  add_smul {i j} (a a' : A i) (b : M j) : smul (a + a') b = smul a b + smul a' b
  zero_smul {i j} (b : M j) : smul (0 : A i) b = 0
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[simp]
theorem of_x (n : α) : (of X d sq).X n = X n
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem get_const (n : ℕ) (a : α) : get (const a) n = a
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
/-- A (finite dimensional) space that is a subsingleton has zero `finrank`. -/
@[nontriviality]
theorem FiniteDimensional.finrank_zero_of_subsingleton [Subsingleton M] : finrank R M = 0
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
theorem isZero_zero [HasZeroObject V] : IsZero (zero : HomologicalComplex V c)
-- Mathlib/Algebra/MvPolynomial/Degrees.lean
theorem totalDegree_add (a b : MvPolynomial σ R) :
    (a + b).totalDegree ≤ max a.totalDegree b.totalDegree
-- Mathlib/RingTheory/Localization/Basic.lean
theorem lift_injective_iff :
    Injective (lift hg : S → P) ↔ ∀ x y, algebraMap R S x = algebraMap R S y ↔ g x = g y
-- Mathlib/CategoryTheory/Grothendieck.lean
/-- The functor `Grothendieck.map α : Grothendieck F ⥤ Grothendieck G` lies over `C`.-/
theorem functor_comp_forget {α : F ⟶ G} :
    Grothendieck.map α ⋙ Grothendieck.forget G = Grothendieck.forget F
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem mk_univ {α : Type u} : #(@univ α) = #α
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem mem_mk' {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubmonoid R} (ha : ↑sa = s)
    {x : R} : x ∈ Subsemiring.mk' s sm hm sa ha ↔ x ∈ s
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigO.triangle (h₁ : (fun x => f₁ x - f₂ x) =O[l] g)
    (h₂ : (fun x => f₂ x - f₃ x) =O[l] g) : (fun x => f₁ x - f₃ x) =O[l] g
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem eq_top_iff' : S = ⊤ ↔ ∀ x : M, x ∈ S
-- Mathlib/CategoryTheory/Shift/ShiftedHom.lean
@[simp]
lemma add_comp
    {a b c : M} (α₁ α₂ : ShiftedHom X Y a) (β : ShiftedHom Y Z b) (h : b + a = c) :
    (α₁ + α₂).comp β h = α₁.comp β h + α₂.comp β h
-- Mathlib/Topology/Algebra/Constructions/DomMulAct.lean
@[to_additive] theorem embedding_mk : Embedding (@mk M)
-- Mathlib/Data/DList/Basic.lean
@[simp]
theorem DList_singleton {α : Type*} {a : α} : DList.singleton a = DList.lazy_ofList [a]
-- Mathlib/Order/Chain.lean
theorem IsChain.image (r : α → α → Prop) (s : β → β → Prop) (f : α → β)
    (h : ∀ x y, r x y → s (f x) (f y)) {c : Set α} (hrc : IsChain r c) : IsChain s (f '' c)
-- Mathlib/Geometry/Manifold/Instances/Sphere.lean
theorem continuous_stereoInvFun (hv : ‖v‖ = 1) : Continuous (stereoInvFun hv)