ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Quaternion.lean
nonrec theorem self_add_star : a + star a = 2 * a.re
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
/-- A column partioned matrix when transposed gives a row partioned matrix with columns of the
initial matrix tranposed to become rows. -/
lemma transpose_fromColumns (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R) :
    transpose (fromColumns A₁ A₂) = fromRows (transpose A₁) (transpose A₂)
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
theorem neZero' {n : ℕ+} (hζ : IsPrimitiveRoot ζ n) : NeZero ((n : ℕ) : R)
-- Mathlib/GroupTheory/MonoidLocalization/MonoidWithZero.lean
/-- If `S` contains `0` then the localization at `S` is trivial. -/
theorem LocalizationMap.subsingleton  (f : Submonoid.LocalizationMap S N) (h : 0 ∈ S) :
    Subsingleton N
-- Mathlib/NumberTheory/Padics/RingHoms.lean
theorem zmod_congr_of_sub_mem_span (n : ℕ) (x : ℤ_[p]) (a b : ℕ)
    (ha : x - a ∈ (Ideal.span {(p : ℤ_[p]) ^ n}))
    (hb : x - b ∈ (Ideal.span {(p : ℤ_[p]) ^ n})) : (a : ZMod (p ^ n)) = b
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem PseudoMetricSpace.replaceBornology_eq {α} [m : PseudoMetricSpace α] [B : Bornology α]
    (H : ∀ s, @IsBounded _ B s ↔ @IsBounded _ PseudoMetricSpace.toBornology s) :
    PseudoMetricSpace.replaceBornology _ H = m
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem le_bsup {o} (f : ∀ a < o, Ordinal) (i h) : f i h ≤ bsup o f
-- Mathlib/Algebra/Algebra/Tower.lean
theorem span_smul_of_span_eq_top {s : Set S} (hs : span R s = ⊤) (t : Set A) :
    span R (s • t) = (span S t).restrictScalars R
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem measure_toMeasurable_add_inter_right {s t : Set α} (hs : MeasurableSet s)
    (ht : (μ + ν) t ≠ ∞) : ν (toMeasurable (μ + ν) t ∩ s) = ν (t ∩ s)
-- Mathlib/RingTheory/Generators.lean
@[simp]
lemma Hom.toAlgHom_X (f : Hom P P') (i) : f.toAlgHom (.X i) = f.val i
-- Mathlib/Data/Multiset/Basic.lean
theorem lt_cons_self (s : Multiset α) (a : α) : s < a ::ₘ s
-- Mathlib/Geometry/Euclidean/PerpBisector.lean
theorem mem_perpBisector_iff_inner_eq :
    c ∈ perpBisector p₁ p₂ ↔ ⟪c -ᵥ p₁, p₂ -ᵥ p₁⟫ = (dist p₁ p₂) ^ 2 / 2
-- Mathlib/Analysis/Matrix.lean
@[simp]
theorem frobenius_norm_map_eq (A : Matrix m n α) (f : α → β) (hf : ∀ a, ‖f a‖ = ‖a‖) :
    ‖A.map f‖ = ‖A‖
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
@[simp]
nonrec theorem integral_add (hf : IntervalIntegrable f μ a b) (hg : IntervalIntegrable g μ a b) :
    ∫ x in a..b, f x + g x ∂μ = (∫ x in a..b, f x ∂μ) + ∫ x in a..b, g x ∂μ
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem sep_mem_eq : { x ∈ s | x ∈ t } = s ∩ t
-- Mathlib/Algebra/Lie/OfAssociative.lean
lemma LieSubalgebra.coe_ad (H : LieSubalgebra R L) (x y : H) :
    (ad R H x y : L) = ad R L x y
-- Mathlib/Analysis/Calculus/LineDeriv/QuadraticMap.lean
theorem lineDifferentiableAt (f : QuadraticMap 𝕜 E F) (a b : E) : LineDifferentiableAt 𝕜 f a b
-- Mathlib/Analysis/Convex/Hull.lean
/-- The convex hull of a set `s` is the minimal convex set that includes `s`. -/
@[simps! isClosed]
def convexHull : ClosureOperator (Set E)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem ofSet_source (s : Set α) : (PartialEquiv.ofSet s).source = s
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem adjoin_le_integralClosure {x : A} (hx : IsIntegral R x) :
    Algebra.adjoin R {x} ≤ integralClosure R A
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Order.lean
@[simp, norm_cast]
lemma inr_nonneg_iff {a : A} : 0 ≤ (a : Unitization ℂ A) ↔ 0 ≤ a
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
@[mono]
theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) :
    l₁.toFilterDistortion I c₁ ≤ l₂.toFilterDistortion I c₂
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem get_toList (n : ℕ) (hn : n < length (toList p x)) :
    (toList p x).get ⟨n, hn⟩ = (p ^ n) x
