ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Icc_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Icc a b = Icc (b / c) (a / c)
-- Mathlib/AlgebraicTopology/FundamentalGroupoid/Basic.lean
@[simp]
lemma subsingleton_iff (X : Type*) :
    Subsingleton (FundamentalGroupoid X) ↔ Subsingleton X
-- Mathlib/Data/Seq/Computation.lean
theorem bind_promises {s : Computation α} {f : α → Computation β} {a b} (h1 : s ~> a)
    (h2 : f a ~> b) : bind s f ~> b
-- Mathlib/Topology/Algebra/ProperConstSMul.lean
/-- A mixin typeclass saying that the `(c +ᵥ ·)` is a proper map for all `c`.

Note that this is **not** the same as a proper additive action (not yet in `Mathlib`). -/
class ProperConstVAdd (M X : Type*) [VAdd M X] [TopologicalSpace X] : Prop where
  /-- `(c +ᵥ ·)` is a proper map. -/
  isProperMap_vadd (c : M) : IsProperMap ((c +ᵥ ·) : X → X)
-- Mathlib/Topology/Algebra/WithZeroTopology.lean
theorem hasBasis_nhds_units (γ : Γ₀ˣ) :
    HasBasis (𝓝 (γ : Γ₀)) (fun _ : Unit => True) fun _ => {↑γ}
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem of_eq_top_imp_eq_top {μ' : Measure α} (h : ∀ s, MeasurableSet s → μ s = ∞ → μ' s = ∞)
    (hT : FinMeasAdditive μ T) : FinMeasAdditive μ' T
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
/-- The range of a surjective semigroup hom is the whole of the codomain. -/
@[to_additive (attr := simp)
  "The range of a surjective `AddSemigroup` hom is the whole of the codomain."]
theorem srange_top_of_surjective {N} [Mul N] (f : M →ₙ* N) (hf : Function.Surjective f) :
    f.srange = (⊤ : Subsemigroup N)
-- Mathlib/Topology/Algebra/ConstMulAction.lean
theorem continuous_const_smul_iff₀ (hc : c ≠ 0) : (Continuous fun x => c • f x) ↔ Continuous f
-- Mathlib/LinearAlgebra/Determinant.lean
@[simp]
theorem det_toLin' (f : Matrix ι ι R) : LinearMap.det (Matrix.toLin' f) = Matrix.det f
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem get_swap_right (a : Array α) {i j : Fin a.size} : (a.swap i j)[j.val] = a[i]
-- Mathlib/Topology/Compactness/Compact.lean
theorem IsCompact.image_of_continuousOn {f : X → Y} (hs : IsCompact s) (hf : ContinuousOn f s) :
    IsCompact (f '' s)
-- Mathlib/RingTheory/Etale/Basic.lean
/-- An `R`-algebra `A` is étale if it is formally étale and of finite presentation.

Note that the definition <https://stacks.math.columbia.edu/tag/00U1> in the stacks project is
different, but <https://stacks.math.columbia.edu/tag/00UR> shows that it is equivalent
to the definition here. -/
class Etale : Prop where
  formallyEtale : FormallyEtale R A := by infer_instance
  finitePresentation : FinitePresentation R A := by infer_instance
-- Mathlib/Algebra/Lie/Nilpotent.lean
/-- If the quotient of a Lie module `M` by a Lie submodule on which the Lie algebra acts trivially
is nilpotent then `M` is nilpotent.

This is essentially the Lie module equivalent of the fact that a central
extension of nilpotent Lie algebras is nilpotent. See `LieAlgebra.nilpotent_of_nilpotent_quotient`
below for the corresponding result for Lie algebras. -/
theorem nilpotentOfNilpotentQuotient {N : LieSubmodule R L M} (h₁ : N ≤ maxTrivSubmodule R L M)
    (h₂ : IsNilpotent R L (M ⧸ N)) : IsNilpotent R L M
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive]
lemma pow_mul_comm' (a : M) (n : ℕ) : a ^ n * a = a * a ^ n
-- Mathlib/Data/Finsupp/Lex.lean
theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
    Finsupp.Lex r s = InvImage (DFinsupp.Lex r fun _ ↦ s) toDFinsupp
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- The valuation on the completion agrees with the global valuation on elements of the field. -/
theorem valuedAdicCompletion_eq_valuation' (k : K) :
    Valued.v (k : v.adicCompletion K) = v.valuation k
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Ico_coe_coe : Ico (a : WithTop α) b = (Ico a b).map Embedding.some
-- Mathlib/RingTheory/PowerBasis.lean
/-- `pb.liftEquiv` states that roots of the minimal polynomial of `pb.gen` correspond to
maps sending `pb.gen` to that root.

