ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Polynomial/Basic.lean
/-- The only constant in a maximal ideal over a field is `0`. -/
theorem eq_zero_of_constant_mem_of_maximal (hR : IsField R) (I : Ideal R[X]) [hI : I.IsMaximal]
    (x : R) (hx : C x ∈ I) : x = 0
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
@[simp] theorem reverse_balance2 (l : RBNode α) (v : α) (r : RBNode α) :
    (balance2 l v r).reverse = balance1 r.reverse v l.reverse
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem uniqueProd_symm_apply [Unique β] (x : α) :
    (uniqueProd α β).symm x = (default, x)
-- Mathlib/AlgebraicGeometry/Gluing.lean
@[simp, reassoc]
theorem gluedCoverT'_fst_fst (x y z : 𝒰.J) :
    𝒰.gluedCoverT' x y z ≫ pullback.fst _ _ ≫ pullback.fst _ _ =
      pullback.fst _ _ ≫ pullback.snd _ _
-- Mathlib/Order/Irreducible.lean
theorem SupPrime.not_isMin (ha : SupPrime a) : ¬IsMin a
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
theorem subgraphOfAdj_eq_induce {v w : V} (hvw : G.Adj v w) :
    G.subgraphOfAdj hvw = (⊤ : G.Subgraph).induce {v, w}
-- Mathlib/CategoryTheory/Dialectica/Basic.lean
/-- A morphism in the `Dial C` category from `⟨U, X, α⟩` to `⟨V, Y, β⟩` is a pair
`(f : U ⟶ V, F : U ⨯ Y ⟶ X)` such that `{(u,y) | α(u, F(u, y))} ≤ {(u,y) | β(f(u), y)}`. -/
@[ext] structure Hom (X Y : Dial C) where
  /-- Maps the sources -/
  f : X.src ⟶ Y.src
  /-- Maps the targets (contravariantly) -/
  F : X.src ⨯ Y.tgt ⟶ X.tgt
  /-- This says `{(u, y) | α(u, F(u, y))} ⊆ {(u, y) | β(f(u), y)}` using subobject pullbacks -/
  le :
    (Subobject.pullback π(π₁, F)).obj X.rel ≤
    (Subobject.pullback (prod.map f (𝟙 _))).obj Y.rel
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma pOpcycles_comp_opcyclesIso_hom : S.pOpcycles ≫ h.opcyclesIso.hom = h.p
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff {a : α} {S : Subgroup G} {x : G} : a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Data/Matrix/Kronecker.lean
theorem zero_kronecker [MulZeroClass α] (B : Matrix n p α) : (0 : Matrix l m α) ⊗ₖ B = 0
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[simp]
theorem comp_assoc {Q T : Type*} [SMul Q T]
    {η : P → Q} {θ : M → Q} {ζ : N → Q}
    (h : Z →ₑ[η] T) (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y)
    [CompTriple φ ψ χ] [CompTriple χ η θ]
    [CompTriple ψ η ζ] [CompTriple φ ζ θ] :
    h.comp (g.comp f) = (h.comp g).comp f
-- Mathlib/Topology/Clopen.lean
theorem IsClopen.union (hs : IsClopen s) (ht : IsClopen t) : IsClopen (s ∪ t)
-- Mathlib/RingTheory/Henselian.lean
theorem HenselianLocalRing.TFAE (R : Type u) [CommRing R] [LocalRing R] :
    TFAE
      [HenselianLocalRing R,
        ∀ f : R[X], f.Monic → ∀ a₀ : ResidueField R, aeval a₀ f = 0 →
          aeval a₀ (derivative f) ≠ 0 → ∃ a : R, f.IsRoot a ∧ residue R a = a₀,
        ∀ {K : Type u} [Field K],
          ∀ (φ : R →+* K), Surjective φ → ∀ f : R[X], f.Monic → ∀ a₀ : K,
            f.eval₂ φ a₀ = 0 → f.derivative.eval₂ φ a₀ ≠ 0 → ∃ a : R, f.IsRoot a ∧ φ a = a₀]
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- Three points are collinear if and only if the first or third point equals the second or
the sine of the angle between three points is zero. -/
theorem collinear_iff_eq_or_eq_or_sin_eq_zero {p₁ p₂ p₃ : P} :
    Collinear ℝ ({p₁, p₂, p₃} : Set P) ↔ p₁ = p₂ ∨ p₃ = p₂ ∨ Real.sin (∠ p₁ p₂ p₃) = 0
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem symm_neg : (neg R : E ≃ₗᵢ[R] E).symm = neg R
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
@[simp]
theorem center_eq_top (R) [NonUnitalCommRing R] : center R = ⊤
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc (attr := simp)]
lemma LeftHomologyData.liftCycles_comp_cyclesIso_hom :
    S.liftCycles k hk ≫ h.cyclesIso.hom = h.liftK k hk
