ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Polynomial/Wronskian.lean
theorem isAlt_wronskianBilin : (wronskianBilin R).IsAlt
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
@[simp]
theorem basisSingleton_apply (ι : Type*) [Unique ι] (h : finrank K V = 1) (v : V) (hv : v ≠ 0)
    (i : ι) : basisSingleton ι h v hv i = v
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem hasBasis_cobounded_compl_ball (c : α) :
    (cobounded α).HasBasis (fun _ ↦ True) (fun r ↦ (ball c r)ᶜ)
-- Mathlib/NumberTheory/WellApproximable.lean
theorem mem_approxAddOrderOf_iff {δ : ℝ} {x : UnitAddCircle} {n : ℕ} (hn : 0 < n) :
    x ∈ approxAddOrderOf UnitAddCircle n δ ↔ ∃ m < n, gcd m n = 1 ∧ ‖x - ↑((m : ℝ) / n)‖ < δ
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem uniformity_eq_symm : 𝓤 α = @Prod.swap α α <$> 𝓤 α
-- Mathlib/Topology/Instances/ENNReal.lean
theorem Summable.toNNReal {f : α → ℝ} (hf : Summable f) : Summable fun n => (f n).toNNReal
-- Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean
theorem map_extend_nhdsWithin {y : M} (hy : y ∈ f.source) :
    map (f.extend I) (𝓝[s] y) = 𝓝[(f.extend I).symm ⁻¹' s ∩ range I] f.extend I y
-- Mathlib/AlgebraicGeometry/Spec.lean
/-- The counit (`SpecΓIdentity.inv.op`) of the adjunction `Γ ⊣ Spec` is an isomorphism. -/
@[simps! hom_app inv_app]
def LocallyRingedSpace.SpecΓIdentity : Spec.toLocallyRingedSpace.rightOp ⋙ Γ ≅ 𝟭 _
-- Mathlib/Algebra/Group/Action/Prod.lean
@[to_additive (attr := simp)] lemma smul_snd : (a • x).2 = a • x.2
-- Mathlib/NumberTheory/Cyclotomic/Rat.lean
/-- If `p` is a prime and `IsCyclotomicExtension {p ^ k} K L`, then there are `u : ℤˣ` and
`n : ℕ` such that the discriminant of the power basis given by `ζ - 1` is `u * p ^ n`. Often this is
enough and less cumbersome to use than `IsCyclotomicExtension.Rat.discr_prime_pow'`. -/
theorem discr_prime_pow_eq_unit_mul_pow' [IsCyclotomicExtension {p ^ k} ℚ K]
    (hζ : IsPrimitiveRoot ζ ↑(p ^ k)) :
    ∃ (u : ℤˣ) (n : ℕ), discr ℚ (hζ.subOnePowerBasis ℚ).basis = u * p ^ n
-- Mathlib/Data/Set/Lattice.lean
theorem image_iInter₂_subset (s : ∀ i, κ i → Set α) (f : α → β) :
    (f '' ⋂ (i) (j), s i j) ⊆ ⋂ (i) (j), f '' s i j
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NNNorm.lean
theorem opNNNorm_le_iff {f : E →SL[σ₁₂] F} {C : ℝ≥0} : ‖f‖₊ ≤ C ↔ ∀ x, ‖f x‖₊ ≤ C * ‖x‖₊
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
@[simp]
lemma IsInvertedBy.isoClosure_iff (W : MorphismProperty C) (F : C ⥤ D) :
    W.isoClosure.IsInvertedBy F ↔ W.IsInvertedBy F
-- Mathlib/Topology/Instances/AddCircle.lean
lemma eq_coe_Ico (a : AddCircle p) : ∃ b, b ∈ Ico 0 p ∧ ↑b = a
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem basis_apply (i : ι) : basis A b i = 1 ⊗ₜ b i
-- Mathlib/Data/Set/Function.lean
theorem EqOn.piecewise_ite' {f f' g : α → β} {t t'} (h : EqOn f g (t ∩ s))
    (h' : EqOn f' g (t' ∩ sᶜ)) : EqOn (s.piecewise f f') g (s.ite t t')
-- Mathlib/Algebra/Associated/Basic.lean
theorem Associated.of_pow_associated_of_prime [CancelCommMonoidWithZero α] {p₁ p₂ : α} {k₁ k₂ : ℕ}
    (hp₁ : Prime p₁) (hp₂ : Prime p₂) (hk₁ : 0 < k₁) (h : p₁ ^ k₁ ~ᵤ p₂ ^ k₂) : p₁ ~ᵤ p₂
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc]
lemma homologyι_descOpcycles_eq_zero_of_boundary {A : C} (k : K.X i ⟶ A) (j : ι)
    (hj : c.prev i = j) {i' : ι} (x : K.X i' ⟶ A) (hx : k = K.d i i' ≫ x) :
    K.homologyι i ≫ K.descOpcycles k j hj (by rw [hx, K.d_comp_d_assoc, zero_comp]) = 0
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem Complex.toBasis_orthonormalBasisOneI :
    Complex.orthonormalBasisOneI.toBasis = Complex.basisOneI
-- Mathlib/RingTheory/LocalProperties.lean
/-- If `M` is an `R' = S⁻¹R` module, and `x ∈ span R' s`,
then `t • x ∈ span R s` for some `t : S`. -/
theorem multiple_mem_span_of_mem_localization_span
    {N : Type*} [AddCommMonoid N] [Module R N] [Module R' N]
    [IsScalarTower R R' N] [IsLocalization M R'] (s : Set N) (x : N)
    (hx : x ∈ Submodule.span R' s) : ∃ (t : M), t • x ∈ Submodule.span R s
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem one_def : (1 : A ⊗[R] B) = (1 : A) ⊗ₜ (1 : B)
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp]
theorem comp_continuousOn_iff {γ} [TopologicalSpace γ] (h : α ≃ᵢ β) {f : γ → α} {s : Set γ} :
    ContinuousOn (h ∘ f) s ↔ ContinuousOn f s
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
@[simp] lemma uIoc_of_le (h : a ≤ b) : Ι a b = Ioc a b
-- Mathlib/Analysis/Convex/Extreme.lean
theorem IsExtreme.convex_diff (hA : Convex 𝕜 A) (hAB : IsExtreme 𝕜 A B) : Convex 𝕜 (A \ B)
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
/-- Uniformizers exist in a DVR. -/
theorem exists_prime : ∃ ϖ : R, Prime ϖ
-- Mathlib/Order/UpperLower/Basic.lean
theorem mem_iSup₂_iff {f : ∀ i, κ i → UpperSet α} : (a ∈ ⨆ (i) (j), f i j) ↔ ∀ i j, a ∈ f i j
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem bind₁_rename {υ : Type*} (f : τ → MvPolynomial υ R) (g : σ → τ) (φ : MvPolynomial σ R) :
    bind₁ f (rename g φ) = bind₁ (f ∘ g) φ
-- Mathlib/Data/Int/Defs.lean
lemma dvd_natCast {n : ℕ} : m ∣ (n : ℤ) ↔ m.natAbs ∣ n
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem getElem?_length (l : List α) : l[l.length]? = none
-- Mathlib/Order/Atoms.lean
theorem isAtom_of_map_bot_of_image [OrderBot α] [OrderBot β] (f : β ↪o α) (hbot : f ⊥ = ⊥) {b : β}
    (hb : IsAtom (f b)) : IsAtom b
-- Mathlib/LinearAlgebra/Dual.lean
@[simp] lemma apply_evalEquiv_symm_apply (f : Dual R M) (g : Dual R (Dual R M)) :
    f ((evalEquiv R M).symm g) = g f
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
/-- `ContinuousMap.compStarAlgHom'` as a `StarAlgEquiv` when the continuous map `f` is
actually a homeomorphism. -/
@[simps]
def compStarAlgEquiv' (f : X ≃ₜ Y) : C(Y, A) ≃⋆ₐ[𝕜] C(X, A)
-- Mathlib/Algebra/Homology/ShortComplex/Exact.lean
/-- A short complex equipped with a splitting is exact. -/
lemma exact [HasZeroObject C] (s : S.Splitting) : S.Exact
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem HasStrictDerivAt.cos (hf : HasStrictDerivAt f f' x) :
    HasStrictDerivAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') x
-- Mathlib/GroupTheory/Coxeter/Length.lean
private theorem isReduced_take_and_drop {ω : List B} (hω : cs.IsReduced ω) (j : ℕ) :
    cs.IsReduced (ω.take j) ∧ cs.IsReduced (ω.drop j)
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
@[simp]
theorem coe_toAddHom (f : M →ₛₗ[σ] M₃) : ⇑f.toAddHom = f
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem eq_of_eqOn_stop {f g : F}
    (h : Set.EqOn (f : R → S) (g : R → S) (⊤ : NonUnitalSubsemiring R)) : f = g
-- Mathlib/Data/Nat/Choose/Central.lean
theorem centralBinom_ne_zero (n : ℕ) : centralBinom n ≠ 0
-- Mathlib/Dynamics/OmegaLimit.lean
theorem omegaLimit_subset_closure_fw_image {u : Set τ} (hu : u ∈ f) :
    ω f ϕ s ⊆ closure (image2 ϕ u s)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem preimage_sphere (x : E₂) (r : ℝ) : e ⁻¹' Metric.sphere x r = Metric.sphere (e.symm x) r
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem span_singleton_le_iff_mem {x : α} : span {x} ≤ I ↔ x ∈ I
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
theorem limsInf_nhds : ∀ a : α, limsInf (𝓝 a) = a
-- Mathlib/Order/Bounds/Basic.lean
/-- If `a` is a least upper bound for sets `s` and `p`, then it is a least upper bound for any
set `t`, `s ⊆ t ⊆ p`. -/
theorem IsLUB.of_subset_of_superset {s t p : Set α} (hs : IsLUB s a) (hp : IsLUB p a) (hst : s ⊆ t)
    (htp : t ⊆ p) : IsLUB t a
-- Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean
theorem oneCoboundaries_eq_bot_of_isTrivial (A : Rep k G) [A.IsTrivial] :
    oneCoboundaries A = ⊥
-- Mathlib/Data/List/Basic.lean
@[simp, deprecated get_map (since := "2023-01-05")]
theorem nthLe_map' (f : α → β) {l n} (H) :
    nthLe (map f l) n H = f (nthLe l n (l.length_map f ▸ H))
-- Mathlib/Analysis/Normed/Order/UpperLower.lean
protected lemma IsClopen.lowerClosure_pi (hs : IsClopen s) (hs' : BddAbove s) :
    IsClopen (lowerClosure s : Set (ι → ℝ))
-- Mathlib/Topology/Semicontinuous.lean
theorem LowerSemicontinuous.lowerSemicontinuousOn (h : LowerSemicontinuous f) (s : Set α) :
    LowerSemicontinuousOn f s
-- Mathlib/Topology/Separation.lean
theorem exists_nhds_disjoint_closure [T25Space X] {x y : X} (h : x ≠ y) :
    ∃ s ∈ 𝓝 x, ∃ t ∈ 𝓝 y, Disjoint (closure s) (closure t)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem append_eq_append_iff {a b c d : List α} :
    a ++ b = c ++ d ↔ (∃ a', c = a ++ a' ∧ b = a' ++ d) ∨ ∃ c', a = c ++ c' ∧ d = c' ++ b
-- Mathlib/Order/Filter/Extr.lean
theorem IsMaxOn.inf (hf : IsMaxOn f s a) (hg : IsMaxOn g s a) : IsMaxOn (fun x => f x ⊓ g x) s a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[simp]
theorem norm_neg (f : Lp E p μ) : ‖-f‖ = ‖f‖
-- Mathlib/Analysis/ODE/PicardLindelof.lean
/-- A time-independent, continuously differentiable ODE admits a solution in some open interval. -/
theorem exists_forall_hasDerivAt_Ioo_eq_of_contDiff (hv : ContDiff ℝ 1 v) :
    ∃ f : ℝ → E, f t₀ = x₀ ∧
      ∃ ε > (0 : ℝ), ∀ t ∈ Ioo (t₀ - ε) (t₀ + ε), HasDerivAt f (v (f t)) t
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem star_apply [Star α] (M : Matrix n n α) (i j) : (star M) i j = star (M j i)
-- Mathlib/Topology/Inseparable.lean
@[trans]
theorem Specializes.trans : x ⤳ y → y ⤳ z → x ⤳ z
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem trinomial_leadingCoeff (hkm : k < m) (hmn : m < n) (hw : w ≠ 0) :
    (trinomial k m n u v w).leadingCoeff = w
-- Mathlib/Algebra/Lie/Weights/Killing.lean
@[simp] lemma orthogonal_span_coroot_eq_ker (α : Weight K H L) :
    (traceForm K H L).orthogonal (K ∙ coroot α) = α.ker
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Basic.lean
/-- If a continuous linear map is constructed from a linear map via the constructor `mkContinuous`,
then its norm is bounded by the bound or zero if bound is negative. -/
theorem mkContinuous_norm_le' (f : E →ₛₗ[σ₁₂] F) {C : ℝ} (h : ∀ x, ‖f x‖ ≤ C * ‖x‖) :
    ‖f.mkContinuous C h‖ ≤ max C 0
-- Mathlib/CategoryTheory/Subobject/Basic.lean
@[simp]
theorem representative_coe (Y : Subobject X) : (representative.obj Y : C) = (Y : C)
-- Mathlib/Data/Finset/Lattice.lean
theorem iSup_option_toFinset (o : Option α) (f : α → β) : ⨆ x ∈ o.toFinset, f x = ⨆ x ∈ o, f x
-- Mathlib/Logic/IsEmpty.lean
@[simp]
theorem isEmpty_plift {α} : IsEmpty (PLift α) ↔ IsEmpty α
-- Mathlib/Algebra/Divisibility/Units.lean
theorem isUnit_iff_forall_dvd {x : α} : IsUnit x ↔ ∀ y, x ∣ y
-- Mathlib/Topology/Category/TopCommRingCat.lean
/-- A bundled topological commutative ring. -/
structure TopCommRingCat where
  /-- carrier of a topological commutative ring. -/
  α : Type u
  [isCommRing : CommRing α]
  [isTopologicalSpace : TopologicalSpace α]
  [isTopologicalRing : TopologicalRing α]
-- Mathlib/Order/SupClosed.lean
lemma supClosure_mono : Monotone (supClosure : Set α → Set α)
-- Mathlib/Topology/Instances/Rat.lean
theorem dist_eq (x y : ℚ) : dist x y = |(x : ℝ) - y|
-- Mathlib/Data/Matroid/Map.lean
lemma restrictSubtype_indep_iff_of_subset (hIX : I ⊆ X) :
    (M.restrictSubtype X).Indep (X ↓∩ I) ↔ M.Indep I
-- Mathlib/Order/Disjointed.lean
theorem disjointed_le (f : ℕ → α) : disjointed f ≤ f
-- Mathlib/Analysis/Convex/Contractible.lean
/-- A non-empty convex set is a contractible space. -/
protected theorem Convex.contractibleSpace (hs : Convex ℝ s) (hne : s.Nonempty) :
    ContractibleSpace s
-- Mathlib/Data/Seq/WSeq.lean
theorem toSeq_ofSeq (s : Seq α) : toSeq (ofSeq s) = s
-- Mathlib/Algebra/Order/Archimedean.lean
/-- An archimedean decidable linearly ordered `AddCommGroup` has a version of the floor: for
`a > 0`, any `g` in the group lies between some two consecutive multiples of `a`. -/
theorem existsUnique_zsmul_near_of_pos {a : α} (ha : 0 < a) (g : α) :
    ∃! k : ℤ, k • a ≤ g ∧ g < (k + 1) • a
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
lemma preimage_symm (e : α ≃ᵐ β) (s : Set α) : e.symm ⁻¹' s = e '' s
-- Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean
theorem comp_attachBound_mem_closure (A : Subalgebra ℝ C(X, ℝ)) (f : A)
    (p : C(Set.Icc (-‖f‖) ‖f‖, ℝ)) : p.comp (attachBound (f : C(X, ℝ))) ∈ A.topologicalClosure
-- Mathlib/RingTheory/Polynomial/Opposites.lean
@[simp]
theorem leadingCoeff_opRingEquiv (p : R[X]ᵐᵒᵖ) :
    (opRingEquiv R p).leadingCoeff = op (unop p).leadingCoeff
-- Mathlib/CategoryTheory/Subobject/FactorThru.lean
theorem factorThru_ofLE {Y Z : C} {P Q : Subobject Y} {f : Z ⟶ Y} (h : P ≤ Q) (w : P.Factors f) :
    Q.factorThru f (factors_of_le f h w) = P.factorThru f w ≫ ofLE P Q h
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Linear.lean
theorem Expr.of_cancel_eq (ctx : Context) (a b c d : Expr) (h : Poly.cancel a.toNormPoly b.toNormPoly = (c.toPoly, d.toPoly)) : (a.denote ctx = b.denote ctx) = (c.denote ctx = d.denote ctx)
-- Mathlib/Analysis/MellinTransform.lean
theorem mellin_cpow_smul (f : ℝ → E) (s a : ℂ) :
    mellin (fun t => (t : ℂ) ^ a • f t) s = mellin f (s + a)
-- Mathlib/FieldTheory/SeparableDegree.lean
theorem natSepDegree_le_of_dvd (g : F[X]) (h1 : f ∣ g) (h2 : g ≠ 0) :
    f.natSepDegree ≤ g.natSepDegree
-- Mathlib/RingTheory/Artinian.lean
/-- A sequence `f` of submodules of an artinian module,
with the supremum `f (n+1)` and the infimum of `f 0`, ..., `f n` being ⊤,
is eventually ⊤. -/
theorem disjoint_partial_infs_eventually_top (f : ℕ → Submodule R M)
    (h : ∀ n, Disjoint (partialSups (OrderDual.toDual ∘ f) n) (OrderDual.toDual (f (n + 1)))) :
    ∃ n : ℕ, ∀ m, n ≤ m → f m = ⊤
-- Mathlib/Data/Finset/Basic.lean
theorem inter_subset_ite (s s' : Finset α) (P : Prop) [Decidable P] : s ∩ s' ⊆ ite P s s'
-- Mathlib/Algebra/Homology/SingleHomology.lean
@[reassoc (attr := simp)]
lemma singleObjOpcyclesSelfIso_hom_naturality :
    (singleObjOpcyclesSelfIso c j A).hom ≫ opcyclesMap ((single C c j).map f) j  =
      f ≫ (singleObjOpcyclesSelfIso c j B).hom
-- Mathlib/RingTheory/HahnSeries/Basic.lean
@[simp]
lemma mk_eq_zero (f : Γ → R) (h) : HahnSeries.mk f h = 0 ↔ f = 0
-- Mathlib/Order/Filter/NAry.lean
theorem map₂_assoc {m : δ → γ → ε} {n : α → β → δ} {m' : α → ε' → ε} {n' : β → γ → ε'}
    {h : Filter γ} (h_assoc : ∀ a b c, m (n a b) c = m' a (n' b c)) :
    map₂ m (map₂ n f g) h = map₂ m' f (map₂ n' g h)
-- Mathlib/Algebra/Algebra/Subalgebra/MulOpposite.lean
@[simp]
theorem op_bot : (⊥ : Subalgebra R A).op = ⊥
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem mapsTo_cos (s : Set ℝ) : MapsTo cos s (Icc (-1 : ℝ) 1)
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp]
theorem morphismRestrict_app' {X Y : Scheme.{u}} (f : X ⟶ Y) (U : Y.Opens) (V : Opens U) :
    (f ∣_ U).app V = f.appLE _ _ (image_morphismRestrict_preimage f U V).le
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
/-- Two morphisms into a universal `S`-costructured arrow are equal if their image under `S` are
equal after postcomposing the universal arrow. -/
theorem hom_ext (h : IsUniversal f) {c : C} {η η' : c ⟶ f.left}
    (w : S.map η ≫ f.hom = S.map η' ≫ f.hom) : η = η'
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
theorem log_bijective : Function.Bijective log
-- Mathlib/Data/Matrix/Basic.lean
theorem mulVec_smul [Fintype n] [Monoid R] [NonUnitalNonAssocSemiring S] [DistribMulAction R S]
    [SMulCommClass R S S] (M : Matrix m n S) (b : R) (v : n → S) :
    M *ᵥ (b • v) = b • M *ᵥ v
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
protected theorem MeasureTheory.StronglyMeasurable.stronglyMeasurableAtFilter
    (h : StronglyMeasurable f) : StronglyMeasurableAtFilter f l μ
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
/-- The measurable equivalence `(∀ i, π i) ≃ᵐ π ⋆` when the domain of `π` only contains `⋆` -/
@[simps! (config := .asFn)]
def piUnique [Unique δ'] : (∀ i, π i) ≃ᵐ π default
-- Mathlib/Data/List/Basic.lean
theorem zipRight_nil_cons :
    zipRight ([] : List α) (b :: bs) = (none, b) :: bs.map fun b => (none, b)
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem Antitone.Ici (hf : Antitone f) : Monotone fun x => Ici (f x)
-- Mathlib/Order/JordanHolder.lean
protected theorem strictMono (s : CompositionSeries X) : StrictMono s
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- The coercion from `M →SL[σ] M₂` to `M →ₛₗ[σ] M₂`, as a linear map. -/
@[simps]
def coeLMₛₗ : (M →SL[σ₁₃] M₃) →ₗ[S₃] M →ₛₗ[σ₁₃] M₃
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[aesop safe 20 apply (rule_sets := [Measurable])]
theorem Measurable.pow (hf : Measurable f) (hg : Measurable g) : Measurable fun x => f x ^ g x
-- Mathlib/Topology/Bornology/Basic.lean
lemma Bornology.le_cofinite (α : Type*) [Bornology α] : cobounded α ≤ cofinite
-- Mathlib/Algebra/MvPolynomial/Basic.lean
/-- Similar to `MvPolynomial.induction_on` but only a yet weaker form of `h_add` is required. -/
theorem induction_on'' {M : MvPolynomial σ R → Prop} (p : MvPolynomial σ R) (h_C : ∀ a, M (C a))
    (h_add_weak :
      ∀ (a : σ →₀ ℕ) (b : R) (f : (σ →₀ ℕ) →₀ R),
        a ∉ f.support → b ≠ 0 → M f → M (monomial a b) →
          M ((show (σ →₀ ℕ) →₀ R from monomial a b) + f))
    (h_X : ∀ (p : MvPolynomial σ R) (n : σ), M p → M (p * MvPolynomial.X n)) : M p
-- Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean
theorem UniqueMDiffWithinAt.smooth_bundle_preimage' {b : M} (hs : UniqueMDiffWithinAt I s b)
    (x : Z b) : UniqueMDiffWithinAt (I.prod 𝓘(𝕜, F)) (π F Z ⁻¹' s) ⟨b, x⟩
-- Mathlib/Data/ENNReal/Basic.lean
@[simp]
theorem abs_toReal {x : ℝ≥0∞} : |x.toReal| = x.toReal
-- Mathlib/Probability/Martingale/Basic.lean
theorem neg [Preorder E] [CovariantClass E E (· + ·) (· ≤ ·)] (hf : Supermartingale f ℱ μ) :
    Submartingale (-f) ℱ μ
-- Mathlib/Algebra/Order/Nonneg/Field.lean
@[simp, norm_cast]
protected theorem coe_div (a b : { x : α // 0 ≤ x }) : ((a / b : { x : α // 0 ≤ x }) : α) = a / b
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
@[simp]
theorem AwayMap.lift_comp (hg : IsUnit (g x)) : (F.lift x hg).comp F.toMap = g
-- Mathlib/Data/Nat/Pairing.lean
theorem iSup_unpair {α} [CompleteLattice α] (f : ℕ → ℕ → α) :
    ⨆ n : ℕ, f n.unpair.1 n.unpair.2 = ⨆ (i : ℕ) (j : ℕ), f i j
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_X_pow_sub_C {n : ℕ} {r : R} : (X ^ n - C r).natDegree = n
-- Mathlib/Topology/Homeomorph.lean
theorem comp_continuousAt_iff' (h : X ≃ₜ Y) (f : Y → Z) (x : X) :
    ContinuousAt (f ∘ h) x ↔ ContinuousAt f (h x)
-- Mathlib/Order/Filter/Bases.lean
theorem HasBasis.to_hasBasis' (hl : l.HasBasis p s) (h : ∀ i, p i → ∃ i', p' i' ∧ s' i' ⊆ s i)
    (h' : ∀ i', p' i' → s' i' ∈ l) : l.HasBasis p' s'
-- Mathlib/Topology/MetricSpace/Thickening.lean
/-- The (open) thickening `Metric.thickening δ E` of a fixed subset `E` is an increasing function of
the thickening radius `δ`. -/
theorem thickening_mono {δ₁ δ₂ : ℝ} (hle : δ₁ ≤ δ₂) (E : Set α) :
    thickening δ₁ E ⊆ thickening δ₂ E
-- Mathlib/Order/Basic.lean
theorem eq_of_le_of_not_lt [PartialOrder α] {a b : α} (hab : a ≤ b) (hba : ¬a < b) : a = b
-- Mathlib/Analysis/BoxIntegral/Box/Basic.lean
theorem diam_Icc_le_of_distortion_le (I : Box ι) (i : ι) {c : ℝ≥0} (h : I.distortion ≤ c) :
    diam (Box.Icc I) ≤ c * (I.upper i - I.lower i)
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem lt_pred {a b} : a < pred b ↔ succ a < b
-- Mathlib/Order/UpperLower/Basic.lean
theorem IsLowerSet.top_mem (hs : IsLowerSet s) : ⊤ ∈ s ↔ s = univ
-- Mathlib/Topology/DiscreteQuotient.lean
theorem proj_bot_inj [DiscreteTopology X] {x y : X} : proj ⊥ x = proj ⊥ y ↔ x = y
-- Mathlib/Data/Fin/Basic.lean
theorem rightInverse_cast (eq : n = m) : RightInverse (cast eq.symm) (cast eq)
-- Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean
/-- Note that this not match the `star_smul` implied by `StarModule`; it certainly could if we
also conjugated all the scalars, but there appears to be nothing in the literature that advocates
doing this. -/
@[simp]
theorem star_smul (r : R) (x : CliffordAlgebra Q) : star (r • x) = r • star x
-- Mathlib/Order/Interval/Set/Basic.lean
theorem nonempty_Icc_subtype (h : a ≤ b) : Nonempty (Icc a b)
-- Mathlib/Algebra/Ring/Parity.lean
lemma ne_of_odd_add (h : Odd (m + n)) : m ≠ n
-- .lake/packages/batteries/Batteries/Data/List/EraseIdx.lean
@[deprecated mem_eraseIdx_iff_getElem? (since := "2024-06-12")]
theorem mem_eraseIdx_iff_get? {x : α} {l} {k} : x ∈ eraseIdx l k ↔ ∃ i ≠ k, l.get? i = x
-- Mathlib/Order/Lattice.lean
theorem SemilatticeSup.ext {α} {A B : SemilatticeSup α}
    (H : ∀ x y : α, (haveI := A; x ≤ y) ↔ x ≤ y) :
    A = B
-- Mathlib/Topology/ContinuousOn.lean
theorem ContinuousOn.mono {f : α → β} {s t : Set α} (hf : ContinuousOn f s) (h : t ⊆ s) :
    ContinuousOn f t
-- Mathlib/Computability/Partrec.lean
theorem of_eq_tot {f : ℕ →. ℕ} {g : ℕ → ℕ} (hf : Partrec f) (H : ∀ n, g n ∈ f n) : Partrec g
-- Mathlib/Algebra/Quandle.lean
@[simp]
theorem op_act_op_eq {x y : R} : op x ◃ op y = op (x ◃⁻¹ y)
-- Mathlib/RingTheory/WittVector/IsPoly.lean
/-- A binary function `f : Π R, 𝕎 R → 𝕎 R → 𝕎 R` on Witt vectors
is said to be *polynomial* if there is a family of polynomials `φₙ` over `ℤ` such that the `n`th
coefficient of `f x y` is given by evaluating `φₙ` at the coefficients of `x` and `y`.

See also `WittVector.IsPoly` for the unary variant.

The `ghost_calc` tactic makes use of the `IsPoly` and `IsPoly₂` typeclass and its instances.
(In Lean 3, there was an `@[is_poly]` attribute to manage these instances,
because typeclass resolution did not play well with function composition.
This no longer seems to be an issue, so that such instances can be defined directly.)
-/
class IsPoly₂ (f : ∀ ⦃R⦄ [CommRing R], WittVector p R → 𝕎 R → 𝕎 R) : Prop where mk' ::
  poly :
    ∃ φ : ℕ → MvPolynomial (Fin 2 × ℕ) ℤ,
      ∀ ⦃R⦄ [CommRing R] (x y : 𝕎 R), (f x y).coeff = fun n => peval (φ n) ![x.coeff, y.coeff]
-- .lake/packages/lean4/src/lean/Init/ByCases.lean
@[simp] theorem ite_eq_right_iff {P : Prop} [Decidable P] : ite P a b = b ↔ P → a = b
-- Mathlib/Analysis/RCLike/Basic.lean
theorem normSq_add (z w : K) : normSq (z + w) = normSq z + normSq w + 2 * re (z * conj w)
-- Mathlib/Algebra/Group/AddChar.lean
lemma compAddMonoidHom_injective_left (f : A →+ B) (hf : Surjective f) :
    Injective fun ψ : AddChar B M ↦ ψ.compAddMonoidHom f
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
@[simp]
theorem condexpInd_empty : condexpInd G hm μ ∅ = (0 : G →L[ℝ] α →₁[μ] G)
-- Mathlib/Analysis/Calculus/ContDiff/RCLike.lean
/-- If `f` is `C^1`, it is locally Lipschitz. -/
lemma ContDiff.locallyLipschitz {f : E' → F'} (hf : ContDiff 𝕂 1 f) : LocallyLipschitz f
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem dual_Ioc : Ioc (toDual a) (toDual b) = ofDual ⁻¹' Ico b a
-- Mathlib/Data/Set/Finite.lean
/-- A finite set is bounded below. -/
protected theorem Finite.bddBelow (hs : s.Finite) : BddBelow s
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
theorem treesOfNumNodesEq_card_eq_catalan (n : ℕ) : (treesOfNumNodesEq n).card = catalan n
-- Mathlib/ModelTheory/Definability.lean
theorem Definable.image_comp_equiv {s : Set (β → M)} (h : A.Definable L s) (f : α ≃ β) :
    A.Definable L ((fun g : β → M => g ∘ f) '' s)
-- Mathlib/Algebra/Order/Floor/Div.lean
lemma support_ceilDiv_subset : (f ⌈/⌉ a).support ⊆ f.support
-- Mathlib/Order/BoundedOrder.lean
@[simp] theorem down_top [Top α] : down (⊤ : ULift α) = ⊤
-- Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean
@[simp]
theorem ι_range_map_involute :
    (ι Q).range.map (involute : CliffordAlgebra Q →ₐ[R] CliffordAlgebra Q).toLinearMap =
      LinearMap.range (ι Q)
-- Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean
/-- `P` is a sheaf for `R`, iff the fork given by `w` is an equalizer.
See <https://stacks.math.columbia.edu/tag/00VM>.
-/
theorem sheaf_condition : R.IsSheafFor P ↔ Nonempty (IsLimit (Fork.ofι _ (w P R)))
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
protected theorem span_apply [DecidableEq E] {v' : ι' → E} (h : Orthonormal 𝕜 v') (s : Finset ι')
    (i : s) : (OrthonormalBasis.span h s i : E) = v' i
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Let `f : ℝ → ℝ` be a differentiable function. If `f'` is nonpositive, then
`f` is an antitone function. -/
theorem antitone_of_deriv_nonpos {f : ℝ → ℝ} (hf : Differentiable ℝ f) (hf' : ∀ x, deriv f x ≤ 0) :
    Antitone f