This is the bundled equiv version of `PowerBasis.lift`.
If the codomain of the `AlgHom`s is an integral domain, then the roots form a multiset,
see `liftEquiv'` for the corresponding statement.
-/
@[simps]
noncomputable def liftEquiv (pb : PowerBasis A S) :
    (S →ₐ[A] S') ≃ { y : S' // aeval y (minpoly A pb.gen) = 0 }
-- Mathlib/Algebra/Group/UniqueProds.lean
/-- If a group has `UniqueProds`, then it actually has `TwoUniqueProds`.
  For an example of a semigroup `G` embeddable into a group that has `UniqueProds`
  but not `TwoUniqueProds`, see Example 10.13 in
  [J. Okniński, *Semigroup Algebras*][Okninski1991]. -/
@[to_additive] theorem toTwoUniqueProds_of_group {G}
    [Group G] [UniqueProds G] : TwoUniqueProds G
-- Mathlib/Data/Real/Basic.lean
theorem ofCauchy_inv {f} : (⟨f⁻¹⟩ : ℝ) = ⟨f⟩⁻¹
-- Mathlib/NumberTheory/Bertrand.lean
/-- The inequality which contradicts Bertrand's postulate, for large enough `n`.
-/
theorem bertrand_main_inequality {n : ℕ} (n_large : 512 ≤ n) :
    n * (2 * n) ^ sqrt (2 * n) * 4 ^ (2 * n / 3) ≤ 4 ^ n
-- Mathlib/Data/Countable/Defs.lean
theorem Countable.of_equiv (α : Sort*) [Countable α] (e : α ≃ β) : Countable β
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem dyadicMap_apply_pow (m : ℤ) (n : ℕ) :
    dyadicMap (IsLocalization.mk' (Localization (Submonoid.powers 2)) m (Submonoid.pow 2 n)) =
      m • powHalf n
-- Mathlib/RingTheory/MatrixAlgebra.lean
@[simp (high)]
theorem matrixEquivTensor_apply_std_basis (i j : n) (x : A) :
    matrixEquivTensor R A n (stdBasisMatrix i j x) = x ⊗ₜ stdBasisMatrix i j 1
-- Mathlib/Probability/Independence/Kernel.lean
@[symm]
theorem Indep.symm {m₁ m₂ : MeasurableSpace Ω} {_mΩ : MeasurableSpace Ω} {κ : Kernel α Ω}
    {μ : Measure α} (h : Indep m₁ m₂ κ μ) :
    Indep m₂ m₁ κ μ
-- Mathlib/GroupTheory/QuotientGroup.lean
@[to_additive (attr := simp)]
theorem mk_prod {G ι : Type*} [CommGroup G] (N : Subgroup G) (s : Finset ι) {f : ι → G} :
    ((Finset.prod s f : G) : G ⧸ N) = Finset.prod s (fun i => (f i : G ⧸ N))
-- Mathlib/Algebra/Order/Group/Lattice.lean
@[to_additive] lemma inv_inf (a b : α) : (a ⊓ b)⁻¹ = a⁻¹ ⊔ b⁻¹
-- Mathlib/Data/Option/Basic.lean
theorem mem_pmem {a : α} (h : ∀ a ∈ x, p a) (ha : a ∈ x) : f a (h a ha) ∈ pmap f x h
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem ContinuousWithinAt.inv (hf : ContinuousWithinAt f s x) :
    ContinuousWithinAt (fun x => (f x)⁻¹) s x
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma liftCycles_i {A : C} (k : A ⟶ K.X i) (j : ι) (hj : c.next i = j)
    (hk : k ≫ K.d i j = 0) : K.liftCycles k j hj hk ≫ K.iCycles i = k
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem smul_set_inter₀ (ha : a ≠ 0) : a • (s ∩ t) = a • s ∩ a • t
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem Sublist.erase_diff_erase_sublist {a : α} :
    ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → (l₂.erase a).diff (l₁.erase a) <+ l₂.diff l₁
-- Mathlib/Order/PFilter.lean
@[simp]
theorem inf_mem_iff : x ⊓ y ∈ F ↔ x ∈ F ∧ y ∈ F
-- Mathlib/Analysis/Calculus/Implicit.lean
theorem left_map_implicitFunction :
    ∀ᶠ p : F × G in 𝓝 (φ.prodFun φ.pt), φ.leftFun (φ.implicitFunction p.1 p.2) = p.1
-- Mathlib/RingTheory/IsAdjoinRoot.lean
@[simp]
theorem ofEquiv_root (h : IsAdjoinRoot S f) (e : S ≃ₐ[R] T) : (h.ofEquiv e).root = e h.root
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
@[simp]
theorem denom_C (c : K) : denom (C c) = 1
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
/-- Algebra isomorphism between `R[X]` and `R[ℕ]`. This is just an
implementation detail, but it can be useful to transfer results from `Finsupp` to polynomials. -/
@[simps!]
def toFinsuppIsoAlg : R[X] ≃ₐ[R] R[ℕ]
-- Mathlib/Data/Real/Hyperreal.lean
theorem st_add {x y : ℝ*} (hx : ¬Infinite x) (hy : ¬Infinite y) : st (x + y) = st x + st y
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive]
theorem mk_surjective : Surjective (@mk M N _ _)
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem map_injective_of_injective : Function.Injective (map f)
-- Mathlib/Analysis/SumOverResidueClass.lean
lemma Finset.sum_indicator_mod {R : Type*} [AddCommMonoid R] (m : ℕ) [NeZero m] (f : ℕ → R) :
    f = ∑ a : ZMod m, {n : ℕ | (n : ZMod m) = a}.indicator f
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem toFinsupp_algebraMap (r : R) : (algebraMap R A[X] r).toFinsupp = algebraMap R _ r
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
/-- In a linearly ordered monoid, we are happy for `bot_eq_one` to be a `@[simp]` lemma. -/
@[to_additive (attr := simp)
  "In a linearly ordered monoid, we are happy for `bot_eq_zero` to be a `@[simp]` lemma"]
theorem bot_eq_one' : (⊥ : α) = 1
-- Mathlib/FieldTheory/KummerExtension.lean
lemma root_X_pow_sub_C_ne_zero {n : ℕ} (hn : 1 < n) (a : K) :
    (AdjoinRoot.root (X ^ n - C a)) ≠ 0
-- Mathlib/Order/RelClasses.lean
lemma eq_of_superset_of_not_ssuperset [IsAntisymm α (· ⊆ ·)] (hab : a ⊆ b) (hba : ¬ a ⊂ b) :
    b = a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem nnnorm_le_of_ae_bound [IsFiniteMeasure μ] {f : Lp E p μ} {C : ℝ≥0}
    (hfC : ∀ᵐ x ∂μ, ‖f x‖₊ ≤ C) : ‖f‖₊ ≤ measureUnivNNReal μ ^ p.toReal⁻¹ * C
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
theorem length_bypass_le {u v : V} (p : G.Walk u v) : p.bypass.length ≤ p.length
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
lemma of_fac {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) (ha : p.obj a = R) (hb : p.obj b = S)
    (h : f = eqToHom ha.symm ≫ p.map φ ≫ eqToHom hb) : p.IsHomLift f φ
-- Mathlib/Analysis/LocallyConvex/Polar.lean
@[simp]
theorem polar_zero : B.polar ({0} : Set E) = Set.univ
-- Mathlib/Algebra/BigOperators/Pi.lean
@[to_additive (attr := simp)]
theorem Finset.prod_apply {α : Type*} {β : α → Type*} {γ} [∀ a, CommMonoid (β a)] (a : α)
    (s : Finset γ) (g : γ → ∀ a, β a) : (∏ c ∈ s, g c) a = ∏ c ∈ s, g c a
-- Mathlib/Dynamics/Flow.lean
@[simp]
theorem map_zero : ϕ 0 = id
-- Mathlib/Algebra/Lie/Derivation/Basic.lean
@[simp]
theorem coe_sub (D1 D2 : LieDerivation R L M) : ⇑(D1 - D2) = D1 - D2
-- Mathlib/CategoryTheory/Abelian/Opposite.lean
theorem factorThruImage_comp_imageUnopOp_inv :
    factorThruImage g ≫ (imageUnopOp g).inv = (image.ι g.unop).op
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
/-- The wide coequalizer morphism in any colimit cocone is an epimorphism. -/
theorem epi_of_isColimit_parallelFamily [Nonempty J] {c : Cocone (parallelFamily f)}
    (i : IsColimit c) : Epi (c.ι.app one)
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem coe_sup : ⇑(f ⊔ g) = ⇑f ⊔ ⇑g
-- Mathlib/RingTheory/Derivation/Basic.lean
theorem leibniz_div (a b : K) : D (a / b) = b⁻¹ ^ 2 • (b • D a - a • D b)
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
protected theorem DifferentiableAt.fderivWithin (h : DifferentiableAt 𝕜 f x)
    (hxs : UniqueDiffWithinAt 𝕜 s x) : fderivWithin 𝕜 f s x = fderiv 𝕜 f x
-- Mathlib/Analysis/Normed/Algebra/Spectrum.lean
/-- In a complex Banach algebra, if every element of the spectrum has norm strictly less than
`r : ℝ≥0`, then the spectral radius is also strictly less than `r`. -/
theorem spectralRadius_lt_of_forall_lt {r : ℝ≥0} (hr : ∀ z ∈ spectrum ℂ a, ‖z‖₊ < r) :
    spectralRadius ℂ a < r
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
/-- `Finsupp.single 0` as an `AlgHom` -/
@[simps! apply]
def singleZeroAlgHom [CommSemiring R] [Semiring k] [Algebra R k] [AddMonoid G] : k →ₐ[R] k[G]
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem minimum?_nil [Min α] : ([] : List α).minimum? = none
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
lemma fundamentalDomain_pi_basisFun [Fintype ι] :
    fundamentalDomain (Pi.basisFun ℝ ι) = Set.pi Set.univ fun _ : ι ↦ Set.Ico (0 : ℝ) 1
-- Mathlib/Algebra/GCDMonoid/Basic.lean
theorem associated_normalize_iff {x y : α} : Associated x (normalize y) ↔ Associated x y
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- Given a σ-finite measure, any measurable set can be approximated from inside by a measurable
set of finite measure. -/
lemma of_sigmaFinite [SigmaFinite μ] :
    InnerRegularWRT μ (fun s ↦ MeasurableSet s ∧ μ s ≠ ∞) (fun s ↦ MeasurableSet s)
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem UniformContinuous.prod_mk {f₁ : α → β} {f₂ : α → γ} (h₁ : UniformContinuous f₁)
    (h₂ : UniformContinuous f₂) : UniformContinuous fun a => (f₁ a, f₂ a)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem coe_toSubmonoid (K : Subgroup G) : (K.toSubmonoid : Set G) = K
-- Mathlib/LinearAlgebra/Eigenspace/Basic.lean
theorem hasEigenvalue_iff_mem_spectrum [FiniteDimensional K V] {f : End K V} {μ : K} :
    f.HasEigenvalue μ ↔ μ ∈ spectrum K f
-- Mathlib/Data/Seq/Seq.lean
/-- If a sequence terminated at position `n`, it also terminated at `m ≥ n`. -/
theorem terminated_stable : ∀ (s : Seq α) {m n : ℕ}, m ≤ n → s.TerminatedAt m → s.TerminatedAt n
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
/-- For `p = 1` (hence, for any `p ≤ 1`), the condition `LiouvilleWith p x` is trivial. -/
theorem liouvilleWith_one (x : ℝ) : LiouvilleWith 1 x
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem isUnit_nonsing_inv_det (h : IsUnit A.det) : IsUnit A⁻¹.det
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem xn_ge_a_pow : ∀ n : ℕ, a ^ n ≤ xn a1 n
-- Mathlib/Geometry/Manifold/VectorBundle/Tangent.lean
@[simp, mfld_simps]
theorem mem_chart_source_iff (p q : TM) :
    p ∈ (chartAt (ModelProd H E) q).source ↔ p.1 ∈ (chartAt H q.1).source
-- Mathlib/Probability/ProbabilityMassFunction/Basic.lean
theorem apply_pos_iff (p : PMF α) (a : α) : 0 < p a ↔ a ∈ p.support
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem areaForm'_apply (x : E) :
    o.areaForm' x = LinearMap.toContinuousLinearMap (o.areaForm x)
-- Mathlib/CategoryTheory/Sites/LocallySurjective.lean
lemma isLocallySurjective_of_isLocallySurjective_of_isLocallyInjective
    {F₁ F₂ F₃ : Cᵒᵖ ⥤ A} (f₁ : F₁ ⟶ F₂) (f₂ : F₂ ⟶ F₃)
    [IsLocallySurjective J (f₁ ≫ f₂)] [IsLocallyInjective J f₂] :
    IsLocallySurjective J f₁
-- .lake/packages/lean4/src/lean/Init/Data/Char/Lemmas.lean
@[ext] theorem Char.ext : {a b : Char} → a.val = b.val → a = b
-- Mathlib/Algebra/CharP/Algebra.lean
/-- If a ring homomorphism `R →+* A` is injective and `R` has characteristic zero
then so does `A`. -/
theorem charZero_of_injective_ringHom {R A : Type*} [NonAssocSemiring R] [NonAssocSemiring A]
    {f : R →+* A} (h : Function.Injective f) [CharZero R] : CharZero A
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem sub {f g : ∀ i, E i} (hf : Memℓp f p) (hg : Memℓp g p) : Memℓp (f - g) p
-- Mathlib/Topology/Separation.lean
theorem SeparatedNhds.of_finset_finset [T2Space X] (s t : Finset X) (h : Disjoint s t) :
    SeparatedNhds (s : Set X) t
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- A subgroup is closed under multiplication. -/
@[to_additive "An `AddSubgroup` is closed under addition."]
protected theorem mul_mem {x y : G} : x ∈ H → y ∈ H → x * y ∈ H
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem testBit_bitwise
  (false_false_axiom : f false false = false) (x y i : Nat)
: (bitwise f x y).testBit i = f (x.testBit i) (y.testBit i)
-- Mathlib/Topology/Algebra/Group/OpenMapping.lean
/-- A surjective morphism of topological groups is open when the source group is sigma-compact and
the target group is a Baire space (for instance a locally compact group). -/
@[to_additive]
theorem MonoidHom.isOpenMap_of_sigmaCompact
    {H : Type*} [Group H] [TopologicalSpace H] [BaireSpace H] [T2Space H] [ContinuousMul H]
    (f : G →* H) (hf : Function.Surjective f) (h'f : Continuous f) :
    IsOpenMap f
-- Mathlib/SetTheory/Cardinal/Finite.lean
theorem card_image_of_injective {α : Type u} {β : Type v} (f : α → β) (s : Set α)
    (h : Function.Injective f) : card (f '' s) = card s
-- Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean
theorem eq_of_empty [IsEmpty α] (f g : C₀(α, β)) : f = g
-- Mathlib/Topology/Constructions.lean
lemma isClosedMap_swap : IsClosedMap (Prod.swap : X × Y → Y × X)
-- Mathlib/Analysis/Convex/Side.lean
theorem wSameSide_smul_vsub_vadd_left {s : AffineSubspace R P} {p₁ p₂ : P} (x : P) (hp₁ : p₁ ∈ s)
    (hp₂ : p₂ ∈ s) {t : R} (ht : 0 ≤ t) : s.WSameSide (t • (x -ᵥ p₁) +ᵥ p₂) x
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- We can prove two cocone points `(s : Cocone F).pt` and `(t : Cocone G).pt` are isomorphic if
* both cocones are colimit cocones
* their indexing categories are equivalent via some `e : J ≌ K`,
* the triangle of functors commutes up to a natural isomorphism: `e.functor ⋙ G ≅ F`.

This is the most general form of uniqueness of cocone points,
allowing relabelling of both the indexing category (up to equivalence)
and the functor (up to natural isomorphism).
-/
@[simps]
def coconePointsIsoOfEquivalence {F : J ⥤ C} {s : Cocone F} {G : K ⥤ C} {t : Cocone G}
    (P : IsColimit s) (Q : IsColimit t) (e : J ≌ K) (w : e.functor ⋙ G ≅ F) : s.pt ≅ t.pt
-- Mathlib/Data/Finset/Image.lean
theorem image_symmDiff [DecidableEq α] {f : α → β} (s t : Finset α) (hf : Injective f) :
    (s ∆ t).image f = s.image f ∆ t.image f
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive, field_simps]
theorem div_mul_eq_mul_div : a / b * c = a * c / b
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem range_top_iff_surjective {f : R →ₙ+* S} :
    f.range = (⊤ : NonUnitalSubring S) ↔ Function.Surjective f
-- Mathlib/Topology/Algebra/Module/Basic.lean
theorem LinearMap.continuous_on_pi {ι : Type*} {R : Type*} {M : Type*} [Finite ι] [Semiring R]
    [TopologicalSpace R] [AddCommMonoid M] [Module R M] [TopologicalSpace M] [ContinuousAdd M]
    [ContinuousSMul R M] (f : (ι → R) →ₗ[R] M) : Continuous f
-- Mathlib/Data/Fin/Tuple/Basic.lean
/-- `find p` returns `none` if and only if `p i` never holds. -/
theorem find_eq_none_iff {n : ℕ} {p : Fin n → Prop} [DecidablePred p] :
    find p = none ↔ ∀ i, ¬p i
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_le [LinearOrderedRing α] {m n : ZNum} : (m : α) ≤ n ↔ m ≤ n
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
theorem pow_inv_comm' (A : M) (m n : ℕ) : A⁻¹ ^ m * A ^ n = A ^ n * A⁻¹ ^ m
-- Mathlib/RingTheory/Filtration.lean
@[simp]
theorem mem_submodule (f : PolynomialModule R M) : f ∈ F.submodule ↔ ∀ i, f i ∈ F.N i
-- Mathlib/Topology/PartialHomeomorph.lean
theorem symm_image_target_inter_eq (s : Set Y) :
    e.symm '' (e.target ∩ s) = e.source ∩ e ⁻¹' (e.target ∩ s)
-- Mathlib/RingTheory/PowerSeries/WellKnown.lean
@[simp]
theorem coeff_invUnitsSub (u : Rˣ) (n : ℕ) : coeff R n (invUnitsSub u) = 1 /ₚ u ^ (n + 1)
-- Mathlib/Algebra/Group/Even.lean
@[to_additive]
lemma IsSquare.map [MulOneClass α] [MulOneClass β] [FunLike F α β] [MonoidHomClass F α β]
    {m : α} (f : F) :
    IsSquare m → IsSquare (f m)
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
theorem basisSets_mem (i : Finset ι) {r : ℝ} (hr : 0 < r) : (i.sup p).ball 0 r ∈ p.basisSets
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem C_1 : C (1 : R) = 1
-- Mathlib/Order/Partition/Finpartition.lean
theorem parts_eq_empty_iff : P.parts = ∅ ↔ a = ⊥
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
theorem Lex.mono (hr : ∀ a b, r₁ a b → r₂ a b) (hs : ∀ a b, s₁ a b → s₂ a b) (h : Lex r₁ s₁ x y) :
    Lex r₂ s₂ x y
-- Mathlib/Topology/Basic.lean
/-- If `x` is an accumulation point of `F` and `F ≤ G`, then
`x` is an accumulation point of `G`. -/
theorem AccPt.mono {F G : Filter X} (h : AccPt x F) (hFG : F ≤ G) : AccPt x G
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem adjugate_subsingleton [Subsingleton n] (A : Matrix n n α) : adjugate A = 1
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
nonrec theorem ContinuousAt.cpow (hf : ContinuousAt f a) (hg : ContinuousAt g a)
    (h0 : f a ∈ slitPlane) : ContinuousAt (fun x => f x ^ g x) a
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem intermediate_value_Ico' {a b : α} (hab : a ≤ b) {f : α → δ}
    (hf : ContinuousOn f (Icc a b)) : Ioc (f b) (f a) ⊆ f '' Ico a b
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive]
theorem pow_self (a : M) (n : ℕ) : Commute (a ^ n) a
-- Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean
lemma norm_integral_le_mul_norm [IsFiniteMeasure μ] (f : X →ᵇ E) :
    ‖∫ x, f x ∂μ‖ ≤ ENNReal.toReal (μ Set.univ) * ‖f‖