-- Mathlib/Order/Filter/Prod.lean
theorem Eventually.diag_of_prod_left {f : Filter α} {g : Filter γ} {p : (α × α) × γ → Prop} :
    (∀ᶠ x in (f ×ˢ f) ×ˢ g, p x) → ∀ᶠ x : α × γ in f ×ˢ g, p ((x.1, x.1), x.2)
-- Mathlib/Probability/Independence/Basic.lean
/-- If `f` is a family of mutually independent random variables (`iIndepFun m f μ`) and `S, T` are
two disjoint finite index sets, then the tuple formed by `f i` for `i ∈ S` is independent of the
tuple `(f i)_i` for `i ∈ T`. -/
lemma iIndepFun.indepFun_finset (S T : Finset ι) (hST : Disjoint S T) (hf_Indep : iIndepFun m f μ)
    (hf_meas : ∀ i, Measurable (f i)) :
    IndepFun (fun a (i : S) ↦ f i a) (fun a (i : T) ↦ f i a) μ
-- Mathlib/FieldTheory/RatFunc/Basic.lean
/-- Subtraction of rational functions. -/
protected irreducible_def sub : RatFunc K → RatFunc K → RatFunc K
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem map_smulₛₗ (f : M₁ →SL[σ₁₂] M₂) (c : R₁) (x : M₁) : f (c • x) = σ₁₂ c • f x
-- Mathlib/Probability/Kernel/IntegralCompProd.lean
theorem _root_.MeasureTheory.AEStronglyMeasurable.compProd_mk_left {δ : Type*} [TopologicalSpace δ]
    {f : β × γ → δ} (hf : AEStronglyMeasurable f ((κ ⊗ₖ η) a)) :
    ∀ᵐ x ∂κ a, AEStronglyMeasurable (fun y => f (x, y)) (η (a, x))
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem tsum_mul_left [T2Space α] : ∑' x, a * f x = a * ∑' x, f x
-- Mathlib/AlgebraicGeometry/StructureSheaf.lean
theorem toBasicOpen_surjective (f : R) : Function.Surjective (toBasicOpen R f)
-- Mathlib/Data/Finset/NatDivisors.lean
lemma Nat.Prime.divisors_sq {p : ℕ} (hp : p.Prime) : (p ^ 2).divisors = {p ^ 2, p, 1}
-- Mathlib/Logic/Embedding/Basic.lean
@[simp]
theorem equiv_symm_toEmbedding_trans_toEmbedding {α β : Sort*} (e : α ≃ β) :
    e.symm.toEmbedding.trans e.toEmbedding = Embedding.refl _
-- Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean
@[ext] theorem initial.hom_ext [HasInitial C] {P : C} (f g : ⊥_ C ⟶ P) : f = g
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/Real.lean
theorem eLpNorm_one_condexp_le_eLpNorm (f : α → ℝ) : eLpNorm (μ[f|m]) 1 μ ≤ eLpNorm f 1 μ
-- Mathlib/LinearAlgebra/Ray.lean
/-- The ray of `someRayVector`. -/
@[simp]
theorem someRayVector_ray (x : Module.Ray R M) : (⟦x.someRayVector⟧ : Module.Ray R M) = x
-- Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean
/-- The unit of the constructed pointwise left Kan extension when
`HasPointwiseLeftKanExtension L F` holds. -/
@[simps]
noncomputable def pointwiseLeftKanExtensionUnit : F ⟶ L ⋙ pointwiseLeftKanExtension L F
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem coeff_mul_add_eq_of_natDegree_le {df dg : ℕ} {f g : R[X]}
    (hdf : natDegree f ≤ df) (hdg : natDegree g ≤ dg) :
    (f * g).coeff (df + dg) = f.coeff df * g.coeff dg
