ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/Adjoin/Basic.lean
@[elab_as_elim]
theorem adjoin_induction'' {x : A} (hx : x ∈ adjoin R s)
    {p : (x : A) → x ∈ adjoin R s → Prop} (mem : ∀ x (h : x ∈ s), p x (subset_adjoin h))
    (algebraMap : ∀ (r : R), p (algebraMap R A r) (algebraMap_mem _ r))
    (add : ∀ x hx y hy, p x hx → p y hy → p (x + y) (add_mem hx hy))
    (mul : ∀ x hx y hy, p x hx → p y hy → p (x * y) (mul_mem hx hy)) :
    p x hx
-- Mathlib/Data/Finsupp/Basic.lean
theorem fst_sumFinsuppEquivProdFinsupp {α β γ : Type*} [Zero γ] (f : α ⊕ β →₀ γ) (x : α) :
    (sumFinsuppEquivProdFinsupp f).1 x = f (Sum.inl x)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma mk_XYIdeal'_mul_mk_XYIdeal'_of_Yeq {x y : F} (h : W.Nonsingular x y) :
    ClassGroup.mk (XYIdeal' <| nonsingular_neg h) * ClassGroup.mk (XYIdeal' h) = 1
-- Mathlib/Topology/Separation.lean
theorem Embedding.t25Space [TopologicalSpace Y] [T25Space Y] {f : X → Y} (hf : Embedding f) :
    T25Space X
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem ringHom_map_cast [Ring R] (f : R →+* ZMod n) (k : ZMod n) : f (cast k) = k
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
theorem congr_F {S₁ S₂ : Split C} {Φ₁ Φ₂ : S₁ ⟶ S₂} (h : Φ₁ = Φ₂) : Φ₁.f = Φ₂.f
-- Mathlib/Data/Matrix/Basic.lean
theorem mul_apply [Fintype m] [Mul α] [AddCommMonoid α] {M : Matrix l m α} {N : Matrix m n α}
    {i k} : (M * N) i k = ∑ j, M i j * N j k
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem tendsto_pure {f : α → β} {a : Filter α} {b : β} :
    Tendsto f a (pure b) ↔ ∀ᶠ x in a, f x = b
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem half_add_half_equiv_one : powHalf 1 + powHalf 1 ≈ 1
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma IsMeasurableRatCDF.stieltjesFunction_le_one (a : α) (x : ℝ) :
    hf.stieltjesFunction a x ≤ 1
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc (attr := simp)]
lemma RightHomologyData.homologyIso_inv_comp_homologyι (h : S.RightHomologyData) :
    h.homologyIso.inv ≫ S.homologyι = h.ι ≫ h.opcyclesIso.inv
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem eval₂_hom (x : R) : p.eval₂ f (f x) = f (p.eval x)
-- Mathlib/Order/RelSeries.lean
lemma length_eq_zero (irrefl : Irreflexive r) : s.length = 0 ↔ {x | x ∈ s}.Subsingleton
-- Mathlib/Probability/ProbabilityMassFunction/Integrals.lean
theorem integral_eq_sum [Fintype α] (p : PMF α) (f : α → E) :
    ∫ a, f a ∂(p.toMeasure) = ∑ a, (p a).toReal • f a
-- Mathlib/RingTheory/ZMod.lean
/-- `ZMod n` is reduced iff `n` is square-free (or `n=0`). -/
@[simp]
theorem isReduced_zmod {n : ℕ} : IsReduced (ZMod n) ↔ Squarefree n ∨ n = 0
-- Mathlib/Order/Heyting/Regular.lean
@[simp]
theorem toRegular_coe (a : Regular α) : toRegular (a : α) = a
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_add_one (a : α) : fract (a + 1) = fract a
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
theorem Integrable.condKernel_ae {f : α × Ω → F} (hf_int : Integrable f ρ) :
    ∀ᵐ a ∂ρ.fst, Integrable (fun ω ↦ f (a, ω)) (ρ.condKernel a)
