ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- Consider a point `x` at which a set `s` has density zero, with respect to closed balls. Then it
also has density zero with respect to any measurable set `t`: the proportion of points in `s`
belonging to a rescaled copy `{x} + r • t` of `t` tends to zero as `r` tends to zero. -/
theorem tendsto_addHaar_inter_smul_zero_of_density_zero (s : Set E) (x : E)
    (h : Tendsto (fun r => μ (s ∩ closedBall x r) / μ (closedBall x r)) (𝓝[>] 0) (𝓝 0)) (t : Set E)
    (ht : MeasurableSet t) (h''t : μ t ≠ ∞) :
    Tendsto (fun r : ℝ => μ (s ∩ ({x} + r • t)) / μ ({x} + r • t)) (𝓝[>] 0) (𝓝 0)
-- Mathlib/Topology/ExtremallyDisconnected.lean
theorem extremallyDisconnected_of_homeo {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y]
    [ExtremallyDisconnected X] (e : X ≃ₜ Y) : ExtremallyDisconnected Y
-- Mathlib/Computability/Partrec.lean
theorem ofOption {f : α → Option β} (hf : Computable f) : Partrec fun a => (f a : Part β)
-- Mathlib/Data/FunLike/Equiv.lean
theorem comp_injective (f : α → β) (e : F) : Function.Injective (e ∘ f) ↔ Function.Injective f
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem half_lt_self (hz : a ≠ 0) (ht : a ≠ ∞) : a / 2 < a
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp]
theorem cast_addNat {n : Nat} (m : Nat) (i : Fin n) :
    cast (Nat.add_comm ..) (addNat i m) = natAdd m i
-- Mathlib/Topology/Constructions.lean
theorem Filter.eventually_nhdsSet_prod_iff {p : X × Y → Prop} :
    (∀ᶠ q in 𝓝ˢ (s ×ˢ t), p q) ↔
      ∀ x ∈ s, ∀ y ∈ t,
          ∃ px : X → Prop, (∀ᶠ x' in 𝓝 x, px x') ∧ ∃ py : Y → Prop, (∀ᶠ y' in 𝓝 y, py y') ∧
            ∀ {x : X}, px x → ∀ {y : Y}, py y → p (x, y)
-- Mathlib/Data/Finsupp/Basic.lean
@[simp]
theorem erase_sub (a : α) (f₁ f₂ : α →₀ G) : erase a (f₁ - f₂) = erase a f₁ - erase a f₂
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp]
theorem symm_trans_self (e : α ≃+*o β) : e.symm.trans e = OrderRingIso.refl β
-- Mathlib/Algebra/Order/Field/Canonical/Basic.lean
theorem tsub_div (a b c : α) : (a - b) / c = a / c - b / c
-- Mathlib/MeasureTheory/Group/Action.lean
/-- See also `smul_ae`. -/
@[to_additive "See also `vadd_ae`."]
theorem tendsto_smul_ae (c : G) : Filter.Tendsto (c • ·) (ae μ) (ae μ)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_lt_mul_of_neg_right {a b c : Int} (h : b < a) (hc : c < 0) : a * c < b * c
-- Mathlib/NumberTheory/NumberField/Discriminant.lean
/-- **Hermite-Minkowski Theorem**. A nontrivial number field has discriminant greater than `2`. -/
theorem abs_discr_gt_two (h : 1 < finrank ℚ K) : 2 < |discr K|
-- Mathlib/Order/Defs.lean
/-- A preorder is a reflexive, transitive relation `≤` with `a < b` defined in the obvious way. -/
class Preorder (α : Type u) extends LE α, LT α where
  le_refl : ∀ a : α, a ≤ a
  le_trans : ∀ a b c : α, a ≤ b → b ≤ c → a ≤ c
  lt := fun a b => a ≤ b ∧ ¬b ≤ a
  lt_iff_le_not_le : ∀ a b : α, a < b ↔ a ≤ b ∧ ¬b ≤ a := by intros; rfl