-- Mathlib/Algebra/Algebra/Hom.lean
lemma toIntAlgHom_injective [Ring R] [Ring S] [Algebra ℤ R] [Algebra ℤ S] :
    Function.Injective (RingHom.toIntAlgHom : (R →+* S) → _)
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
@[simp]
theorem addHaar_image_homothety (x : E) (r : ℝ) (s : Set E) :
    μ (AffineMap.homothety x r '' s) = ENNReal.ofReal (abs (r ^ finrank ℝ E)) * μ s
-- Mathlib/Data/Finsupp/Basic.lean
theorem filter_eq_zero_iff : f.filter p = 0 ↔ ∀ x, p x → f x = 0
-- Mathlib/Data/Finset/Basic.lean
theorem eq_empty_or_nonempty (s : Finset α) : s = ∅ ∨ s.Nonempty
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLogExp.lean
@[simp] lemma _root_.EReal.expHomeomorph_apply (x : EReal) : expHomeomorph x = exp x
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[simp]
theorem log_pow_eq_self [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)
    (m : ℕ) : log (pow n m) = m
-- Mathlib/Tactic/FunProp/ContDiff.lean
theorem contDiff_pi' (hΦ : ∀ i, ContDiff K n fun x => Φ x i) : ContDiff K n Φ
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem Monotone.le_of_tendsto [TopologicalSpace α] [Preorder α] [OrderClosedTopology α]
    [SemilatticeInf β] {f : β → α} {a : α} (hf : Monotone f) (ha : Tendsto f atBot (𝓝 a)) (b : β) :
    a ≤ f b
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem map_smul (f : M →ₗ⁅R,L⁆ N) (c : R) (x : M) : f (c • x) = c • f x
-- Mathlib/Data/Num/Lemmas.lean
theorem to_nat_pos : ∀ n : PosNum, 0 < (n : ℕ)
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem alternatization_apply_toAlternatingMap :
    (alternatization f).toAlternatingMap = MultilinearMap.alternatization f.1
-- Mathlib/Topology/Sequences.lean
/-- A set is sequentially closed iff it is equal to its sequential closure. -/
theorem isSeqClosed_iff {s : Set X} : IsSeqClosed s ↔ seqClosure s = s
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
@[simp]
theorem mem_mk {l u x : ι → ℝ} {H} : x ∈ mk l u H ↔ ∀ i, x i ∈ Ioc (l i) (u i)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem comm_symm_tmul (a : A) (b : B) :
    (TensorProduct.comm R A B).symm (b ⊗ₜ a) = a ⊗ₜ b
-- Mathlib/RingTheory/Flat/Stability.lean
private lemma auxRTensorBaseChange_eq (I : Ideal S) :
    auxRTensorBaseChange R S M I = rTensor (S ⊗[R] M) (Submodule.subtype I)
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
@[simp]
theorem map_of_apply {f : α → β} (a : α) : map f (of a) = of (f a)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
lemma mem_ae_iff_prob_eq_one₀ (hs : NullMeasurableSet s μ) : s ∈ ae μ ↔ μ s = 1
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem norm_const_smul (hp : p ≠ 0) {c : 𝕜} (f : lp E p) : ‖c • f‖ = ‖c‖ * ‖f‖
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
lemma arg_mul_eq_add_arg_iff {x y : ℂ} (hx₀ : x ≠ 0) (hy₀ : y ≠ 0) :
    (x * y).arg = x.arg + y.arg ↔ arg x + arg y ∈ Set.Ioc (-π) π