-- Mathlib/Analysis/Analytic/Basic.lean
theorem le_radius_of_summable_nnnorm (h : Summable fun n => ‖p n‖₊ * r ^ n) : ↑r ≤ p.radius
-- Mathlib/Analysis/Analytic/Within.lean
lemma HasFPowerSeriesWithinAt.mono {f : E → F} {p : FormalMultilinearSeries 𝕜 E F}
    {s t : Set E} {x : E} (h : HasFPowerSeriesWithinAt f p t x)
    (hs : s ⊆ t) : HasFPowerSeriesWithinAt f p s x
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem symm_dual_comp (g : BoundedOrderHom βᵒᵈ γᵒᵈ) (f : BoundedOrderHom αᵒᵈ βᵒᵈ) :
    BoundedOrderHom.dual.symm (g.comp f) =
      (BoundedOrderHom.dual.symm g).comp (BoundedOrderHom.dual.symm f)
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem moebius_ne_zero_iff_squarefree {n : ℕ} : μ n ≠ 0 ↔ Squarefree n
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem smoothWithinAt_proj {s : Set (TotalSpace F E)} {p : TotalSpace F E} :
    SmoothWithinAt (IB.prod 𝓘(𝕜, F)) IB (π F E) s p
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
@[simp]
theorem affineCombination_coord_eq_self [Fintype ι] (q : P) :
    (Finset.univ.affineCombination k b fun i => b.coord i q) = q
-- Mathlib/Order/ConditionallyCompleteLattice/Finset.lean
theorem Finset.Nonempty.csSup_eq_max' {s : Finset α} (h : s.Nonempty) : sSup ↑s = s.max' h
-- Mathlib/Data/Set/Lattice.lean
theorem iInter_eq_if {p : Prop} [Decidable p] (s : Set α) : ⋂ _ : p, s = if p then s else univ
-- Mathlib/Algebra/Module/Equiv/Basic.lean
theorem conj_apply_apply (e : M ≃ₗ[R] M₂) (f : Module.End R M) (x : M₂) :
    e.conj f x = e (f (e.symm x))