-- Mathlib/Algebra/NeZero.lean
lemma two_ne_zero' [OfNat α 2] [NeZero (2 : α)] : (2 : α) ≠ 0
-- Mathlib/Order/Interval/Set/ProjIcc.lean
protected theorem Monotone.IccExtend (hf : Monotone f) : Monotone (IccExtend h f)
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem lt_nfpFamily {a b} : a < nfpFamily.{u, v} f b ↔ ∃ l, a < List.foldr f b l
-- Mathlib/Algebra/BigOperators/Group/List.lean
/-- In a join of sublists, taking the slice between the indices `A` and `B - 1` gives back the
original sublist of index `i` if `A` is the sum of the lengths of sublists of index `< i`, and
`B` is the sum of the lengths of sublists of index `≤ i`. -/
lemma drop_take_succ_join_eq_getElem (L : List (List α)) (i : Nat) (h : i < L.length) :
    (L.join.take ((L.map length).take (i + 1)).sum).drop ((L.map length).take i).sum = L[i]
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem cons_vecMulVec (x : α) (v : Fin m → α) (w : n' → α) :
    vecMulVec (vecCons x v) w = vecCons (x • w) (vecMulVec v w)
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
/-- If an element `a` divides another element `b` in a ring, `a` divides the sum of `b` and another
element `c` iff `a` divides `c`. -/
theorem dvd_add_right (h : a ∣ b) : a ∣ b + c ↔ a ∣ c
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem comap_iInf {ι : Sort*} (f : R →+* S) (s : ι → Subring S) :
    (iInf s).comap f = ⨅ i, (s i).comap f
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean
@[simp] lemma mk_pow (i : NumDenSameDeg 𝒜 x) (n : ℕ) : mk (i ^ n) = mk i ^ n
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_le_nat_iff {a : Cardinal.{u}} {n : ℕ} : lift.{v} a ≤ n ↔ a ≤ n
-- Mathlib/Data/Seq/Computation.lean
theorem mem_of_promises {a} (p : s ~> a) : a ∈ s
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[deprecated Nat.le_sub_iff_add_le (since := "2024-02-19")]
protected theorem add_le_to_le_sub (n : Nat) (h : m ≤ k) : n + m ≤ k ↔ n ≤ k - m
-- Mathlib/Data/Multiset/Basic.lean
theorem erase_le_erase {s t : Multiset α} (a : α) (h : s ≤ t) : s.erase a ≤ t.erase a
-- Mathlib/LinearAlgebra/Matrix/Block.lean
/-- The inverse of a block-triangular matrix is block-triangular. -/
theorem blockTriangular_inv_of_blockTriangular [LinearOrder α] [Invertible M]
    (hM : BlockTriangular M b) : BlockTriangular M⁻¹ b
-- Mathlib/LinearAlgebra/Span.lean
theorem span_int_eq_addSubgroup_closure {M : Type*} [AddCommGroup M] (s : Set M) :
    (span ℤ s).toAddSubgroup = AddSubgroup.closure s
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
nonrec theorem SmoothAt.prod_mk {f : M → M'} {g : M → N'} (hf : SmoothAt I I' f x)
    (hg : SmoothAt I J' g x) : SmoothAt I (I'.prod J') (fun x => (f x, g x)) x
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- The image under a ring homomorphism of the `NonUnitalSubring` generated by a set equals
the `NonUnitalSubring` generated by the image of the set. -/
theorem map_closure (f : R →ₙ+* S) (s : Set R) : (closure s).map f = closure (f '' s)
-- Mathlib/NumberTheory/FLT/Three.lean
/-- If there is a solution then there is a minimal one. -/
lemma Solution.exists_minimal : ∃ (S₁ : Solution hζ), S₁.isMinimal
-- Mathlib/MeasureTheory/Measure/Tilted.lean
@[simp]
lemma tilted_zero_measure (f : α → ℝ) : (0 : Measure α).tilted f = 0
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
/-- Let `{x | p x}` be a subsemigroup of a commutative monoid `M`. Let `f : M → N` be a map
such that `f 1 = 1` and `f` is submultiplicative on `{x | p x}`, i.e.,
`p x → p y → f (x * y) ≤ f x * f y`. Let `g i`, `i ∈ s`, be a finite family of elements of `M` such
that `∀ i ∈ s, p (g i)`. Then `f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)`. -/
@[to_additive le_sum_of_subadditive_on_pred]
theorem le_prod_of_submultiplicative_on_pred (f : M → N) (p : M → Prop) (h_one : f 1 = 1)
    (h_mul : ∀ x y, p x → p y → f (x * y) ≤ f x * f y) (hp_mul : ∀ x y, p x → p y → p (x * y))
    (g : ι → M) {s : Finset ι} (hs : ∀ i ∈ s, p (g i)) : f (∏ i ∈ s, g i) ≤ ∏ i ∈ s, f (g i)
-- Mathlib/Order/Interval/Set/ProjIcc.lean
@[simp]
theorem projIic_self (b : α) : projIic b b = ⟨b, le_rfl⟩
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem exponent_eq_zero_iff_range_orderOf_infinite (h : ∀ g : G, 0 < orderOf g) :
    exponent G = 0 ↔ (Set.range (orderOf : G → ℕ)).Infinite
-- Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean
theorem incMatrix_apply_eq_zero_iff : G.incMatrix R a e = 0 ↔ e ∉ G.incidenceSet a
-- Mathlib/Topology/Algebra/InfiniteSum/Constructions.lean
@[to_additive]
theorem tprod_comm {f : β → γ → α} (h : Multipliable (Function.uncurry f)) :
    ∏' (c) (b), f b c = ∏' (b) (c), f b c
-- Mathlib/RingTheory/PrincipalIdealDomain.lean
theorem Irreducible.coprime_pow_of_not_dvd {p a : R} (m : ℕ) (hp : Irreducible p) (h : ¬p ∣ a) :
    IsCoprime a (p ^ m)
-- Mathlib/Data/Bool/AllAny.lean
theorem all_iff_forall_prop : (all l fun a => p a) ↔ ∀ a ∈ l, p a
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
theorem _root_.Pi.orthonormalBasis_repr {η : Type*} [Fintype η] {ι : η → Type*}
    [∀ i, Fintype (ι i)] {𝕜 : Type*} [RCLike 𝕜] {E : η → Type*} [∀ i, NormedAddCommGroup (E i)]
    [∀ i, InnerProductSpace 𝕜 (E i)] (B : ∀ i, OrthonormalBasis (ι i) 𝕜 (E i)) (x : (i : η ) → E i)
    (j : (i : η) × (ι i)) :
    (Pi.orthonormalBasis B).repr x j = (B j.fst).repr (x j.fst) j.snd
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
/-- For finite intervals, see: `intervalIntegral.integral_deriv_mul_eq_sub`. -/
theorem integral_Ioi_deriv_mul_eq_sub
    (hu : ∀ x ∈ Ioi a, HasDerivAt u (u' x) x) (hv : ∀ x ∈ Ioi a, HasDerivAt v (v' x) x)
    (huv : IntegrableOn (u' * v + u * v') (Ioi a))
    (h_zero : Tendsto (u * v) (𝓝[>] a) (𝓝 a')) (h_infty : Tendsto (u * v) atTop (𝓝 b')) :
    ∫ (x : ℝ) in Ioi a, u' x * v x + u x * v' x = b' - a'
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
theorem coeFn_pair (f : α →ₘ[μ] β) (g : α →ₘ[μ] γ) : f.pair g =ᵐ[μ] fun x => (f x, g x)
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem eq_id_of_mono {x : SimplexCategory} (i : x ⟶ x) [Mono i] : i = 𝟙 _
-- Mathlib/CategoryTheory/Localization/Prod.lean
lemma prod_fac₁ [W₂.ContainsIdentities] :
    W₁.Q ⋙ prodLift₁ F hF = curry.obj F
-- Mathlib/RepresentationTheory/Rep.lean
theorem linearization_single (X : Action (Type u) (MonCat.of G)) (g : G) (x : X.V) (r : k) :
    ((linearization k G).obj X).ρ g (Finsupp.single x r) = Finsupp.single (X.ρ g x) r
-- Mathlib/Topology/Algebra/Star.lean
@[fun_prop]
theorem ContinuousOn.star (hf : ContinuousOn f s) : ContinuousOn (fun x => star (f x)) s
-- Mathlib/Data/Real/Sqrt.lean
theorem lt_sq_of_sqrt_lt (h : √x < y) : x < y ^ 2
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The minimal distance from `x` to `s` is bounded by the distance from `y` to `s`, modulo
the distance between `x` and `y`. -/
theorem infDist_le_infDist_add_dist : infDist x s ≤ infDist y s + dist x y
-- Mathlib/Analysis/Complex/Basic.lean
theorem nndist_conj_comm (z w : ℂ) : nndist (conj z) w = nndist z (conj w)
-- Mathlib/Analysis/SpecialFunctions/Log/Base.lean
theorem tendsto_logb_atTop_of_base_lt_one : Tendsto (logb b) atTop atBot
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- Biproducts are unique up to isomorphism. This already follows because bilimits are limits,
    but in the case of biproducts we can give an isomorphism with particularly nice definitional
    properties, namely that `biproduct.lift b.π` and `biproduct.desc b.ι` are inverses of each
    other. -/
@[simps]
def biproduct.uniqueUpToIso (f : J → C) [HasBiproduct f] {b : Bicone f} (hb : b.IsBilimit) :
    b.pt ≅ ⨁ f
-- Mathlib/Algebra/IsPrimePow.lean
theorem IsPrimePow.dvd {n m : ℕ} (hn : IsPrimePow n) (hm : m ∣ n) (hm₁ : m ≠ 1) : IsPrimePow m
-- Mathlib/Algebra/Category/CoalgebraCat/ComonEquivalence.lean
/-- The natural category equivalence between `R`-coalgebras and comonoid objects in the
category of `R`-modules. -/
@[simps]
noncomputable def comonEquivalence : CoalgebraCat R ≌ Comon_ (ModuleCat R)
-- Mathlib/Probability/Independence/Kernel.lean
/-- If `f` is a family of mutually independent random variables (`iIndepFun m f μ`) and `S, T` are
two disjoint finite index sets, then the tuple formed by `f i` for `i ∈ S` is independent of the
tuple `(f i)_i` for `i ∈ T`. -/
theorem iIndepFun.indepFun_finset [IsMarkovKernel κ] (S T : Finset ι) (hST : Disjoint S T)
    (hf_Indep : iIndepFun m f κ μ) (hf_meas : ∀ i, Measurable (f i)) :
    IndepFun (fun a (i : S) => f i a) (fun a (i : T) => f i a) κ μ
-- Mathlib/Topology/Connected/Basic.lean
theorem isPreconnected_closed_iff {s : Set α} :
    IsPreconnected s ↔ ∀ t t', IsClosed t → IsClosed t' →
      s ⊆ t ∪ t' → (s ∩ t).Nonempty → (s ∩ t').Nonempty → (s ∩ (t ∩ t')).Nonempty
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
theorem StableUnderCobaseChange.unop {P : MorphismProperty Cᵒᵖ} (hP : StableUnderCobaseChange P) :
    StableUnderBaseChange P.unop
-- Mathlib/Data/Seq/WSeq.lean
theorem exists_get?_of_mem {s : WSeq α} {a} (h : a ∈ s) : ∃ n, some a ∈ get? s n
-- Mathlib/Algebra/GroupWithZero/Indicator.lean
@[simp] lemma support_mul' (f g : ι → M₀) : support (f * g) = support f ∩ support g
-- Mathlib/Analysis/Normed/Module/Complemented.lean
@[simp]
theorem equivProdOfSurjectiveOfIsCompl_toLinearEquiv {f : E →L[𝕜] F} {g : E →L[𝕜] G}
    (hf : range f = ⊤) (hg : range g = ⊤) (hfg : IsCompl (ker f) (ker g)) :
    (equivProdOfSurjectiveOfIsCompl f g hf hg hfg).toLinearEquiv =
      LinearMap.equivProdOfSurjectiveOfIsCompl f g hf hg hfg
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Ioo_ofDual (a b : αᵒᵈ) : Ioo (ofDual a) (ofDual b) = (Ioo b a).map ofDual.toEmbedding
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem neg_le_of_neg_le {a b : Int} (h : -a ≤ b) : -b ≤ a
-- Mathlib/Topology/MetricSpace/Contracting.lean
theorem apriori_dist_iterate_fixedPoint_le (x n) :
    dist (f^[n] x) (fixedPoint f hf) ≤ dist x (f x) * (K : ℝ) ^ n / (1 - K)
-- Mathlib/FieldTheory/IsAlgClosed/Basic.lean
@[simp]
theorem equivOfEquiv_algebraMap (hSR : S ≃+* R) (s : S) :
    equivOfEquiv L M hSR (algebraMap S L s) = algebraMap R M (hSR s)
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma dist_pi_lt_iff {f g : ∀ b, π b} {r : ℝ} (hr : 0 < r) :
    dist f g < r ↔ ∀ b, dist (f b) (g b) < r
-- Mathlib/RingTheory/Coalgebra/Hom.lean
theorem coe_fn_injective : @Function.Injective (A →ₗc[R] B) (A → B) (↑)
-- Mathlib/Logic/Basic.lean
lemma eq_true_intro {a : Prop} (h : a) : a = True
-- Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean
@[reassoc]
theorem tensor_left_unitality (X₁ X₂ : C) :
    (λ_ (X₁ ⊗ X₂)).hom =
      ((λ_ (𝟙_ C)).inv ▷ (X₁ ⊗ X₂)) ≫
        tensor_μ C (𝟙_ C, 𝟙_ C) (X₁, X₂) ≫ ((λ_ X₁).hom ⊗ (λ_ X₂).hom)
-- .lake/packages/batteries/Batteries/Classes/SatisfiesM.lean
/-- The `SatisfiesM p x` predicate is monotonic in `p`. -/
theorem imp [Functor m] [LawfulFunctor m] {x : m α}
    (h : SatisfiesM p x) (H : ∀ {a}, p a → q a) : SatisfiesM q x
-- Mathlib/Algebra/Quaternion.lean
@[simp] theorem smul_imK : (s • a).imK = s • a.imK
-- Mathlib/AlgebraicGeometry/Pullbacks.lean
theorem cocycle_snd_snd (i j k : 𝒰.J) :
    t' 𝒰 f g i j k ≫ t' 𝒰 f g j k i ≫ t' 𝒰 f g k i j ≫ pullback.snd _ _ ≫ pullback.snd _ _ =
      pullback.snd _ _ ≫ pullback.snd _ _
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- A more general version of `finprod_mem_union` that requires `s ∩ mulSupport f` and
`t ∩ mulSupport f` rather than `s` and `t` to be finite. -/
@[to_additive
      "A more general version of `finsum_mem_union` that requires `s ∩ support f` and
      `t ∩ support f` rather than `s` and `t` to be finite."]
theorem finprod_mem_union' (hst : Disjoint s t) (hs : (s ∩ mulSupport f).Finite)
    (ht : (t ∩ mulSupport f).Finite) : ∏ᶠ i ∈ s ∪ t, f i = (∏ᶠ i ∈ s, f i) * ∏ᶠ i ∈ t, f i
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem star_def : (Star.star : ℂ → ℂ) = conj
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem natAbs_negSucc (n : Nat) : natAbs -[n+1] = n.succ
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
theorem dropSlice_zero₂ : ∀ n l, @dropSlice α n 0 l = l
-- Mathlib/ModelTheory/LanguageMap.lean
/-- The inclusion of the left factor into the sum of two languages. -/
@[simps]
protected def sumInl : L →ᴸ L.sum L'
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_nat : #ℕ = ℵ₀
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
/-- The space of constant maps is equivalent to the space of maps that are alternating with respect
to an empty family. -/
@[simps]
def constLinearEquivOfIsEmpty [IsEmpty ι] : N'' ≃ₗ[R'] (M'' [⋀^ι]→ₗ[R'] N'')
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_X_pow_add_C {n : ℕ} (hn : 0 < n) {r : R} :
    (X ^ n + C r).leadingCoeff = 1
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem moebius_ne_zero_iff_eq_or {n : ℕ} : μ n ≠ 0 ↔ μ n = 1 ∨ μ n = -1
-- Mathlib/Algebra/Star/Pointwise.lean
@[simp]
theorem iInter_star {ι : Sort*} [Star α] (s : ι → Set α) : (⋂ i, s i)⋆ = ⋂ i, (s i)⋆
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
@[reassoc]
theorem biproduct.matrix_desc [Fintype K] {f : J → C} {g : K → C}
    (m : ∀ j k, f j ⟶ g k) {P} (x : ∀ k, g k ⟶ P) :
    biproduct.matrix m ≫ biproduct.desc x = biproduct.desc fun j => ∑ k, m j k ≫ x k
-- Mathlib/Order/Monotone/Basic.lean
theorem StrictMonoOn.eq_iff_eq (hf : StrictMonoOn f s) {a b : α} (ha : a ∈ s) (hb : b ∈ s) :
    f a = f b ↔ a = b
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
theorem monomorphisms.infer_property [hf : Mono f] : (monomorphisms C) f
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem mul_integral_upcrossingsBefore_le_integral_pos_part_aux [IsFiniteMeasure μ]
    (hf : Submartingale f ℱ μ) (hab : a < b) :
    (b - a) * μ[upcrossingsBefore a b f N] ≤ μ[fun ω => (f N ω - a)⁺]
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
lemma cos_half {x : ℝ} (hl : -π ≤ x) (hr : x ≤ π) : cos (x / 2) = sqrt ((1 + cos x) / 2)
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem map_map (h : β → γ) (g : α → β) (x : Option α) :
    (x.map g).map h = x.map (h ∘ g)
-- Mathlib/MeasureTheory/Measure/Tilted.lean
@[simp]
lemma tilted_of_not_aemeasurable (hf : ¬ AEMeasurable f μ) : μ.tilted f = 0
-- Mathlib/Order/LiminfLimsup.lean
lemma Monotone.frequently_ge_map_of_frequently_ge {f : R → S} (f_incr : Monotone f)
    {l : R} (freq_ge : ∃ᶠ x in F, l ≤ x) :
    ∃ᶠ x' in F.map f, f l ≤ x'
-- Mathlib/Topology/Instances/AddCircle.lean
@[simp]
theorem equivAddCircle_apply_mk (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜) :
    equivAddCircle p q hp hq (x : 𝕜) = (x * (p⁻¹ * q) : 𝕜)
-- Mathlib/RingTheory/PowerBasis.lean
@[simp]
theorem equivOfRoot_map (pb : PowerBasis A S) (e : S ≃ₐ[A] S') (h₁ h₂) :
    pb.equivOfRoot (pb.map e) h₁ h₂ = e
-- Mathlib/Dynamics/PeriodicPts.lean
@[simp]
theorem iterate_mem_periodicOrbit (hx : x ∈ periodicPts f) (n : ℕ) :
    f^[n] x ∈ periodicOrbit f x
-- Mathlib/LinearAlgebra/FiniteDimensional.lean
/-- A linear independent family of `finrank K V` vectors forms a basis. -/
@[simps! repr_apply]
noncomputable def basisOfLinearIndependentOfCardEqFinrank {ι : Type*} [Nonempty ι] [Fintype ι]
    {b : ι → V} (lin_ind : LinearIndependent K b) (card_eq : Fintype.card ι = finrank K V) :
    Basis ι K V
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem linearIndependent_cols_of_invertible (A : Matrix m m K) [Invertible A] :
    LinearIndependent K (fun i ↦ Aᵀ i)
-- Mathlib/MeasureTheory/Function/Jacobian.lean
lemma _root_.MeasurableEmbedding.withDensity_ofReal_comap_apply_eq_integral_abs_deriv_mul'
    {f : ℝ → ℝ} (hf : MeasurableEmbedding f) {s : Set ℝ} (hs : MeasurableSet s)
    {f' : ℝ → ℝ} (hf' : ∀ x, HasDerivAt f (f' x) x)
    {g : ℝ → ℝ} (hg : 0 ≤ᵐ[volume] g) (hg_int : Integrable g) :
    (volume.withDensity (fun x ↦ ENNReal.ofReal (g x))).comap f s
      = ENNReal.ofReal (∫ x in s, |f' x| * g (f x))
-- Mathlib/Topology/Algebra/Order/UpperLower.lean
protected theorem IsLowerSet.interior (h : IsLowerSet s) : IsLowerSet (interior s)
-- Mathlib/Data/Seq/Computation.lean
theorem LiftRel.imp {R S : α → β → Prop} (H : ∀ {a b}, R a b → S a b) (s t) :
    LiftRel R s t → LiftRel S s t
-- Mathlib/Computability/Ackermann.lean
@[simp]
theorem ack_two (n : ℕ) : ack 2 n = 2 * n + 3
-- Mathlib/Data/ENat/Basic.lean
theorem coe_one : ((1 : ℕ) : ℕ∞) = 1
-- Mathlib/RingTheory/Polynomial/IntegralNormalization.lean
theorem integralNormalization_support {f : R[X]} :
    (integralNormalization f).support ⊆ f.support
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
@[reassoc (attr := simp)]
theorem imageMonoIsoSource_hom_self [Mono f] : (imageMonoIsoSource f).hom ≫ f = image.ι f
-- Mathlib/Topology/Bornology/Basic.lean
theorem comap_cobounded_le_iff [Bornology β] {f : α → β} :
    (cobounded β).comap f ≤ cobounded α ↔ ∀ ⦃s⦄, IsBounded s → IsBounded (f '' s)
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
lemma Hom.comp_eq_comp {X Y Z : WalkingMultispan fst snd}
    (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.comp f g = f ≫ g
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem getElem?_modifyNth (f : α → α) :
    ∀ n (l : List α) m, (modifyNth f n l)[m]? = (fun a => if n = m then f a else a) <$> l[m]?
-- Mathlib/Order/CompleteLattice.lean
theorem sSup_eq_iSup' (s : Set α) : sSup s = ⨆ a : s, (a : α)
-- Mathlib/Analysis/Convex/Side.lean
@[simp]
theorem _root_.AffineEquiv.wOppSide_map_iff {s : AffineSubspace R P} {x y : P} (f : P ≃ᵃ[R] P') :
    (s.map ↑f).WOppSide (f x) (f y) ↔ s.WOppSide x y
-- Mathlib/Topology/Inseparable.lean
/-- A continuous function is monotone with respect to the specialization preorders on the domain and
the codomain. -/
theorem Continuous.specialization_monotone (hf : Continuous f) : Monotone f
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem UniqueMDiffOn.eq (U : UniqueMDiffOn I s) (hx : x ∈ s) (h : HasMFDerivWithinAt I I' f s x f')
    (h₁ : HasMFDerivWithinAt I I' f s x f₁') : f' = f₁'
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The norm of the sum of two vectors equals the norm of their difference if and only if
the angle between them is π/2. -/
theorem norm_add_eq_norm_sub_iff_angle_eq_pi_div_two (x y : V) :
    ‖x + y‖ = ‖x - y‖ ↔ angle x y = π / 2
-- Mathlib/RingTheory/Nilpotent/Basic.lean
protected lemma isNilpotent_sum {ι : Type*} {s : Finset ι} {f : ι → R}
    (hnp : ∀ i ∈ s, IsNilpotent (f i)) (h_comm : ∀ i j, i ∈ s → j ∈ s → Commute (f i) (f j)) :
    IsNilpotent (∑ i ∈ s, f i)
-- Mathlib/Algebra/Polynomial/Reverse.lean
@[simp]
theorem reflect_eq_zero_iff {N : ℕ} {f : R[X]} : reflect N (f : R[X]) = 0 ↔ f = 0
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem decide_false_eq {b : Bool} [Decidable (false = b)] : decide (false = b) = !b
-- Mathlib/Data/Vector/Basic.lean
@[to_additive]
theorem prod_set' [CommGroup α] (v : Vector α n) (i : Fin n) (a : α) :
    (v.set i a).toList.prod = v.toList.prod * (v.get i)⁻¹ * a
-- Mathlib/Algebra/Group/Subgroup/Pointwise.lean
@[to_additive (attr := simp)]
theorem closure_inv (s : Set G) : closure s⁻¹ = closure s
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem PairwiseDisjoint.elim' (hs : s.PairwiseDisjoint f) {i j : ι} (hi : i ∈ s) (hj : j ∈ s)
    (h : f i ⊓ f j ≠ ⊥) : i = j
-- Mathlib/Computability/TMToPartrec.lean
theorem codeSupp_supports {S c k} (H : codeSupp c k ⊆ S) : Supports (codeSupp c k) S
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
@[simp]
theorem sup_eq_zero_iff {ι : Type u} {f : ι → Ordinal.{max u v}} :
    sup.{_, v} f = 0 ↔ ∀ i, f i = 0
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of two monotone functions is monotone. -/
@[to_additive add "The sum of two monotone functions is monotone."]
theorem MonotoneOn.mul' [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (hf : MonotoneOn f s) (hg : MonotoneOn g s) :
    MonotoneOn (fun x => f x * g x) s
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Module.lean
/-- `M[1/f] = 0` if and only if `D(f) ∩ Supp M = 0`. -/
lemma LocalizedModule.subsingleton_iff_disjoint {f : R} :
    Subsingleton (LocalizedModule (.powers f) M) ↔
      Disjoint ↑(PrimeSpectrum.basicOpen f) (Module.support R M)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableWithinAt.add (hf : DifferentiableWithinAt 𝕜 f s x)
    (hg : DifferentiableWithinAt 𝕜 g s x) : DifferentiableWithinAt 𝕜 (fun y => f y + g y) s x
-- Mathlib/RingTheory/Kaehler/CotangentComplex.lean
lemma map_comp_cotangentComplex (f : Hom P P') :
    CotangentSpace.map f ∘ₗ P.cotangentComplex =
      P'.cotangentComplex.restrictScalars S ∘ₗ Cotangent.map f
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictAnti.image_Ioo_subset (h : StrictAnti f) : f '' Ioo a b ⊆ Ioo (f b) (f a)
-- Mathlib/Data/Nat/Choose/Multinomial.lean
theorem multinomial_eq (f : α →₀ ℕ) : f.multinomial = Nat.multinomial f.support f
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp] theorem measurableSet_inl_image {s : Set α} :
    MeasurableSet (Sum.inl '' s : Set (α ⊕ β)) ↔ MeasurableSet s
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem norm_compContinuous_linearIsometryEquiv (g : ContinuousMultilinearMap 𝕜 E₁ G)
    (f : ∀ i, E i ≃ₗᵢ[𝕜] E₁ i) :
    ‖g.compContinuousLinearMap fun i => (f i : E i →L[𝕜] E₁ i)‖ = ‖g‖
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem derivWithin_of_isOpen (hs : IsOpen s) (hx : x ∈ s) : derivWithin f s x = deriv f x