-- Mathlib/Data/Int/Defs.lean
@[elab_as_elim] protected lemma induction_on {p : ℤ → Prop} (i : ℤ)
    (hz : p 0) (hp : ∀ i : ℕ, p i → p (i + 1)) (hn : ∀ i : ℕ, p (-i) → p (-i - 1)) : p i
-- Mathlib/MeasureTheory/Decomposition/Jordan.lean
theorem null_of_totalVariation_zero (s : SignedMeasure α) {i : Set α}
    (hs : s.totalVariation i = 0) : s i = 0
-- Mathlib/Data/Nat/Bits.lean
@[simp]
lemma bodd_mul (m n : ℕ) : bodd (m * n) = (bodd m && bodd n)
-- Mathlib/GroupTheory/Perm/Sign.lean
@[simp]
theorem sign_ofSubtype {p : α → Prop} [DecidablePred p] (f : Equiv.Perm (Subtype p)) :
    sign (ofSubtype f) = sign f
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
@[simp]
theorem norm_coe_unitary_mul (U : unitary E) (A : E) : ‖(U : E) * A‖ = ‖A‖
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem Irreducible.isUnit_gcd_iff [GCDMonoid α] {x y : α} (hx : Irreducible x) :
    IsUnit (gcd x y) ↔ ¬(x ∣ y)
-- Mathlib/Order/Filter/FilterProduct.lean
theorem lt_def [Preorder β] : ((· < ·) : β* → β* → Prop) = LiftRel (· < ·)
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_subset_ge_of_subset_image_lift {α : Type u} {β : Type v} (f : α → β) {s : Set α}
    {t : Set β} (h : t ⊆ f '' s) : lift.{u} #t ≤ lift.{v} #({ x ∈ s | f x ∈ t } : Set α)
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem oadd_lt_oadd_3 {e n a₁ a₂} (h : a₁ < a₂) : oadd e n a₁ < oadd e n a₂
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive (attr := simp) existing AddGroupNorm.apply_one]
theorem apply_one (x : E) : (1 : GroupNorm E) x = if x = 1 then 0 else 1
-- Mathlib/Analysis/Convex/Combination.lean
theorem Finset.centerMass_insert (ha : i ∉ t) (hw : ∑ j ∈ t, w j ≠ 0) :
    (insert i t).centerMass w z =
      (w i / (w i + ∑ j ∈ t, w j)) • z i +
        ((∑ j ∈ t, w j) / (w i + ∑ j ∈ t, w j)) • t.centerMass w z
-- Mathlib/LinearAlgebra/QuadraticForm/IsometryEquiv.lean
theorem equivalent_weightedSumSquares (Q : QuadraticForm K V) :
    ∃ w : Fin (FiniteDimensional.finrank K V) → K, Equivalent Q (weightedSumSquares K w)
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem intCast_toProd (n : ℤ) : (n : 𝓜(𝕜, A)).toProd = n
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem find?_cons_of_neg (l) (h : ¬p a) : find? p (a :: l) = find? p l
-- Mathlib/Data/List/Duplicate.lean
theorem Duplicate.ne_nil (h : x ∈+ l) : l ≠ []
-- Mathlib/Analysis/Calculus/FDeriv/Comp.lean
theorem fderiv.comp_fderivWithin {g : F → G} (hg : DifferentiableAt 𝕜 g (f x))
    (hf : DifferentiableWithinAt 𝕜 f s x) (hxs : UniqueDiffWithinAt 𝕜 s x) :
    fderivWithin 𝕜 (g ∘ f) s x = (fderiv 𝕜 g (f x)).comp (fderivWithin 𝕜 f s x)
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
/-- The conditional cdf is lower or equal to 1 for all `a : α`. -/
theorem condCDF_le_one (ρ : Measure (α × ℝ)) (a : α) (x : ℝ) : condCDF ρ a x ≤ 1
-- Mathlib/Data/Multiset/Range.lean
@[simp]
theorem range_succ (n : ℕ) : range (succ n) = n ::ₘ range n
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem isSeparatedFor_iff_generate :
    IsSeparatedFor P R ↔ IsSeparatedFor P (generate R : Presieve X)