-- Mathlib/CategoryTheory/Sites/Sieves.lean
protected theorem ext_iff {R S : Sieve X} : R = S ↔ ∀ ⦃Y⦄ (f : Y ⟶ X), R f ↔ S f
-- Mathlib/Algebra/Polynomial/UnitTrinomial.lean
theorem trinomial_mirror (hkm : k < m) (hmn : m < n) (hu : u ≠ 0) (hw : w ≠ 0) :
    (trinomial k m n u v w).mirror = trinomial k (n - m + k) n w v u
-- Mathlib/Data/PEquiv.lean
theorem symm_trans_self (f : α ≃. β) : f.symm.trans f = ofSet { b | (f.symm b).isSome }
-- Mathlib/MeasureTheory/Integral/RieszMarkovKakutani.lean
/-- The Riesz content can be approximated arbitrarily well by evaluating the positive linear
functional on test functions: for any `ε > 0`, there exists a bounded continuous nonnegative
function f on X such that `f ≥ 1` on K and such that `λ(K) ≤ Λ f < λ(K) + ε`. -/
theorem exists_lt_rieszContentAux_add_pos (K : Compacts X) {ε : ℝ≥0} (εpos : 0 < ε) :
    ∃ f : X →ᵇ ℝ≥0, (∀ x ∈ K, (1 : ℝ≥0) ≤ f x) ∧ Λ f < rieszContentAux Λ K + ε