-- Mathlib/Data/PNat/Basic.lean
@[simp]
theorem natPred_lt_natPred {m n : ℕ+} : m.natPred < n.natPred ↔ m < n
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem intCast_im (z : ℤ) : (z : ℍ[R]).im = 0
-- Mathlib/Topology/Algebra/InfiniteSum/Ring.lean
theorem hasSum_mul_left_iff (h : a₂ ≠ 0) : HasSum (fun i ↦ a₂ * f i) (a₂ * a₁) ↔ HasSum f a₁
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem translate_iterate (x : ℝ) (n : ℕ) :
    (translate (Multiplicative.ofAdd x))^[n] = translate (Multiplicative.ofAdd <| ↑n * x)
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem opCoproductIsoProduct'_inv_comp_inj {c : Cofan Z} {f : Fan (op <| Z ·)}
    (hc : IsColimit c) (hf : IsLimit f) (b : α) :
    (opCoproductIsoProduct' hc hf).inv ≫ (c.inj b).op = f.proj b
-- Mathlib/Data/Set/Finite.lean
/-- Induction up to a finite set `S`. -/
theorem Finite.induction_to {C : Set α → Prop} {S : Set α} (h : S.Finite)
    (S0 : Set α) (hS0 : S0 ⊆ S) (H0 : C S0) (H1 : ∀ s ⊂ S, C s → ∃ a ∈ S \ s, C (insert a s)) :
    C S
-- Mathlib/SetTheory/Game/PGame.lean
private theorem le_trans_aux {x y z : PGame}
    (h₁ : ∀ {i}, y ≤ z → z ≤ x.moveLeft i → y ≤ x.moveLeft i)
    (h₂ : ∀ {j}, z.moveRight j ≤ x → x ≤ y → z.moveRight j ≤ y) (hxy : x ≤ y) (hyz : y ≤ z) :
    x ≤ z
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem refl_extend {a : X} : (Path.refl a).extend = fun _ => a
-- Mathlib/RingTheory/Noetherian.lean
/-- A sequence `f` of submodules of a noetherian module,
with `f (n+1)` disjoint from the supremum of `f 0`, ..., `f n`,
is eventually zero.
-/
theorem IsNoetherian.disjoint_partialSups_eventually_bot
    (f : ℕ → Submodule R M) (h : ∀ n, Disjoint (partialSups f n) (f (n + 1))) :
    ∃ n : ℕ, ∀ m, n ≤ m → f m = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem foldlM_append [Monad m] [LawfulMonad m] (f : β → α → m β) (b) (l l' : List α) :
    (l ++ l').foldlM f b = l.foldlM f b >>= l'.foldlM f
-- Mathlib/Algebra/Group/TypeTags.lean
@[simp]
theorem ofAdd_add [Add α] (x y : α) : ofAdd (x + y) = ofAdd x * ofAdd y
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
lemma setLIntegral_condKernel_univ_right (hf : Measurable f) (a : α) {s : Set β}
    (hs : MeasurableSet s) :
    ∫⁻ b in s, ∫⁻ ω, f (b, ω) ∂(Kernel.condKernel κ (a, b)) ∂(Kernel.fst κ a)
      = ∫⁻ x in s ×ˢ Set.univ, f x ∂(κ a)
-- Mathlib/RingTheory/Polynomial/Content.lean
theorem content_eq_zero_iff {p : R[X]} : content p = 0 ↔ p = 0
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIcc_of_not_le (h : ¬a ≤ b) : [[a, b]] = Icc b a
-- Mathlib/NumberTheory/Cyclotomic/PrimitiveRoots.lean
/-- If `Irreducible (cyclotomic (p ^ (k + 1)) K)` (in particular for `K = ℚ`) and `p` is a prime,
then the norm of `ζ ^ (p ^ s) - 1` is `p ^ (p ^ s)` if `k ≠ 0` and `s ≤ k`. -/
theorem norm_pow_sub_one_eq_prime_pow_of_ne_zero {k s : ℕ} (hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1)))
    [hpri : Fact (p : ℕ).Prime] [hcycl : IsCyclotomicExtension {p ^ (k + 1)} K L]
    (hirr : Irreducible (cyclotomic (↑(p ^ (k + 1)) : ℕ) K)) (hs : s ≤ k) (hk : k ≠ 0) :
    norm K (ζ ^ (p : ℕ) ^ s - 1) = (p : K) ^ (p : ℕ) ^ s
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem le_comap_map [RingHomSurjective σ₁₂] (f : F) (p : Submodule R M) : p ≤ comap f (map f p)
-- Mathlib/ModelTheory/Substructures.lean
@[simp, norm_cast]
theorem coe_iInf {ι : Sort*} {S : ι → L.Substructure M} :
    ((⨅ i, S i : L.Substructure M) : Set M) = ⋂ i, (S i : Set M)
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem zipWithAll_nil_left :
    zipWithAll f [] bs = bs.map fun b => f none (some b)
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotating the first of two vectors by `θ` scales their Kahler form by `cos θ - sin θ * I`. -/
@[simp]
theorem kahler_rotation_left (x y : V) (θ : Real.Angle) :
    o.kahler (o.rotation θ x) y = conj (θ.expMapCircle : ℂ) * o.kahler x y
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem total_equivMapDomain (f : α ≃ α') (l : α →₀ R) :
    (Finsupp.total α' M' R v') (equivMapDomain f l) = (Finsupp.total α M' R (v' ∘ f)) l
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem piecewise_ae_eq_of_ae_eq_set [DecidablePred (· ∈ s)] [DecidablePred (· ∈ t)]
    (hst : s =ᵐ[μ] t) : s.piecewise f g =ᵐ[μ] t.piecewise f g
-- Mathlib/Data/Finset/Image.lean
theorem mem_image_const_self : b ∈ s.image (const α b) ↔ s.Nonempty
-- Mathlib/Data/Nat/PartENat.lean
@[simp, norm_cast]
lemma ofENat_top : ofENat ⊤ = ⊤
-- Mathlib/Analysis/Convex/Between.lean
@[simp]
theorem AffineEquiv.sbtw_map_iff {x y z : P} (f : P ≃ᵃ[R] P') :
    Sbtw R (f x) (f y) (f z) ↔ Sbtw R x y z
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem monomial_sum_one {α : Type*} (s : Finset α) (f : α → σ →₀ ℕ) :
    (monomial (∑ i ∈ s, f i) 1 : MvPolynomial σ R) = ∏ i ∈ s, monomial (f i) 1
-- Mathlib/Topology/Order/LeftRightLim.lean
/-- An antitone function is continuous to the left at a point if and only if its left limit
coincides with the value of the function. -/
theorem continuousWithinAt_Iio_iff_leftLim_eq :
    ContinuousWithinAt f (Iio x) x ↔ leftLim f x = f x
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem ne_single_iff {n : ℕ} (hn : 0 < n) {c : Composition n} :
    c ≠ single n hn ↔ ∀ i, c.blocksFun i < n
-- Mathlib/MeasureTheory/Function/L2Space.lean
theorem memℒp_two_iff_integrable_sq_norm {f : α → F} (hf : AEStronglyMeasurable f μ) :
    Memℒp f 2 μ ↔ Integrable (fun x => ‖f x‖ ^ 2) μ
-- Mathlib/Data/Finset/Pointwise.lean
@[simp]
theorem vsub_empty (s : Finset β) : s -ᵥ (∅ : Finset β) = ∅
-- Mathlib/Algebra/Ring/Parity.lean
@[simp] lemma succ_mod_two_add_mod_two (m : ℕ) : (m + 1) % 2 + m % 2 = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_filterMap_of_inv (f : α → Option β) (g : β → α) (H : ∀ x : α, (f x).map g = some x)
    (l : List α) : map g (filterMap f l) = l
-- Mathlib/AlgebraicGeometry/Scheme.lean
theorem eqToHom_c_app {X Y : Scheme} (e : X = Y) (U) :
    (eqToHom e).app U = eqToHom (by subst e; rfl)
-- Mathlib/Data/Set/Lattice.lean
theorem seq_seq {s : Set (β → γ)} {t : Set (α → β)} {u : Set α} :
    seq s (seq t u) = seq (seq ((· ∘ ·) '' s) t) u
-- Mathlib/Topology/LocallyConstant/Algebra.lean
/-- `LocallyConstant.const` as an `AlgHom` -/
@[simps!]
def constₐ (R : Type*) [CommSemiring R] [Semiring Y] [Algebra R Y] :
    Y →ₐ[R] LocallyConstant X Y
-- Mathlib/Data/List/Rotate.lean
theorem getElem?_rotate {l : List α} {n m : ℕ} (hml : m < l.length) :
    (l.rotate n)[m]? = l[(m + n) % l.length]?
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem toFun_eq_coe (e : PartialHomeomorph X Y) : e.toFun = e
-- Mathlib/Order/SuccPred/Basic.lean
theorem Iio_succ_eq_insert (a : α) : Iio (succ a) = insert a (Iio a)
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem HasDerivWithinAt.congr_of_eventuallyEq_of_mem (h : HasDerivWithinAt f f' s x)
    (h₁ : f₁ =ᶠ[𝓝[s] x] f) (hx : x ∈ s) : HasDerivWithinAt f₁ f' s x
-- Mathlib/Algebra/BigOperators/NatAntidiagonal.lean
theorem sum_antidiagonal_succ {n : ℕ} {f : ℕ × ℕ → N} :
    (∑ p ∈ antidiagonal (n + 1), f p) = f (0, n + 1) + ∑ p ∈ antidiagonal n, f (p.1 + 1, p.2)
-- Mathlib/Algebra/Lie/Nilpotent.lean
@[simp]
theorem lcs_succ : I.lcs M (k + 1) = ⁅I, I.lcs M k⁆
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mul_eq_max_of_aleph0_le_right {a b : Cardinal} (h' : a ≠ 0) (h : ℵ₀ ≤ b) :
    a * b = max a b
-- Mathlib/Topology/Constructions.lean
@[continuity, fun_prop]
theorem Continuous.prod_mk {f : Z → X} {g : Z → Y} (hf : Continuous f) (hg : Continuous g) :
    Continuous fun x => (f x, g x)
-- Mathlib/Combinatorics/Quiver/Push.lean
@[simp]
theorem of_obj : (of σ).obj = σ
-- Mathlib/Data/Setoid/Partition.lean
/-- This lemma is analogous to `Quotient.mk_out'`. -/
@[simp]
theorem out_proj (x : α) : hs.out (hs.proj x) = hs.some (hs.index x)
-- Mathlib/Data/Set/Subset.lean
@[simp]
lemma cou_inter_self_right_eq_coe : A ∩ ↑D = ↑D
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If ∠ABC = π then dist C B ≠ 0. -/
theorem right_dist_ne_zero_of_angle_eq_pi {p1 p2 p3 : P} (h : ∠ p1 p2 p3 = π) : dist p3 p2 ≠ 0
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem ae (h : QuasiMeasurePreserving f μa μb) {p : β → Prop} (hg : ∀ᵐ x ∂μb, p x) :
    ∀ᵐ x ∂μa, p (f x)
-- Mathlib/Analysis/RCLike/Basic.lean
theorem isCauSeq_im (f : CauSeq K norm) : IsCauSeq abs fun n => im (f n)
-- Mathlib/GroupTheory/Coxeter/Basic.lean
theorem reindexGroupEquiv_apply_simple (i : B') :
    (M.reindexGroupEquiv e) ((M.reindex e).simple i) = M.simple (e.symm i)
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- Continuous linear maps between modules. We only put the type classes that are necessary for the
definition, although in applications `M` and `M₂` will be topological modules over the topological
ring `R`. -/
structure ContinuousLinearMap {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    (M : Type*) [TopologicalSpace M] [AddCommMonoid M] (M₂ : Type*) [TopologicalSpace M₂]
    [AddCommMonoid M₂] [Module R M] [Module S M₂] extends M →ₛₗ[σ] M₂ where
  cont : Continuous toFun := by continuity
-- Mathlib/LinearAlgebra/Contraction.lean
@[simp]
theorem zero_prodMap_dualTensorHom (g : Module.Dual R N) (q : Q) :
    (0 : M →ₗ[R] P).prodMap ((dualTensorHom R N Q) (g ⊗ₜ[R] q)) =
      dualTensorHom R (M × N) (P × Q) ((g ∘ₗ snd R M N) ⊗ₜ inr R P Q q)
-- Mathlib/Data/Finset/NAry.lean
theorem card_le_card_image₂_left {s : Finset α} (hs : s.Nonempty) (hf : ∀ a, Injective (f a)) :
    t.card ≤ (image₂ f s t).card
-- Mathlib/Data/Matroid/Basic.lean
theorem Indep.exists_base_superset (hI : M.Indep I) : ∃ B, M.Base B ∧ I ⊆ B
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
protected theorem map_sub (x y : E) : f (x - y) = f x - f y
-- Mathlib/Order/CompletePartialOrder.lean
protected lemma DirectedOn.isLUB_sSup : DirectedOn (· ≤ ·) d → IsLUB d (sSup d)
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem cos_add_int_mul_two_pi (x : ℂ) (n : ℤ) : cos (x + n * (2 * π)) = cos x
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasDerivAt.comp_hasFDerivWithinAt {f : E → 𝕜'} {f' : E →L[𝕜] 𝕜'} {s} (x)
    (hh : HasDerivAt h₂ h₂' (f x)) (hf : HasFDerivWithinAt f f' s x) :
    HasFDerivWithinAt (h₂ ∘ f) (h₂' • f') s x
-- Mathlib/Topology/Category/TopCat/Limits/Products.lean
theorem sigmaIsoSigma_inv_apply {ι : Type v} (α : ι → TopCat.{max v u}) (i : ι) (x : α i) :
    (sigmaIsoSigma α).inv ⟨i, x⟩ = (Sigma.ι α i : _) x
-- Mathlib/Order/Interval/Multiset.lean
theorem left_mem_Icc : a ∈ Icc a b ↔ a ≤ b
-- Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean
/-- The terms of the sequence are nonzero. -/
theorem seq_ne_zero (n : ℕ) : algebraMap (𝓞 K) K (seq K w₁ hB n) ≠ 0
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem mem_filter {a : α} {s} : a ∈ filter p s ↔ a ∈ s ∧ p a
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem ContDiff.rpow (hf : ContDiff ℝ n f) (hg : ContDiff ℝ n g) (h : ∀ x, f x ≠ 0) :
    ContDiff ℝ n fun x => f x ^ g x
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem differentiableOn_apply (i : ι) (s' : Set (∀ i, F' i)) :
    DifferentiableOn (𝕜 := 𝕜) (fun f : ∀ i, F' i => f i) s'
-- Mathlib/Topology/Compactness/SigmaCompact.lean
theorem subset_interior ⦃m n : ℕ⦄ (h : m < n) : K m ⊆ interior (K n)
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem le_integralClosure_iff_isIntegral {S : Subalgebra R A} :
    S ≤ integralClosure R A ↔ Algebra.IsIntegral R S
-- Mathlib/Algebra/Order/Field/Pi.lean
theorem Pi.exists_forall_pos_add_lt [ExistsAddOfLE α] [Finite ι] {x y : ι → α}
    (h : ∀ i, x i < y i) : ∃ ε, 0 < ε ∧ ∀ i, x i + ε < y i
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_neg_of_neg_of_nonpos {a b : Int} (ha : a < 0) (hb : b ≤ 0) : a + b < 0
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[simp]
theorem leftUnitor_inv (X : C) : (λ_ X).inv = prod.lift (terminal.from X) (𝟙 _)
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem HasFiniteIntegral.neg {f : α → β} (hfi : HasFiniteIntegral f μ) :
    HasFiniteIntegral (-f) μ
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[simp] lemma norm_eq_zero (x : PUnit) : ‖x‖ = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma ofJ0_j [Invertible (3 : R)] : (ofJ0 R).j = 0
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
lemma tendsto_measure_Icc [NoAtoms μ] (b : ℝ) :
    Tendsto (fun δ ↦ μ (Icc (b - δ) (b + δ))) (𝓝 (0 : ℝ)) (𝓝 0)
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
/-- If `R` is a Noetherian ring and `M` is a finite `R`-module, then the natural map
given by `AdicCompletion.ofTensorProduct` is an isomorphism. -/
theorem ofTensorProduct_bijective_of_finite_of_isNoetherian [Module.Finite R M] :
    Function.Bijective (ofTensorProduct I M)
-- Mathlib/Analysis/BoxIntegral/Partition/Filter.lean
theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
    (hr : ∀ J ∈ π, r₁ (π.tag J) ≤ r₂ (π.tag J)) (hπ : l₁.MemBaseSet I c₁ r₁ π) :
    l₂.MemBaseSet I c₂ r₂ π
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
theorem toNNReal_pow (a : ℝ≥0∞) (n : ℕ) : (a ^ n).toNNReal = a.toNNReal ^ n
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem derivWithin.scomp_of_eq (hg : DifferentiableWithinAt 𝕜' g₁ t' y)
    (hh : DifferentiableWithinAt 𝕜 h s x) (hs : MapsTo h s t') (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hy : y = h x) :
    derivWithin (g₁ ∘ h) s x = derivWithin h s x • derivWithin g₁ t' (h x)
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem map_expand_pow_char (f : R[X]) (n : ℕ) :
    map (frobenius R p ^ n) (expand R (p ^ n) f) = f ^ p ^ n
-- Mathlib/Order/SymmDiff.lean
@[simp]
theorem symmDiff_sdiff_right : a ∆ b \ b = a \ b
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem some_get : ∀ {x : Option α} (h : isSome x), some (x.get h) = x
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_count' {f : α → ℝ≥0∞} (hf : Measurable f) : ∫⁻ a, f a ∂count = ∑' a, f a
-- Mathlib/Probability/IdentDistrib.lean
protected theorem pow [Pow γ ℕ] [MeasurablePow γ ℕ] (h : IdentDistrib f g μ ν) {n : ℕ} :
    IdentDistrib (fun x => f x ^ n) (fun x => g x ^ n) μ ν
-- Mathlib/Data/Set/Image.lean
/-- The range of a function from a `Unique` type contains just the
function applied to its single value. -/
theorem range_unique [h : Unique ι] : range f = {f default}
-- Mathlib/CategoryTheory/Limits/ConeCategory.lean
theorem hasColimitsOfShape_iff_isRightAdjoint_const :
    HasColimitsOfShape J C ↔ IsRightAdjoint (const J : C ⥤ _)
-- Mathlib/Topology/Constructions.lean
@[continuity]
theorem continuous_uLift_down [TopologicalSpace X] : Continuous (ULift.down : ULift.{v, u} X → X)
-- .lake/packages/lean4/src/lean/Init/System/ST.lean
structure Ref (σ : Type) (α : Type) : Type where
  ref : RefPointed.type
  h   : Nonempty α
-- Mathlib/Data/Finset/Basic.lean
theorem sdiff_singleton_eq_erase (a : α) (s : Finset α) : s \ singleton a = erase s a
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem ker_id : (LieModuleHom.id : M →ₗ⁅R,L⁆ M).ker = ⊥
-- Mathlib/Order/RelIso/Basic.lean
protected theorem isIrrefl (f : r ↪r s) [IsIrrefl β s] : IsIrrefl α r
-- Mathlib/Order/WithBot.lean
@[simp] lemma map₂_eq_top_iff {f : α → β → γ} {a : WithTop α} {b : WithTop β} :
    map₂ f a b = ⊤ ↔ a = ⊤ ∨ b = ⊤
-- Mathlib/RingTheory/Ideal/Pointwise.lean
@[simp]
theorem smul_bot (a : M) : a • (⊥ : Ideal R) = ⊥
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem NeBot.of_smul_right : (f • g).NeBot → g.NeBot
-- Mathlib/Data/Nat/Bits.lean
@[simp]
theorem bit1_bits (n : ℕ) : (2 * n + 1).bits = true :: n.bits
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem crossing_pos_eq (hab : a < b) :
    upperCrossingTime 0 (b - a) (fun n ω => (f n ω - a)⁺) N n = upperCrossingTime a b f N n ∧
      lowerCrossingTime 0 (b - a) (fun n ω => (f n ω - a)⁺) N n = lowerCrossingTime a b f N n
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- Given `u : α → β` a uniform inducing map, a family `𝓕 : ι → X → α` is equicontinuous at a point
`x₀ : X` within a subset `S : Set X` iff the family `𝓕'`, obtained by composing each function
of `𝓕` by `u`, is equicontinuous at `x₀` within `S`. -/
theorem UniformInducing.equicontinuousWithinAt_iff {F : ι → X → α} {S : Set X} {x₀ : X} {u : α → β}
    (hu : UniformInducing u) : EquicontinuousWithinAt F S x₀ ↔
      EquicontinuousWithinAt ((u ∘ ·) ∘ F) S x₀
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem mem_top (x : R) : x ∈ (⊤ : Subsemiring R)
-- Mathlib/Probability/Independence/Kernel.lean
lemma iIndep.meas_iInter [Fintype ι] (h : iIndep m κ μ) (hs : ∀ i, MeasurableSet[m i] (s i)) :
    ∀ᵐ a ∂μ, κ a (⋂ i, s i) = ∏ i, κ a (s i)
-- Mathlib/CategoryTheory/Limits/ConcreteCategory.lean
theorem isColimit_exists_of_rep_eq {D : Cocone F} {i j : J} (hD : IsColimit D)
    (x : F.obj i) (y : F.obj j) (h : D.ι.app _ x = D.ι.app _ y) :
    ∃ (k : _) (f : i ⟶ k) (g : j ⟶ k), F.map f x = F.map g y
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.measurable_stieltjesFunction (x : ℝ) :
    Measurable fun a ↦ hf.stieltjesFunction a x
-- Mathlib/Algebra/DirectSum/Basic.lean
theorem support_subset [DecidableEq ι] [DecidableEq M] (A : ι → S) (x : DirectSum ι fun i => A i) :
    (Function.support fun i => (x i : M)) ⊆ ↑(DFinsupp.support x)
-- Mathlib/Topology/Bases.lean
lemma IsTopologicalBasis.subset_of_forall_subset {t : Set α} (hB : IsTopologicalBasis B)
    (hs : IsOpen s) (h : ∀ U ∈ B, U ⊆ s → U ⊆ t) : s ⊆ t
-- Mathlib/Topology/Algebra/FilterBasis.lean
@[to_additive]
theorem inv {U : Set G} : U ∈ B → ∃ V ∈ B, V ⊆ (fun x ↦ x⁻¹) ⁻¹' U
-- Mathlib/RingTheory/PowerSeries/Basic.lean
theorem coeff_ne_zero_C {a : R} {n : ℕ} (h : n ≠ 0) : coeff R n (C R a) = 0
-- Mathlib/LinearAlgebra/Dimension/Basic.lean
/-- If `M / R` and `M' / R'` are modules, `i : R' → R` is a map which sends non-zero elements to
non-zero elements, `j : M →+ M'` is an injective group homomorphism, such that the scalar
multiplications on `M` and `M'` are compatible, then the rank of `M / R` is smaller than or equal to
the rank of `M' / R'`. As a special case, taking `R = R'` it is
`LinearMap.lift_rank_le_of_injective`. -/
theorem lift_rank_le_of_injective_injective (i : R' → R) (j : M →+ M')
    (hi : ∀ r, i r = 0 → r = 0) (hj : Injective j)
    (hc : ∀ (r : R') (m : M), j (i r • m) = r • j m) :
    lift.{v'} (Module.rank R M) ≤ lift.{v} (Module.rank R' M')