-- Mathlib/Algebra/Group/Action/Defs.lean
@[simp] lemma toAdd_vadd [VAdd α β] (a) (b : β) : (toAdd a : α) +ᵥ b = a • b
-- Mathlib/Topology/Order/Lattice.lean
lemma finset_sup'_nhds_apply [SemilatticeSup L] [ContinuousSup L]
    (hne : s.Nonempty) (hs : ∀ i ∈ s, Tendsto (f i) l (𝓝 (g i))) :
    Tendsto (fun a ↦ s.sup' hne (f · a)) l (𝓝 (s.sup' hne g))
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousWithinAt.preimage_mem_nhdsWithin' {f : α → β} {x : α} {s : Set α} {t : Set β}
    (h : ContinuousWithinAt f s x) (ht : t ∈ 𝓝[f '' s] f x) : f ⁻¹' t ∈ 𝓝[s] x
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
theorem lt_rpow_of_log_lt (hx : 0 ≤ x) (hy : 0 < y) (h : Real.log x < z * Real.log y) :
    x < y ^ z
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
/-- The ideal of `A ⊗[R] B` generated by `I` is the image of `A ⊗[R] I` -/
lemma Ideal.map_includeRight_eq (I : Ideal B) :
    (I.map (Algebra.TensorProduct.includeRight : B →ₐ[R] A ⊗[R] B)).restrictScalars R
      = LinearMap.range (LinearMap.lTensor A (Submodule.subtype (I.restrictScalars R)))
-- Mathlib/Data/Seq/WSeq.lean
theorem mem_congr {s t : WSeq α} (h : s ~ʷ t) (a) : a ∈ s ↔ a ∈ t
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
@[simp]
theorem coequalizerIso_quot_comp_inv :
    ↾Quot.mk (CoequalizerRel f g) ≫ (coequalizerIso f g).inv = coequalizer.π f g
-- Mathlib/Algebra/Lie/EngelSubalgebra.lean
/-- Engel subalgebras are self-normalizing.
See `LieSubalgebra.normalizer_eq_self_of_engel_le` for a proof that Lie-subalgebras
containing an Engel subalgebra are also self-normalizing,
provided that the ambient Lie algebra is artinina. -/
@[simp]
lemma normalizer_engel (x : L) : normalizer (engel R x) = engel R x
-- Mathlib/Algebra/Algebra/Basic.lean
@[simp]
theorem algebraMap_end_apply (a : R) (m : M) : algebraMap R (End S M) a m = a • m
-- Mathlib/Data/Finset/Card.lean
theorem card_eq_two : s.card = 2 ↔ ∃ x y, x ≠ y ∧ s = {x, y}
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_subset_Iio_iff : Iio a ⊆ Iio b ↔ a ≤ b
-- Mathlib/Algebra/CharZero/Lemmas.lean
@[simp] theorem eq_neg_self_iff {a : R} : a = -a ↔ a = 0
-- Mathlib/Data/List/Sigma.lean
@[simp]
theorem lookupAll_cons_ne (l) {a} : ∀ s : Sigma β, a ≠ s.1 → lookupAll a (s :: l) = lookupAll a l
-- Mathlib/Data/Set/Functor.lean
theorem mem_of_mem_coe {a : α} (ha : a ∈ (γ : Set α)) : ⟨a, coe_subset ha⟩ ∈ γ
-- Mathlib/Data/Nat/Bitwise.lean
@[simp]
theorem lor_bit : ∀ a m b n, bit a m ||| bit b n = bit (a || b) (m ||| n)
-- Mathlib/Order/Interval/Basic.lean
@[simp]
theorem dual_top : dual (⊤ : Interval α) = ⊤
-- Mathlib/ModelTheory/Algebra/Ring/Basic.lean
@[simp]
theorem realize_add (x y : ring.Term α) (v : α → R) :
    Term.realize v (x + y) = Term.realize v x + Term.realize v y