-- Mathlib/Combinatorics/SimpleGraph/Operations.lean
lemma edge_edgeSet_of_ne (h : s ≠ t) : (edge s t).edgeSet = {s(s, t)}
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
lemma prod_sum_right {ι' : Type*} [Countable ι'] (m : Measure α) (m' : ι' → Measure β)
    [∀ n, SFinite (m' n)] :
    m.prod (Measure.sum m') = Measure.sum (fun p ↦ m.prod (m' p))
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[ext]
theorem ext {φ₁ φ₂ : A →ₗc[R] B} (H : ∀ x, φ₁ x = φ₂ x) : φ₁ = φ₂
-- Mathlib/Analysis/Convex/Side.lean
theorem SSameSide.trans_sOppSide {s : AffineSubspace R P} {x y z : P} (hxy : s.SSameSide x y)
    (hyz : s.SOppSide y z) : s.SOppSide x z
-- Mathlib/Analysis/NormedSpace/Exponential.lean
/-- In a commutative Banach-algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`,
`exp 𝕂 (x+y) = (exp 𝕂 x) * (exp 𝕂 y)`. -/
theorem exp_add {x y : 𝔸} : exp 𝕂 (x + y) = exp 𝕂 x * exp 𝕂 y
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
/-- The open set `ContinuousMap.setOfIdeal I` realized as a term of `opens X`. -/
@[simps]
def opensOfIdeal [T2Space R] (I : Ideal C(X, R)) : Opens X
-- Mathlib/RingTheory/WittVector/Basic.lean
@[simp]
theorem ghostEquiv_coe : (ghostEquiv p R : 𝕎 R →+* ℕ → R) = ghostMap
-- Mathlib/RingTheory/Polynomial/Bernstein.lean
/-- The Bernstein polynomials are linearly independent.

We prove by induction that the collection of `bernsteinPolynomial n ν` for `ν = 0, ..., k`
are linearly independent.
The inductive step relies on the observation that the `(n-k)`-th derivative, evaluated at 1,
annihilates `bernsteinPolynomial n ν` for `ν < k`, but has a nonzero value at `ν = k`.
-/
theorem linearIndependent (n : ℕ) :
    LinearIndependent ℚ fun ν : Fin (n + 1) => bernsteinPolynomial ℚ n ν
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem hasLineDerivAt_smul_iff {c : 𝕜} (hc : c ≠ 0) :
    HasLineDerivAt 𝕜 f (c • f') x (c • v) ↔ HasLineDerivAt 𝕜 f f' x v
-- Mathlib/Topology/Order/MonotoneContinuity.lean
/-- If a function `f` with a densely ordered codomain is monotone on a left neighborhood of `a` and
the closure of the image of this neighborhood under `f` is a left neighborhood of `f a`, then `f` is
continuous at `a` from the left -/
theorem continuousWithinAt_left_of_monotoneOn_of_closure_image_mem_nhdsWithin [DenselyOrdered β]
    {f : α → β} {s : Set α} {a : α} (hf : MonotoneOn f s) (hs : s ∈ 𝓝[≤] a)
    (hfs : closure (f '' s) ∈ 𝓝[≤] f a) : ContinuousWithinAt f (Iic a) a
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
theorem addVal_one : addVal R 1 = 0
-- Mathlib/Data/Fin/Basic.lean
lemma pred_succAbove (x : Fin n) (y : Fin (n + 1)) (h : y ≤ castSucc x)
    (h' := Fin.ne_zero_of_lt $ (lt_succAbove_iff_le_castSucc ..).2 h) :
    (y.succAbove x).pred h' = x
-- Mathlib/Data/Sign.lean
@[simp] theorem sign_mul_abs (x : α) : (sign x * |x| : α) = x
-- Mathlib/SetTheory/Cardinal/ToNat.lean
theorem toNat_injOn : InjOn toNat (Iio ℵ₀)
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem hnot_hnot_hnot (a : α) : ￢￢￢a = ￢a
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem iterate_eq_of_map_eq_add_int {x : ℝ} {m : ℤ} (h : f x = x + m) (n : ℕ) :
    f^[n] x = x + n * m
-- Mathlib/NumberTheory/Ostrowski.lean
/-- The minimal positive integer with absolute value smaller than 1 is a prime number.-/
lemma is_prime_of_minimal_nat_zero_lt_mulRingNorm_lt_one : p.Prime
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem cons_dotProduct (x : α) (v : Fin n → α) (w : Fin n.succ → α) :
    dotProduct (vecCons x v) w = x * vecHead w + dotProduct v (vecTail w)
-- Mathlib/Analysis/Calculus/Deriv/Add.lean
nonrec theorem HasDerivWithinAt.add_const (hf : HasDerivWithinAt f f' s x) (c : F) :
    HasDerivWithinAt (fun y => f y + c) f' s x
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
lemma pow_inj_mod {n m : ℕ} : x ^ n = x ^ m ↔ n % orderOf x = m % orderOf x
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
theorem isPiSystem_Iic_rat : IsPiSystem (⋃ a : ℚ, {Iic (a : ℝ)})
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem HasLimit.isoOfEquivalence_inv_π {F : J ⥤ C} [HasLimit F] {G : K ⥤ C} [HasLimit G]
    (e : J ≌ K) (w : e.functor ⋙ G ≅ F) (j : J) :
    (HasLimit.isoOfEquivalence e w).inv ≫ limit.π F j =
    limit.π G (e.functor.obj j) ≫ w.hom.app j
-- Mathlib/Topology/AlexandrovDiscrete.lean
@[simp] lemma exterior_subset_exterior : exterior s ⊆ exterior t ↔ 𝓝ˢ s ≤ 𝓝ˢ t
-- Mathlib/Topology/Semicontinuous.lean
theorem LowerSemicontinuousAt.comp_continuousAt {f : α → β} {g : ι → α} {x : ι}
    (hf : LowerSemicontinuousAt f (g x)) (hg : ContinuousAt g x) :
    LowerSemicontinuousAt (fun x ↦ f (g x)) x
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem linearIndependent_pair {x y : V} (hx : x ≠ 0) (hy : ∀ a : K, a • x ≠ y) :
    LinearIndependent K ((↑) : ({x, y} : Set V) → V)
-- Mathlib/Data/Int/Lemmas.lean
theorem strictAntiOn_natAbs : StrictAntiOn natAbs (Iic 0)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
/-- Even if `s` is not measurable, we can bound `map f μ s` from below.
  See also `MeasurableEquiv.map_apply`. -/
theorem le_map_apply {f : α → β} (hf : AEMeasurable f μ) (s : Set β) : μ (f ⁻¹' s) ≤ μ.map f s
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem tendsto_of_monotone {ι α : Type*} [Preorder ι] [TopologicalSpace α]
    [ConditionallyCompleteLinearOrder α] [OrderTopology α] {f : ι → α} (h_mono : Monotone f) :
    Tendsto f atTop atTop ∨ ∃ l, Tendsto f atTop (𝓝 l)
-- Mathlib/Data/PNat/Basic.lean
theorem lt_add_left (n m : ℕ+) : n < m + n
-- Mathlib/Order/Cover.lean
@[simp] lemma sdiff_singleton_covBy (ha : a ∈ s) : s \ {a} ⋖ s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem filterMap_replicate_of_some {f : α → Option β} (h : f a = some b) :
    (replicate n a).filterMap f = replicate n b
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem sdiff_sdiff_self : (a \ b) \ a = ⊥
-- Mathlib/Data/Quot.lean
theorem lift_mk (f : α → γ) (h : ∀ a₁ a₂, r a₁ a₂ → f a₁ = f a₂) (a : α) :
    Quot.lift f h (Quot.mk r a) = f a
-- Mathlib/Data/Set/Sigma.lean
theorem exists_sigma_iff {p : (Σi, α i) → Prop} :
    (∃ x ∈ s.sigma t, p x) ↔ ∃ i ∈ s, ∃ a ∈ t i, p ⟨i, a⟩
-- Mathlib/Analysis/Convex/Gauge.lean
theorem gauge_eq_zero (hs : Absorbent ℝ s) (hb : Bornology.IsVonNBounded ℝ s) :
    gauge s x = 0 ↔ x = 0
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem isLUB_norm [Nonempty α] (f : lp E ∞) : IsLUB (Set.range fun i => ‖f i‖) ‖f‖
-- Mathlib/LinearAlgebra/Dimension/StrongRankCondition.lean
/-- The rank of a finite module is finite. -/
theorem rank_lt_aleph0 [Module.Finite R M] : Module.rank R M < ℵ₀
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem union_smul_inter_subset_union [DecidableEq α] : (s₁ ∪ s₂) • (t₁ ∩ t₂) ⊆ s₁ • t₁ ∪ s₂ • t₂
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
/-- The composition of two monoidal functors is again monoidal. -/
@[simps]
def comp : MonoidalFunctor.{v₁, v₃} C E
-- Mathlib/Data/Matrix/Basic.lean
theorem dotProduct_assoc [NonUnitalSemiring α] (u : m → α) (w : n → α) (v : Matrix m n α) :
    (fun j => u ⬝ᵥ fun i => v i j) ⬝ᵥ w = u ⬝ᵥ fun i => v i ⬝ᵥ w
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Bilinear.lean
@[simp]
theorem coe_deriv₂ (f : E →L[𝕜] Fₗ →L[𝕜] Gₗ) (p : E × Fₗ) :
    ⇑(f.deriv₂ p) = fun q : E × Fₗ => f p.1 q.2 + f q.1 p.2
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem inv_apply_self (f : Perm α) (x) : f⁻¹ (f x) = x
-- Mathlib/CategoryTheory/Bicategory/LocallyDiscrete.lean
@[simp]
lemma comp_toLoc {a b c : C} (f : a ⟶ b) (g : b ⟶ c) : (f ≫ g).toLoc = f.toLoc ≫ g.toLoc
-- Mathlib/Data/Rat/Defs.lean
lemma zero_of_num_zero {q : ℚ} (hq : q.num = 0) : q = 0
-- Mathlib/CategoryTheory/Limits/Constructions/LimitsOfProductsAndEqualizers.lean
theorem hasFiniteColimits_of_hasInitial_and_pushouts [HasInitial C] [HasPushouts C] :
    HasFiniteColimits C
-- Mathlib/MeasureTheory/Function/Floor.lean
@[measurability]
theorem Measurable.nat_ceil (hf : Measurable f) : Measurable fun x => ⌈f x⌉₊
-- Mathlib/NumberTheory/ModularForms/SlashInvariantForms.lean
@[simp]
theorem sub_apply (f g : SlashInvariantForm Γ k) (z : ℍ) : (f - g) z = f z - g z
-- Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean
/-- If a monoid homomorphism `f` between two `GroupWithZero`s maps `0` to `0`, then it maps `x^n`,
`n : ℤ`, to `(f x)^n`. -/
@[simp]
theorem map_zpow₀ {F G₀ G₀' : Type*} [GroupWithZero G₀] [GroupWithZero G₀'] [FunLike F G₀ G₀']
    [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (x : G₀) (n : ℤ) : f (x ^ n) = f x ^ n
-- Mathlib/Algebra/BigOperators/Intervals.lean
@[to_additive]
theorem prod_Ico_eq_div {δ : Type*} [CommGroup δ] (f : ℕ → δ) {m n : ℕ} (h : m ≤ n) :
    ∏ k ∈ Ico m n, f k = (∏ k ∈ range n, f k) / ∏ k ∈ range m, f k
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem Ioo_ae_eq_Icc' (ha : μ {a} = 0) (hb : μ {b} = 0) : Ioo a b =ᵐ[μ] Icc a b
-- Mathlib/LinearAlgebra/Matrix/Nondegenerate.lean
theorem eq_zero_of_mulVec_eq_zero [DecidableEq m] {M : Matrix m m A} (hM : M.det ≠ 0) {v : m → A}
    (hv : M *ᵥ v = 0) : v = 0
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem le_div_iff (hc : 0 < c) : a ≤ b / c ↔ a * c ≤ b
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem iSup_lt_lift_of_isRegular {ι} {f : ι → Cardinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} #ι < c) : (∀ i, f i < c) → iSup.{max u v + 1, u + 1} f < c
-- Mathlib/Data/Finite/Card.lean
/-- If `f` is an embedding, then `Nat.card α ≤ Nat.card β`. We must also assume
  `Nat.card β = 0 → Nat.card α = 0` since `Nat.card` is defined to be `0` for infinite types. -/
theorem card_le_of_embedding' (f : α ↪ β) (h : Nat.card β = 0 → Nat.card α = 0) :
    Nat.card α ≤ Nat.card β
-- Mathlib/Topology/Algebra/InfiniteSum/Basic.lean
@[to_additive]
theorem hasProd_ite_eq (b : β) [DecidablePred (· = b)] (a : α) :
    HasProd (fun b' ↦ if b' = b then a else 1) a
-- Mathlib/Algebra/Algebra/Hom.lean
theorem id_apply (p : A) : AlgHom.id R A p = p
-- Mathlib/Algebra/MonoidAlgebra/Degree.lean
theorem le_infDegree_add (f g : R[A]) :
    (f.infDegree D) ⊓ (g.infDegree D) ≤ (f + g).infDegree D
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem?_zipWith (since := "2024-06-12")]
theorem get?_zipWith {f : α → β → γ} :
    (List.zipWith f as bs).get? i = match as.get? i, bs.get? i with
      | some a, some b => some (f a b) | _, _ => none
-- Mathlib/Combinatorics/Colex.lean
lemma ofColex_ne_ofColex {s t : Colex α} : ofColex s ≠ ofColex t ↔ s ≠ t
-- Mathlib/Computability/TuringMachine.lean
theorem step_supports (M : Machine₀) {S : Set Λ} (ss : Supports M S) :
    ∀ {c c' : Cfg₀}, c' ∈ step M c → c.q ∈ S → c'.q ∈ S
-- Mathlib/LinearAlgebra/Basis.lean
protected theorem linearIndependent : LinearIndependent R b
-- Mathlib/CategoryTheory/Sites/Coherent/ExtensiveSheaves.lean
/--
A presheaf of sets on a category which is `FinitaryExtensive` is a sheaf iff it preserves finite
products.
-/
theorem Presieve.isSheaf_iff_preservesFiniteProducts (F : Cᵒᵖ ⥤ Type w) :
    Presieve.IsSheaf (extensiveTopology C) F ↔
    Nonempty (PreservesFiniteProducts F)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
lemma coe_variableChange_Δ' : (E.variableChange C).Δ' = C.u⁻¹ ^ 12 * E.Δ'
-- Mathlib/Analysis/Normed/Module/WeakDual.lean
@[simp]
theorem toWeakDual_eq_iff (x' y' : Dual 𝕜 E) : toWeakDual x' = toWeakDual y' ↔ x' = y'
-- Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean
@[measurability]
protected theorem aemeasurable [MeasurableSpace E] (f : Lp.simpleFunc E p μ) :
    AEMeasurable (toSimpleFunc f) μ
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
/-- `rpow` version of `Finset.prod_pow`. -/
theorem _root_.Real.finset_prod_rpow
    {ι} (s : Finset ι) (f : ι → ℝ) (hs : ∀ i ∈ s, 0 ≤ f i) (r : ℝ) :
    (∏ i ∈ s, f i ^ r) = (∏ i ∈ s, f i) ^ r
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
@[simp] protected theorem one_mul : ∀ a : Int, 1 * a = a
-- Mathlib/Data/ENNReal/Basic.lean
theorem max_zero_right : max a 0 = a
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[reassoc (attr := simp)]
lemma lift_φ₂ {A : C} (a : A ⟶ S.L₁.X₂) (b : A ⟶ S.L₀.X₃) (h : a ≫ S.L₁.g = b ≫ S.v₀₁.τ₃) :
    pullback.lift a b h ≫ S.φ₂ = a ≫ S.v₁₂.τ₂
-- Mathlib/Data/Matroid/Dual.lean
theorem dual_base_iff' : M✶.Base B ↔ M.Base (M.E \ B) ∧ B ⊆ M.E
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive existing, simp] lemma prod_neg_index [InvolutiveNeg ι] (s : Finset ι) (f : ι → α) :
    ∏ i ∈ -s, f i = ∏ i ∈ s, f (-i)
-- Mathlib/Combinatorics/Additive/Energy.lean
@[to_additive] lemma mulEnergy_pos (hs : s.Nonempty) (ht : t.Nonempty) : 0 < Eₘ[s, t]
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem fract_zspan_add (m : E) {v : E} (h : v ∈ span ℤ (Set.range b)) :
    fract b (v + m) = fract b m
-- Mathlib/Order/BoundedOrder.lean
theorem Monotone.ball {P : β → α → Prop} {s : Set β} (hP : ∀ x ∈ s, Monotone (P x)) :
    Monotone fun y => ∀ x ∈ s, P x y
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem val_add_one_of_lt {n : Nat} {i : Fin n.succ} (h : i < last _) : (i + 1).1 = i + 1
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem isClosed_aeStronglyMeasurable' [Fact (1 ≤ p)] [CompleteSpace F] (hm : m ≤ m0) :
    IsClosed {f : Lp F p μ | AEStronglyMeasurable' m f μ}
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
@[mono]
theorem arctan_strictMono : StrictMono arctan
-- Mathlib/Data/Set/Image.lean
theorem image_inter_subset (f : α → β) (s t : Set α) : f '' (s ∩ t) ⊆ f '' s ∩ f '' t
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem inclusion_faithful {S T : Subgroupoid C} (h : S ≤ T) (s t : S.objs) :
    Function.Injective fun f : s ⟶ t => (inclusion h).map f
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
protected theorem preimage_symm_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₁) :
    e ⁻¹' (e.symm ⁻¹' s) = s
-- Mathlib/Data/NNRat/Defs.lean
@[simp, norm_cast] lemma coe_zero : ((0 : ℚ≥0) : ℚ) = 0
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
/-- In a `RegularNormedAlgebra`, the map `Unitization.splitMul 𝕜 A` is injective.
We will use this to pull back the norm from `𝕜 × (A →L[𝕜] A)` to `Unitization 𝕜 A`. -/
theorem splitMul_injective : Function.Injective (splitMul 𝕜 A)
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_mk (e : P ≃ᵃ[𝕜] P₂) (he : ∀ x, ‖e.linear x‖ = ‖x‖) : ⇑(mk e he) = e
-- Mathlib/Order/Filter/Basic.lean
@[simp 1100, nolint simpNF]
theorem image_mem_map_iff (hf : Injective m) : m '' s ∈ map m f ↔ s ∈ f
-- Mathlib/RingTheory/Ideal/Quotient.lean
theorem zero_eq_one_iff {I : Ideal R} : (0 : R ⧸ I) = 1 ↔ I = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
theorem negSucc_eq (n : Nat) : -[n+1] = -((n : Int) + 1)
-- Mathlib/Data/Erased.lean
/-- Extracts the erased value, if it is a proof. -/
theorem out_proof {p : Prop} (a : Erased p) : p
-- .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 : Fin l.length, ↑i ≠ k ∧ l.get i = x
-- Mathlib/NumberTheory/Pell.lean
theorem x_mul_y_le_y_mul_x {a₁ : Solution₁ d} (h : IsFundamental a₁) {a : Solution₁ d}
    (hax : 1 < a.x) (hay : 0 < a.y) : a.x * a₁.y ≤ a.y * a₁.x
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
@[to_additive (attr := simp)]
theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥
-- Mathlib/Data/Nat/Factors.lean
/-- If `p` is a prime factor of `b` then `p` is also a prime factor of `a * b` for any `a > 0` -/
theorem mem_primeFactorsList_mul_right {p a b : ℕ} (hpb : p ∈ b.primeFactorsList) (ha : a ≠ 0) :
    p ∈ (a * b).primeFactorsList
-- Mathlib/Data/Nat/Factorization/Basic.lean
lemma coprime_factorizationLCMLeft_factorizationLCMRight :
    (factorizationLCMLeft a b).Coprime (factorizationLCMRight a b)
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
theorem eq_zero_of_src {X Y : C} (o : IsZero X) (f : X ⟶ Y) : f = 0
-- Mathlib/Data/NNReal/Basic.lean
@[simp, norm_cast] lemma coe_one : ((1 : ℝ≥0) : ℝ) = 1
-- Mathlib/Analysis/RCLike/Basic.lean
theorem I_mul_I : (I : K) = 0 ∨ (I : K) * I = -1
-- Mathlib/Order/CompleteBooleanAlgebra.lean
lemma inf_iSup_eq (a : α) (f : ι → α) : (a ⊓ ⨆ i, f i) = ⨆ i, a ⊓ f i
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem constantCoeff_wittStructureInt (Φ : MvPolynomial idx ℤ) (h : constantCoeff Φ = 0) (n : ℕ) :
    constantCoeff (wittStructureInt p Φ n) = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem sup_unique {ι} [Unique ι] (f : ι → Ordinal) : sup f = f default
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem back_eq_back? [Inhabited α] (a : Array α) : a.back = a.back?.getD default
-- Mathlib/Algebra/Module/Submodule/Range.lean
theorem range_comp_of_range_eq_top [RingHomSurjective τ₁₂] [RingHomSurjective τ₂₃]
    [RingHomSurjective τ₁₃] {f : M →ₛₗ[τ₁₂] M₂} (g : M₂ →ₛₗ[τ₂₃] M₃) (hf : range f = ⊤) :
    range (g.comp f : M →ₛₗ[τ₁₃] M₃) = range g
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem Measure.restrict_singleton' {a : α} : μ.restrict {a} = 0
-- Mathlib/Geometry/Manifold/VectorBundle/Hom.lean
theorem smoothOn_continuousLinearMapCoordChange
    [SmoothVectorBundle F₁ E₁ IB] [SmoothVectorBundle F₂ E₂ IB] [MemTrivializationAtlas e₁]
    [MemTrivializationAtlas e₁'] [MemTrivializationAtlas e₂] [MemTrivializationAtlas e₂'] :
    SmoothOn IB 𝓘(𝕜, (F₁ →L[𝕜] F₂) →L[𝕜] F₁ →L[𝕜] F₂)
      (continuousLinearMapCoordChange (RingHom.id 𝕜) e₁ e₁' e₂ e₂')
      (e₁.baseSet ∩ e₂.baseSet ∩ (e₁'.baseSet ∩ e₂'.baseSet))
-- Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean
/--
The natural transformation from identity functor on `R`-module to the composition of extension and
restriction of scalars.
-/
@[simps]
def unit : 𝟭 (ModuleCat R) ⟶ extendScalars f ⋙ restrictScalars.{max v u₂,u₁,u₂} f
-- Mathlib/Data/Set/Card.lean
theorem Infinite.exists_superset_ncard_eq {s t : Set α} (ht : t.Infinite) (hst : s ⊆ t)
    (hs : s.Finite) {k : ℕ} (hsk : s.ncard ≤ k) : ∃ s', s ⊆ s' ∧ s' ⊆ t ∧ s'.ncard = k
-- Mathlib/RingTheory/Localization/Basic.lean
theorem map_mk' (x) (y : M) : map Q g hy (mk' S x y) = mk' Q (g x) ⟨g y, hy y.2⟩
-- Mathlib/FieldTheory/RatFunc/AsPolynomial.lean
@[simp]
theorem algebraMap_X : algebraMap K[X] (RatFunc K) Polynomial.X = X
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem foldr (f) (init : α) : ∀ {s}, Valid s → s.foldr f init = s.toString.1.foldr f init
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
lemma map_apply_of_aemeasurable (ν : ProbabilityMeasure Ω) {f : Ω → Ω'}
    (f_aemble : AEMeasurable f ν) {A : Set Ω'} (A_mble : MeasurableSet A) :
    (ν.map f_aemble) A = ν (f ⁻¹' A)
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
lemma coeff_natTrailingDegree_ne_zero : coeff p p.natTrailingDegree ≠ 0 ↔ p ≠ 0
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp] lemma isRegular_X_pow (k : ℕ) : IsRegular (X n ^ k : MvPolynomial σ R)
-- Mathlib/Data/Multiset/Powerset.lean
theorem revzip_powersetAux_perm {l₁ l₂ : List α} (p : l₁ ~ l₂) :
    revzip (powersetAux l₁) ~ revzip (powersetAux l₂)
-- Mathlib/Computability/Primrec.lean
theorem nat_bodd : Primrec Nat.bodd
-- Mathlib/Algebra/Module/CharacterModule.lean
lemma eq_zero_of_character_apply {a : A} (h : ∀ c : CharacterModule A, c a = 0) : a = 0
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem map_comap_eq_self {f : F} {S : Submonoid N} (h : S ≤ MonoidHom.mrange f) :
    (S.comap f).map f = S
-- Mathlib/Data/Matrix/Basic.lean
/-- Note that `StarModule` is quite a strong requirement; as such we also provide the following
variants which this lemma would not apply to:
* `Matrix.conjTranspose_smul_non_comm`
* `Matrix.conjTranspose_nsmul`
* `Matrix.conjTranspose_zsmul`
* `Matrix.conjTranspose_natCast_smul`
* `Matrix.conjTranspose_intCast_smul`
* `Matrix.conjTranspose_inv_natCast_smul`
* `Matrix.conjTranspose_inv_intCast_smul`
* `Matrix.conjTranspose_rat_smul`
* `Matrix.conjTranspose_ratCast_smul`
-/
@[simp]
theorem conjTranspose_smul [Star R] [Star α] [SMul R α] [StarModule R α] (c : R)
    (M : Matrix m n α) : (c • M)ᴴ = star c • Mᴴ
-- Mathlib/Topology/Sets/Compacts.lean
protected theorem isCompact (s : PositiveCompacts α) : IsCompact (s : Set α)