-- Mathlib/LinearAlgebra/CliffordAlgebra/BaseChange.lean
@[simp] theorem ofBaseChange_toBaseChange
    (Q : QuadraticForm R V) (x : CliffordAlgebra (Q.baseChange A)) :
    ofBaseChange A Q (toBaseChange A Q x) = x
-- Mathlib/CategoryTheory/Sites/Sieves.lean
lemma ofArrows_le_ofObjects
    {I : Type*} (Y : I → C) {X : C} (f : ∀ i, Y i ⟶ X) :
    Sieve.ofArrows Y f ≤ Sieve.ofObjects Y X
-- Mathlib/Data/Set/Image.lean
theorem range_ite_subset {p : α → Prop} [DecidablePred p] {f g : α → β} :
    (range fun x => if p x then f x else g x) ⊆ range f ∪ range g
-- Mathlib/Data/List/Range.lean
@[simp]
theorem unzip_enumFrom_eq_prod (l : List α) {n : ℕ} :
    (l.enumFrom n).unzip = (range' n l.length, l)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma toAffineLift_eq {P : Fin 3 → F} (hP : W.NonsingularLift ⟦P⟧) :
    toAffineLift ⟨hP⟩ = toAffine W P
-- Mathlib/Data/Complex/Exponential.lean
theorem cos_bound {x : ℝ} (hx : |x| ≤ 1) : |cos x - (1 - x ^ 2 / 2)| ≤ |x| ^ 4 * (5 / 96)
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem sumAddHom_single [∀ i, AddZeroClass (β i)] [AddCommMonoid γ] (φ : ∀ i, β i →+ γ) (i)
    (x : β i) : sumAddHom φ (single i x) = φ i x
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem abs_eq_one_iff (z : ℂ) : abs z = 1 ↔ ∃ θ : ℝ, exp (θ * I) = z
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
protected theorem Monotone.measurable [LinearOrder β] [OrderClosedTopology β] {f : β → α}
    (hf : Monotone f) : Measurable f
-- Mathlib/Analysis/Convex/Topology.lean
/-- In a topological vector space, the interior of a convex set is convex. -/
protected theorem Convex.interior {s : Set E} (hs : Convex 𝕜 s) : Convex 𝕜 (interior s)
-- Mathlib/Algebra/Group/Pi/Lemmas.lean
@[to_additive]
theorem Set.preimage_one {α β : Type*} [One β] (s : Set β) [Decidable ((1 : β) ∈ s)] :
    (1 : α → β) ⁻¹' s = if (1 : β) ∈ s then Set.univ else ∅
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp] theorem mem_sphere : y ∈ sphere x ε ↔ dist y x = ε
-- Mathlib/Data/Num/Lemmas.lean
@[simp, norm_cast]
theorem cast_one [One α] [Add α] : ((1 : PosNum) : α) = 1
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- See also `Finset.prod_pi_mulSingle`. -/
@[to_additive "See also `Finset.sum_pi_single`."]
lemma prod_pi_mulSingle {α : ι → Type*} [∀ i, CommMonoid (α i)] (i : ι) (f : ∀ i, α i) :
    ∏ j, Pi.mulSingle j (f j) i = f i
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
@[simp]
theorem coe_lTensorHom : (lTensorHom M : (N →ₗ[R] P) → M ⊗[R] N →ₗ[R] M ⊗[R] P) = lTensor M
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
/-- The one-edge subgraph. -/
@[simps]
def subgraphOfAdj (G : SimpleGraph V) {v w : V} (hvw : G.Adj v w) : G.Subgraph
-- Mathlib/Order/Hom/Lattice.lean
theorem coe_comp_inf_hom (f : BoundedLatticeHom β γ) (g : BoundedLatticeHom α β) :
    (f.comp g : InfHom α γ) = (f : InfHom β γ).comp g