-- Mathlib/MeasureTheory/Function/ConvergenceInMeasure.lean
theorem TendstoInMeasure.exists_seq_tendsto_ae' {u : Filter ι} [NeBot u] [IsCountablyGenerated u]
    {f : ι → α → E} {g : α → E} (hfg : TendstoInMeasure μ f u g) :
    ∃ ns : ℕ → ι, ∀ᵐ x ∂μ, Tendsto (fun i => f (ns i) x) atTop (𝓝 (g x))
-- Mathlib/Order/LiminfLimsup.lean
/-- In a complete lattice, the liminf of a function is the infimum over sets `s` in the filter
of the supremum of the function over `s` -/
theorem liminf_eq_iSup_iInf {f : Filter β} {u : β → α} : liminf u f = ⨆ s ∈ f, ⨅ a ∈ s, u a
-- Mathlib/Topology/Instances/Real.lean
/-- A continuous, periodic function has compact range. -/
theorem Periodic.compact_of_continuous [TopologicalSpace α] {f : ℝ → α} {c : ℝ} (hp : Periodic f c)
    (hc : c ≠ 0) (hf : Continuous f) : IsCompact (range f)
-- Mathlib/Data/Real/Hyperreal.lean
theorem infiniteNeg_iff_infinitesimal_inv_neg {x : ℝ*} :
    InfiniteNeg x ↔ Infinitesimal x⁻¹ ∧ x⁻¹ < 0
-- Mathlib/RingTheory/SurjectiveOnStalks.lean
lemma surjectiveOnStalks_of_surjective (h : Function.Surjective f) :
    SurjectiveOnStalks f
-- Mathlib/Algebra/Regular/SMul.lean
/-- An element of `R` admitting a left inverse is `M`-regular. -/
theorem of_mul_eq_one (h : a * b = 1) : IsSMulRegular M b
-- Mathlib/Order/Filter/AtTopBot.lean
theorem atTop_countable_basis [Nonempty α] [SemilatticeSup α] [Countable α] :
    HasCountableBasis (atTop : Filter α) (fun _ => True) Ici
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[measurability]
protected theorem aestronglyMeasurable (f : Lp E p μ) : AEStronglyMeasurable f μ
-- Mathlib/Algebra/Category/ModuleCat/Presheaf.lean
@[simp]
lemma neg_app (f : P ⟶ Q) (X : Cᵒᵖ) : (-f).app X = -f.app X
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem max_le_of_le_of_le {a b c : Nat} : a ≤ c → b ≤ c → max a b ≤ c
-- Mathlib/RingTheory/Bialgebra/Equiv.lean
@[simp, norm_cast]
theorem coe_coe : ⇑(e : A →ₐc[R] B) = e
-- Mathlib/MeasureTheory/Covering/DensityTheorem.lean
/-- A version of **Lebesgue differentiation theorem** for a sequence of closed balls whose
centers are not required to be fixed. -/
theorem ae_tendsto_average [NormedSpace ℝ E] [CompleteSpace E]
    {f : α → E} (hf : LocallyIntegrable f μ) (K : ℝ) : ∀ᵐ x ∂μ,
      ∀ {ι : Type*} {l : Filter ι} (w : ι → α) (δ : ι → ℝ) (δlim : Tendsto δ l (𝓝[>] 0))
        (xmem : ∀ᶠ j in l, x ∈ closedBall (w j) (K * δ j)),
        Tendsto (fun j => ⨍ y in closedBall (w j) (δ j), f y ∂μ) l (𝓝 (f x))
-- Mathlib/Topology/ContinuousOn.lean
theorem tendsto_nhdsWithin_iff {a : α} {l : Filter β} {s : Set α} {f : β → α} :
    Tendsto f l (𝓝[s] a) ↔ Tendsto f l (𝓝 a) ∧ ∀ᶠ n in l, f n ∈ s
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem ContDiffWithinAt.continuousWithinAt (h : ContDiffWithinAt 𝕜 n f s x) :
    ContinuousWithinAt f s x
-- Mathlib/Topology/Algebra/UniformRing.lean
theorem inseparableSetoid_ring (α) [CommRing α] [TopologicalSpace α] [TopologicalRing α] :
    inseparableSetoid α = Submodule.quotientRel (Ideal.closure ⊥)