-- Mathlib/Data/Finset/Pi.lean
@[simp]
theorem pi_val (s : Finset α) (t : ∀ a, Finset (β a)) : (s.pi t).1 = s.1.pi fun a => (t a).1
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem not_mem_uIcc_of_lt : c < a → c < b → c ∉ [[a, b]]
-- Mathlib/Analysis/Oscillation.lean
/-- The oscillation of `f` at `x` is 0 if and only if `f` is continuous at `x`. -/
theorem eq_zero_iff_continuousAt [TopologicalSpace E] (f : E → F) (x : E) :
    oscillation f x = 0 ↔ ContinuousAt f x
-- Mathlib/Data/Int/CardIntervalMod.lean
lemma Ico_filter_dvd_eq : (Ico a b).filter (r ∣ ·) =
    (Ico ⌈a / (r : ℚ)⌉ ⌈b / (r : ℚ)⌉).map ⟨(· * r), mul_left_injective₀ hr.ne'⟩
-- Mathlib/Algebra/Module/Basic.lean
lemma support_smul_subset_right [Zero M] [SMulZeroClass R M] (f : α → R) (g : α → M) :
    support (f • g) ⊆ support g
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem smul_finset_def : a • s = s.image (a • ·)
-- Mathlib/Order/CompactlyGenerated/Basic.lean
theorem IsSupClosedCompact.wellFounded (h : IsSupClosedCompact α) :
    WellFounded ((· > ·) : α → α → Prop)