-- Mathlib/Algebra/Group/Int.lean
lemma not_even_iff : ¬Even n ↔ n % 2 = 1
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1_smul (hT : DominatedFinMeasAdditive μ T C)
    (h_smul : ∀ c : 𝕜, ∀ s x, T s (c • x) = c • T s x) (c : 𝕜) (f : α →₁[μ] E) :
    setToL1 hT (c • f) = c • setToL1 hT f
-- Mathlib/Logic/Encodable/Basic.lean
/-- A constructive version of `Classical.skolem` for `Encodable` types. -/
theorem skolem {α : Type*} {β : α → Type*} {P : ∀ x, β x → Prop} [∀ a, Encodable (β a)]
    [∀ x y, Decidable (P x y)] : (∀ x, ∃ y, P x y) ↔ ∃ f : ∀ a, β a, ∀ x, P x (f x)
-- Mathlib/RingTheory/WittVector/Identities.lean
theorem iterate_verschiebung_coeff (x : 𝕎 R) (n k : ℕ) :
    (verschiebung^[n] x).coeff (k + n) = x.coeff k
-- Mathlib/Data/ENNReal/Basic.lean
theorem toReal_eq_zero_iff (x : ℝ≥0∞) : x.toReal = 0 ↔ x = 0 ∨ x = ∞
-- Mathlib/Order/SymmDiff.lean
theorem bihimp_of_le {a b : α} (h : a ≤ b) : a ⇔ b = b ⇨ a
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- See also `comp3_mem_uniformity`. -/
theorem comp_le_uniformity3 : ((𝓤 α).lift' fun s : Set (α × α) => s ○ (s ○ s)) ≤ 𝓤 α
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem range_snd : NonUnitalRingHom.srange (snd R S) = ⊤
-- Mathlib/Topology/Bornology/Basic.lean
@[simp]
theorem isBounded_insert : IsBounded (insert x s) ↔ IsBounded s
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_shiftLeft (x : BitVec m) (n) :
    getLsb (x <<< n) i = (decide (i < m) && !decide (i < n) && getLsb x (i - n))
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem integrableOn_Ioc_of_intervalIntegral_norm_bounded_left {I a₀ b : ℝ}
    (hfi : ∀ i, IntegrableOn f <| Ioc (a i) b) (ha : Tendsto a l <| 𝓝 a₀)
    (h : ∀ᶠ i in l, (∫ x in Ioc (a i) b, ‖f x‖) ≤ I) : IntegrableOn f (Ioc a₀ b)
-- Mathlib/Analysis/Convex/Between.lean
theorem affineSegment_eq_segment (x y : V) : affineSegment R x y = segment R x y
-- Mathlib/Probability/Independence/Kernel.lean
theorem iIndepSet.indep_generateFrom_of_disjoint [IsMarkovKernel κ] {s : ι → Set Ω}
    (hsm : ∀ n, MeasurableSet (s n)) (hs : iIndepSet s κ μ) (S T : Set ι) (hST : Disjoint S T) :
    Indep (generateFrom { t | ∃ n ∈ S, s n = t }) (generateFrom { t | ∃ k ∈ T, s k = t }) κ μ
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem ofFinsupp_one : (⟨1⟩ : R[X]) = 1
-- Mathlib/Algebra/Module/LocalizedModule.lean
/-- If `S` contains `0` then the localization at `S` is trivial. -/
theorem subsingleton (h : 0 ∈ S) : Subsingleton (LocalizedModule S M)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem logb_ne_zero_of_pos_of_ne_one (hx_pos : 0 < x) (hx : x ≠ 1) : logb b x ≠ 0
-- Mathlib/Algebra/Ring/Commute.lean
@[simp] lemma sq_eq_one_iff : a ^ 2 = 1 ↔ a = 1 ∨ a = -1
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem le_tsub_iff_left (ha : AddLECancellable a) (h : a ≤ c) : b ≤ c - a ↔ a + b ≤ c
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
/-- The sine of `π / 3` is `√3 / 2`. -/
@[simp]
theorem sin_pi_div_three : sin (π / 3) = √3 / 2
-- Mathlib/Order/WellFoundedSet.lean
@[simp] theorem isPWO_singleton (a : α) : IsPWO ({a} : Set α)
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
/-- A fixed block is a block -/
theorem IsFixedBlock.isBlock {B : Set X} (hfB : IsFixedBlock G B) :
    IsBlock G B
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsLowerSet.prod (hs : IsLowerSet s) (ht : IsLowerSet t) : IsLowerSet (s ×ˢ t)
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem aecover_restrict_of_ae_imp {s : Set α} {φ : ι → Set α} (hs : MeasurableSet s)
    (ae_eventually_mem : ∀ᵐ x ∂μ, x ∈ s → ∀ᶠ n in l, x ∈ φ n)
    (measurable : ∀ n, MeasurableSet <| φ n) : AECover (μ.restrict s) l φ
-- Mathlib/Analysis/Normed/Ring/SeminormFromBounded.lean
/-- If `f` is invariant under negation of `x`, then so is `seminormFromBounded'`.-/
theorem seminormFromBounded_neg (f_neg : ∀ x : R, f (-x) = f x) (x : R) :
    seminormFromBounded' f (-x) = seminormFromBounded' f x
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
/-- Expressing `HasFDerivAtFilter f f' x L` in terms of `HasDerivAtFilter` -/
theorem hasFDerivAtFilter_iff_hasDerivAtFilter {f' : 𝕜 →L[𝕜] F} :
    HasFDerivAtFilter f f' x L ↔ HasDerivAtFilter f (f' 1) x L
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem coe_const (b : β) : ⇑(const α b) = Function.const α b
-- Mathlib/Topology/Separation.lean
theorem continuousAt_update_of_ne [T1Space X] [DecidableEq X] [TopologicalSpace Y]
    {f : X → Y} {x x' : X} {y : Y} (hne : x' ≠ x) :
    ContinuousAt (Function.update f x y) x' ↔ ContinuousAt f x'
-- Mathlib/CategoryTheory/Abelian/ProjectiveResolution.lean
lemma exact₀ {Z : C} (P : ProjectiveResolution Z) :
    (ShortComplex.mk _ _ P.complex_d_comp_π_f_zero).Exact
-- Mathlib/CategoryTheory/Sites/LocallyBijective.lean
lemma W_of_isLocallyBijective [Presheaf.IsLocallyInjective J f]
    [Presheaf.IsLocallySurjective J f] : J.W f
-- Mathlib/Data/Nat/Nth.lean
theorem subset_range_nth : setOf p ⊆ Set.range (nth p)
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma Ioc_subset_uIoc : Ioc a b ⊆ Ι a b
-- Mathlib/Analysis/Convex/GaugeRescale.lean
theorem gauge_gaugeRescale (s : Set E) {t : Set E} (hta : Absorbent ℝ t) (htb : IsVonNBounded ℝ t)
    (x : E) : gauge t (gaugeRescale s t x) = gauge s x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_sub_pi_div_two (x : ℝ) : cos (x - π / 2) = sin x
-- Mathlib/Topology/Instances/Int.lean
theorem pairwise_one_le_dist : Pairwise fun m n : ℤ => 1 ≤ dist m n
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem tendsto_nhds_nhds [PseudoMetricSpace β] {f : α → β} {a b} :
    Tendsto f (𝓝 a) (𝓝 b) ↔ ∀ ε > 0, ∃ δ > 0, ∀ {x : α}, dist x a < δ → dist (f x) b < ε
-- Mathlib/Probability/Kernel/Disintegration/CondCdf.lean
theorem tendsto_IicSnd_atBot [IsFiniteMeasure ρ] {s : Set α} (hs : MeasurableSet s) :
    Tendsto (fun r : ℚ ↦ ρ.IicSnd r s) atBot (𝓝 0)
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem coe_top : ↑(⊤ : IntermediateField F E) = (Set.univ : Set E)