ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Monad/Basic.lean
/-- The data of a comonad on C consists of an endofunctor G together with natural transformations
ε : G ⟶ 𝟭 C and δ : G ⟶ G ⋙ G satisfying three equations:
- δ_X ≫ G δ_X = δ_X ≫ δ_(GX) (coassociativity)
- δ_X ≫ ε_(GX) = 1_X (left counit)
- δ_X ≫ G ε_X = 1_X (right counit)
-/
structure Comonad extends C ⥤ C where
  /-- The counit for the comonad. -/
  ε : toFunctor ⟶ 𝟭 _
  /-- The comultiplication for the comonad. -/
  δ : toFunctor ⟶ toFunctor ⋙ toFunctor
  coassoc : ∀ X, NatTrans.app δ _ ≫ toFunctor.map (δ.app X) = δ.app _ ≫ δ.app _ := by
    aesop_cat
  left_counit : ∀ X : C, δ.app X ≫ ε.app (toFunctor.obj X) = 𝟙 _ := by aesop_cat
  right_counit : ∀ X : C, δ.app X ≫ toFunctor.map (ε.app X) = 𝟙 _ := by aesop_cat
-- Mathlib/Data/Sum/Basic.lean
theorem isLeft_left (h : LiftRel r s x (inl c)) : x.isLeft
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem dist_self (x : α) : dist x x = 0
-- Mathlib/RingTheory/Ideal/Cotangent.lean
theorem toCotangent_eq {x y : I} : I.toCotangent x = I.toCotangent y ↔ (x - y : R) ∈ I ^ 2
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected nonrec theorem SmoothOn.coordChange (hf : SmoothOn IM IB f s)
    (hg : SmoothOn IM 𝓘(𝕜, F) g s) (he : MapsTo f s e.baseSet) (he' : MapsTo f s e'.baseSet) :
    SmoothOn IM 𝓘(𝕜, F) (fun y ↦ e.coordChange e' (f y) (g y)) s
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive]
theorem AEMeasurable.mul_iff_right {G : Type*} [MeasurableSpace G] [MeasurableSpace α] [CommGroup G]
    [MeasurableMul₂ G] [MeasurableInv G] {μ : Measure α} {f g : α → G} (hf : AEMeasurable f μ) :
    AEMeasurable (f * g) μ ↔ AEMeasurable g μ
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
lemma orderOf_eq_card_powers : orderOf x = Fintype.card (powers x : Set G)
-- Mathlib/Order/Filter/AtTopBot.lean
theorem comap_neg_atTop : comap (Neg.neg : β → β) atTop = atBot
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean
theorem arctan_inv_of_pos {x : ℝ} (h : 0 < x) : arctan x⁻¹ = π / 2 - arctan x
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
lemma range_liftBaseChange (l : M →ₗ[R] N) :
    LinearMap.range (l.liftBaseChange A) = Submodule.span A (LinearMap.range l)
-- Mathlib/CategoryTheory/ClosedUnderIsomorphisms.lean
lemma le_isoClosure : P ≤ isoClosure P
-- Mathlib/Data/ENNReal/Basic.lean
theorem toNNReal_eq_zero_iff (x : ℝ≥0∞) : x.toNNReal = 0 ↔ x = 0 ∨ x = ∞
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive]
theorem smul_filter_le_smul_filter (hf : f₁ ≤ f₂) : a • f₁ ≤ a • f₂
-- Mathlib/Probability/Kernel/Disintegration/Density.lean
lemma measurable_density (κ : Kernel α (γ × β)) (ν : Kernel α γ)
    {s : Set β} (hs : MeasurableSet s) :
    Measurable (fun (p : α × γ) ↦ density κ ν p.1 p.2 s)
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
theorem MonoidHom.comp_assoc {Q : Type*} [MulOneClass M] [MulOneClass N] [MulOneClass P]
    [MulOneClass Q] (f : M →* N) (g : N →* P) (h : P →* Q) :
    (h.comp g).comp f = h.comp (g.comp f)
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- If a family is affinely independent, so is any subfamily given by
composition of an embedding into index type with the original
family. -/
theorem AffineIndependent.comp_embedding {ι2 : Type*} (f : ι2 ↪ ι) {p : ι → P}
    (ha : AffineIndependent k p) : AffineIndependent k (p ∘ f)
-- Mathlib/Order/Heyting/Basic.lean
theorem sdiff_le_sdiff_of_sup_le_sup_left (h : c ⊔ a ≤ c ⊔ b) : a \ c ≤ b \ c
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem d_pos : 0 < d
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
protected theorem map_smul_nnreal (c : ℝ≥0) (μ : Measure α) (f : α → β) :
    (c • μ).map f = c • μ.map f
-- Mathlib/Analysis/Convex/Deriv.lean
theorem StrictMonoOn.exists_slope_lt_deriv_aux {x y : ℝ} {f : ℝ → ℝ} (hf : ContinuousOn f (Icc x y))
    (hxy : x < y) (hf'_mono : StrictMonoOn (deriv f) (Ioo x y)) (h : ∀ w ∈ Ioo x y, deriv f w ≠ 0) :
    ∃ a ∈ Ioo x y, (f y - f x) / (y - x) < deriv f a
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem closure_univ : closure (univ : Set G) = ⊤
-- Mathlib/MeasureTheory/Function/AEEqFun.lean
@[simp]
theorem mk_pow (f : α → γ) (hf) (n : ℕ) :
    (mk f hf : α →ₘ[μ] γ) ^ n =
      mk (f ^ n) ((_root_.continuous_pow n).comp_aestronglyMeasurable hf)
-- Mathlib/Data/Int/CharZero.lean
lemma support_intCast (hn : n ≠ 0) : support (n : α → β) = univ
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_plift_down (f : ι → α) : ⨅ i, f (PLift.down i) = ⨅ i, f i
-- Mathlib/Algebra/Algebra/NonUnitalHom.lean
@[simp, norm_cast]
theorem coe_comp (f : B →ₛₙₐ[ψ] C) (g : A →ₛₙₐ[φ] B) [MonoidHom.CompTriple φ ψ χ] :
    ⇑(f.comp g) = (⇑f) ∘ (⇑g)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem edist_def (f g : Lp E p μ) : edist f g = eLpNorm (⇑f - ⇑g) p μ
-- Mathlib/SetTheory/Surreal/Basic.lean
/-- Same as `lt_moveRight`, but for `Surreal` instead of `PGame` -/
theorem mk_lt_mk_moveRight {x : PGame} (o : Numeric x) (j) :
    Surreal.mk x o < Surreal.mk (x.moveRight j) (Numeric.moveRight o j)
-- Mathlib/Data/Set/Pairwise/Basic.lean
@[simp]
theorem pairwiseDisjoint_singleton (i : ι) (f : ι → α) : PairwiseDisjoint {i} f
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
@[simp] theorem ofNat_num : (OfNat.ofNat n : Rat).num = OfNat.ofNat n
-- Mathlib/Order/OrdContinuous.lean
@[simp]
theorem coe_toOrderEmbedding (hf : RightOrdContinuous f) (h : Injective f) :
    ⇑(hf.toOrderEmbedding f h) = f
-- Mathlib/Algebra/Algebra/Equiv.lean
@[deprecated map_smul (since := "2024-06-20")]
protected theorem map_smul (r : R) (x : A₁) : e (r • x) = r • e x
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- The product of two antitone functions is antitone. -/
@[to_additive add "The sum of two antitone functions is antitone."]
theorem Antitone.mul' [CovariantClass α α (· * ·) (· ≤ ·)]
    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x => f x * g x
-- Mathlib/Order/LiminfLimsup.lean
theorem limsup_le_limsup {α : Type*} [ConditionallyCompleteLattice β] {f : Filter α} {u v : α → β}
    (h : u ≤ᶠ[f] v)
    (hu : f.IsCoboundedUnder (· ≤ ·) u := by isBoundedDefault)
    (hv : f.IsBoundedUnder (· ≤ ·) v := by isBoundedDefault) :
    limsup u f ≤ limsup v f
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Ioi_subset_Ioi_iff : Ioi b ⊆ Ioi a ↔ a ≤ b
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biproduct.ι_fromSubtype (j : Subtype p) :
    biproduct.ι (Subtype.restrict p f) j ≫ biproduct.fromSubtype f p = biproduct.ι f j
-- Mathlib/GroupTheory/Congruence/Basic.lean
/-- Sometimes, a group is defined as a quotient of a monoid by a congruence relation.
Usually, the inverse operation is defined as `Setoid.map f _` for some `f`.
This lemma allows to avoid code duplication in the definition of the inverse operation:
instead of proving both `∀ x y, c x y → c (f x) (f y)` (to define the operation)
and `∀ x, c (f x * x) 1` (to prove the group laws), one can only prove the latter. -/
@[to_additive "Sometimes, an additive group is defined as a quotient of a monoid
  by an additive congruence relation.
  Usually, the inverse operation is defined as `Setoid.map f _` for some `f`.
  This lemma allows to avoid code duplication in the definition of the inverse operation:
  instead of proving both `∀ x y, c x y → c (f x) (f y)` (to define the operation)
  and `∀ x, c (f x + x) 0` (to prove the group laws), one can only prove the latter."]
theorem map_of_mul_left_rel_one [Monoid M] (c : Con M)
    (f : M → M) (hf : ∀ x, c (f x * x) 1) {x y} (h : c x y) : c (f x) (f y)
-- Mathlib/CategoryTheory/GradedObject/Single.lean
@[reassoc (attr := simp)]
lemma singleObjApplyIso_inv_single_map (j : J) {X Y : C} (f : X ⟶ Y) :
    (singleObjApplyIso j X).inv ≫ (single j).map f j = f ≫ (singleObjApplyIso j Y).inv
-- Mathlib/Topology/Instances/ENNReal.lean
theorem add_biSup {ι} {s : Set ι} (hs : s.Nonempty) {f : ι → ℝ≥0∞} :
    (a + ⨆ i ∈ s, f i) = ⨆ i ∈ s, a + f i
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
/-- `BoundedContinuousMapClass F α β` states that `F` is a type of bounded continuous maps.

You should also extend this typeclass when you extend `BoundedContinuousFunction`. -/
class BoundedContinuousMapClass (F : Type*) (α β : outParam Type*) [TopologicalSpace α]
    [PseudoMetricSpace β] [FunLike F α β] extends ContinuousMapClass F α β : Prop where
  map_bounded (f : F) : ∃ C, ∀ x y, dist (f x) (f y) ≤ C
-- Mathlib/CategoryTheory/Abelian/Opposite.lean
/-- The cokernel of `f.op` is the opposite of `kernel f`. -/
@[simps!]
def cokernelOpOp : cokernel f.op ≅ Opposite.op (kernel f)
-- Mathlib/Logic/Equiv/PartialEquiv.lean
@[simp, mfld_simps]
theorem invFun_as_coe : e.invFun = e.symm
-- Mathlib/Order/Filter/Basic.lean
@[simp]
theorem comap_principal {t : Set β} : comap m (𝓟 t) = 𝓟 (m ⁻¹' t)
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem diff_self_inter {s t : Set α} : s \ (s ∩ t) = s \ t
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem mem_map {b : β} : b ∈ s.map f ↔ ∃ a ∈ s, f a = b
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem ediv_add_emod' (a b : Int) : a / b * b + a % b = a
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem_concat_length : ∀ (l : List α) (a : α) (i) (_ : i = l.length) (w), (l ++ [a])[i]'w = a
-- Mathlib/Data/Set/Lattice.lean
theorem iSup_iUnion (s : ι → Set α) (f : α → β) : ⨆ a ∈ ⋃ i, s i, f a = ⨆ (i) (a ∈ s i), f a
-- Mathlib/Topology/Order/ScottTopology.lean
lemma isOpen_iff :
    IsOpen s ↔ ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (· ≤ ·) d → ∀ ⦃a : α⦄, IsLUB d a →
      a ∈ s → ∃ b ∈ d, Ici b ∩ d ⊆ s
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[to_additive (attr := simp, norm_cast) coe_le_zero]
theorem coe_le_one [LE α] : (a : WithBot α) ≤ 1 ↔ a ≤ 1
-- Mathlib/GroupTheory/GroupAction/Pointwise.lean
/-- `preimage_smul_setₛₗ` when both scalars act by unit -/
theorem preimage_smul_setₛₗ_of_units (hc : IsUnit c) (hc' : IsUnit (σ c)) :
    h ⁻¹' (σ c • t) = c • h ⁻¹' t
-- Mathlib/Algebra/Field/Basic.lean
theorem inv_neg : (-a)⁻¹ = -a⁻¹
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[simp] theorem toFun_eq_coe (f : G →+c[a, b] H) : f.toFun = f
-- Mathlib/Order/Heyting/Basic.lean
theorem sup_sdiff_left : a ⊔ a \ b = a
-- Mathlib/RingTheory/Bezout.lean
theorem TFAE [IsBezout R] [IsDomain R] :
    List.TFAE
    [IsNoetherianRing R, IsPrincipalIdealRing R, UniqueFactorizationMonoid R, WfDvdMonoid R]
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem Matrix.toBilin_basisFun : Matrix.toBilin (Pi.basisFun R₂ n) = Matrix.toBilin'
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem le_map_of_map_zero (x : ℝ) : f 0 + ⌊x⌋ ≤ f x
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.inj {f} (H : IsNormal f) {a b} : f a = f b ↔ a = b
-- Mathlib/CategoryTheory/Sites/SheafHom.lean
/-- Given two presheaves `F` and `G` on a category `C` with values in a category `A`,
this `presheafHom F G` is the presheaf of types which sends an object `X : C`
to the type of morphisms between the "restrictions" of `F` and `G` to the category `Over X`. -/
@[simps! obj]
def presheafHom : Cᵒᵖ ⥤ Type _
-- Mathlib/Topology/Homotopy/Basic.lean
@[symm]
theorem symm ⦃f g : C(X, Y)⦄ (h : HomotopicRel f g S) : HomotopicRel g f S
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem replaceF_cons_of_some {l : List α} (p) (h : p a = some a') :
    (a :: l).replaceF p = a' :: l
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem sign_negSucc (x : Nat) : Int.sign (Int.negSucc x) = -1
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[to_additive (attr := simp)]
theorem prod_mul [Zero M] [CommMonoid N] {f : α →₀ M} {h₁ h₂ : α → M → N} :
    (f.prod fun a b => h₁ a b * h₂ a b) = f.prod h₁ * f.prod h₂
-- Mathlib/SetTheory/Surreal/Basic.lean
theorem lt_or_equiv_or_gt {x y : PGame} (ox : Numeric x) (oy : Numeric y) :
    x < y ∨ (x ≈ y) ∨ y < x
-- Mathlib/Combinatorics/Enumerative/Composition.lean
/-- The canonical increasing bijection between `Fin (c.length + 1)` and `c.boundaries` is
exactly `c.boundary`. -/
theorem orderEmbOfFin_boundaries :
    c.boundaries.orderEmbOfFin c.card_boundaries_eq_succ_length = c.boundary
-- Mathlib/FieldTheory/Separable.lean
theorem Separable.aeval_derivative_ne_zero [Nontrivial S] [Algebra R S] {p : R[X]}
    (h : p.Separable) {x : S} (hx : aeval x p = 0) :
    aeval x (derivative p) ≠ 0
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma eq_of_mem_uIcc_of_mem_uIcc (ha : a ∈ [[b, c]]) (hb : b ∈ [[a, c]]) : a = b
-- Mathlib/Order/Lattice.lean
@[simp]
theorem toDual_min (a b : α) : toDual (min a b) = max (toDual a) (toDual b)
-- Mathlib/Topology/Homotopy/Equiv.lean
/-- Any topological space is homotopy equivalent to itself.
-/
@[simps!]
def refl (X : Type u) [TopologicalSpace X] : X ≃ₕ X
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma MorphismProperty.LeftFraction.map_eq_iff
    {X Y : C} (φ ψ : W.LeftFraction X Y) :
    φ.map L (Localization.inverts _ _) = ψ.map L (Localization.inverts _ _) ↔
      LeftFractionRel φ ψ
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
@[simp] lemma exp_top : exp ⊤ = ∞
-- Mathlib/Order/Hom/Lattice.lean
@[simp, norm_cast]
lemma coe_withTopWithBot (f : LatticeHom α β) : ⇑f.withTopWithBot = Option.map (Option.map f)
-- Mathlib/Order/Chain.lean
theorem chain_le (s : Flag α) : IsChain (· ≤ ·) (s : Set α)
-- Mathlib/Analysis/Complex/Basic.lean
lemma mem_slitPlane_iff_not_le_zero {z : ℂ} : z ∈ slitPlane ↔ ¬z ≤ 0
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Basic.lean
@[simp] lemma locallyLinear_comap {G : SimpleGraph β} {e : α ≃ β} :
    (G.comap e).LocallyLinear ↔ G.LocallyLinear
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem testBit_bit_succ (m b) : ∀ n, testBit (bit b n) (Nat.succ m) = testBit n m
-- Mathlib/Data/TypeVec.lean
@[simp]
theorem dropFun_id {α : TypeVec (n + 1)} : dropFun (@TypeVec.id _ α) = id
-- Mathlib/Data/Multiset/Basic.lean
theorem card_eq_three {s : Multiset α} : card s = 3 ↔ ∃ x y z, s = {x, y, z}
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
theorem orbit_eq_univ [IsPretransitive M α] (a : α) : orbit M a = Set.univ
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem restr_trans (s : Set α) : (e.restr s).trans e' = (e.trans e').restr s
-- Mathlib/Order/Directed.lean
theorem directedOn_range {f : ι → α} : Directed r f ↔ DirectedOn r (Set.range f)
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem enum_zero_le' {o : Ordinal} (h0 : 0 < o) (a : o.out.α) :
    @enum o.out.α (· < ·) _ 0 (by rwa [type_lt]) ≤ a
-- Mathlib/RingTheory/PowerSeries/Derivative.lean
@[simp] theorem derivative_invOf {R} [CommRing R] (f : R⟦X⟧) [Invertible f] :
    d⁄dX R ⅟f = - ⅟f ^ 2 * d⁄dX R f
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
lemma continuous_inv_iff : Continuous f⁻¹ ↔ Continuous f
-- Mathlib/RingTheory/AlgebraTower.lean
@[simp]
theorem Basis.coe_algebraMapCoeffs : (b.algebraMapCoeffs A h : ι → M) = b
-- Mathlib/Analysis/BoxIntegral/Basic.lean
theorem Integrable.of_neg (hf : Integrable I l (-f) vol) : Integrable I l f vol
-- Mathlib/Dynamics/OmegaLimit.lean
theorem omegaLimit_preimage_subset {α' : Type*} (ϕ : τ → α' → β) (s : Set α') (f : Filter τ)
    (g : α → α') : ω f (fun t x ↦ ϕ t (g x)) (g ⁻¹' s) ⊆ ω f ϕ s
-- Mathlib/CategoryTheory/Comma/Arrow.lean
theorem mk_inj (A B : T) {f g : A ⟶ B} : Arrow.mk f = Arrow.mk g ↔ f = g
-- Mathlib/Algebra/Order/Monovary.lean
@[to_additive (attr := simp)]
lemma monovaryOn_inv_right : MonovaryOn f g⁻¹ s ↔ AntivaryOn f g s
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp, norm_cast]
theorem coe_sInf (S : Set (StarSubalgebra R A)) : (↑(sInf S) : Set A) = ⋂ s ∈ S, ↑s
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := simp)]
theorem toWord_inj {x y : FreeGroup α} : toWord x = toWord y ↔ x = y
-- Mathlib/ModelTheory/Substructures.lean
/-- A dependent version of `Substructure.closure_induction`. -/
@[elab_as_elim]
theorem closure_induction' (s : Set M) {p : ∀ x, x ∈ closure L s → Prop}
    (Hs : ∀ (x) (h : x ∈ s), p x (subset_closure h))
    (Hfun : ∀ {n : ℕ} (f : L.Functions n), ClosedUnder f { x | ∃ hx, p x hx }) {x}
    (hx : x ∈ closure L s) : p x hx
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Simproc.lean
theorem bneEqOfEqEq {a b c d : Nat} (p : (a = b) = (c = d)) : (a != b) = (c != d)
-- Mathlib/Combinatorics/SimpleGraph/Acyclic.lean
@[simp] lemma isAcyclic_bot : IsAcyclic (⊥ : SimpleGraph V)
-- Mathlib/CategoryTheory/Generator.lean
theorem isSeparating_iff_epi (𝒢 : Set C)
    [∀ A : C, HasCoproduct fun f : ΣG : 𝒢, (G : C) ⟶ A => (f.1 : C)] :
    IsSeparating 𝒢 ↔ ∀ A : C, Epi (Sigma.desc (@Sigma.snd 𝒢 fun G => (G : C) ⟶ A))
-- Mathlib/Algebra/Lie/Weights/Linear.lean
lemma trace_comp_toEnd_weightSpace_eq (χ : L → R) :
    LinearMap.trace R _ ∘ₗ (toEnd R L (weightSpace M χ)).toLinearMap =
    finrank R (weightSpace M χ) • χ
-- Mathlib/MeasureTheory/Measure/Regular.lean
protected theorem map {α β} [MeasurableSpace α] [MeasurableSpace β]
    {μ : Measure α} {pa qa : Set α → Prop}
    (H : InnerRegularWRT μ pa qa) {f : α → β} (hf : AEMeasurable f μ) {pb qb : Set β → Prop}
    (hAB : ∀ U, qb U → qa (f ⁻¹' U)) (hAB' : ∀ K, pa K → pb (f '' K))
    (hB₂ : ∀ U, qb U → MeasurableSet U) :
    InnerRegularWRT (map f μ) pb qb
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem associated_of_factorization_eq (a b : α) (ha : a ≠ 0) (hb : b ≠ 0)
    (h : factorization a = factorization b) : Associated a b
-- Mathlib/Algebra/Lie/Basic.lean
@[simp, norm_cast]
theorem coe_toLinearMap (f : M →ₗ⁅R,L⁆ N) : ((f : M →ₗ[R] N) : M → N) = f
-- Mathlib/Order/Directed.lean
theorem directed_comp {ι} {f : ι → β} {g : β → α} : Directed r (g ∘ f) ↔ Directed (g ⁻¹'o r) f
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem op_sSup (S : Set (Subring R)) : (sSup S).op = sSup (.unop ⁻¹' S)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_const' (l : List α) (b : β) : map (fun _ => b) l = replicate l.length b
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
@[simp]
theorem isReflection_conj_iff (w t : W) :
    cs.IsReflection (w * t * w⁻¹) ↔ cs.IsReflection t
-- Mathlib/Combinatorics/Additive/FreimanHom.lean
@[to_additive] lemma IsMulFreimanHom.comp (hg : IsMulFreimanHom n B C g)
    (hf : IsMulFreimanHom n A B f) : IsMulFreimanHom n A C (g ∘ f)
-- Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean
@[reassoc (attr := simp)]
theorem arrow_ι (j : J) : arrows j ≫ ι arrows j = head arrows
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc (attr := simp)]
theorem biproduct.lift_π {f : J → C} [HasBiproduct f] {P : C} (p : ∀ b, P ⟶ f b) (j : J) :
    biproduct.lift p ≫ biproduct.π f j = p j
-- Mathlib/Combinatorics/Quiver/SingleObj.lean
lemma ext {x y : SingleObj α} : x = y
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Restrict.lean
lemma starAlgHom_id {a : A} {φ : C(spectrum S a, S) →⋆ₐ[S] A} {f : C(S, R)}
    (h : SpectrumRestricts a f) (h_id : φ (.restrict (spectrum S a) <| .id S) = a) :
    h.starAlgHom φ (.restrict (spectrum R a) <| .id R) = a
-- Mathlib/SetTheory/Game/Basic.lean
theorem PGame.fuzzy_iff_game_fuzzy {x y : PGame} : PGame.Fuzzy x y ↔ ⟦x⟧ ‖ ⟦y⟧
-- Mathlib/Topology/Algebra/InfiniteSum/NatInt.lean
@[to_additive]
theorem prod_range_mul {f : ℕ → M} {k : ℕ} (h : HasProd (fun n ↦ f (n + k)) m) :
    HasProd f ((∏ i ∈ range k, f i) * m)
-- Mathlib/Data/PNat/Defs.lean
@[simp]
theorem one_le (n : ℕ+) : (1 : ℕ+) ≤ n
-- Mathlib/Logic/Basic.lean
/-- See `IsEmpty.exists_iff` for the `False` version. -/
@[simp] theorem exists_true_left (p : True → Prop) : (∃ x, p x) ↔ p True.intro
-- Mathlib/RingTheory/Algebraic.lean
theorem isAlgebraic_int [Nontrivial R] (n : ℤ) : IsAlgebraic R (n : A)
-- Mathlib/Data/Finset/Basic.lean
theorem Nonempty.ne_empty {s : Finset α} (h : s.Nonempty) : s ≠ ∅
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc]
lemma RightHomologyData.rightHomologyIso_inv_naturality
    (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData) :
      h₁.homologyIso.inv ≫ homologyMap φ =
        rightHomologyMap' φ h₁ h₂ ≫ h₂.homologyIso.inv
-- Mathlib/CategoryTheory/EpiMono.lean
/-- Every split epi whose section is epi is an iso. -/
theorem IsIso.of_epi_section {X Y : C} (f : X ⟶ Y) [hf : IsSplitEpi f] [hf' : Epi <| section_ f] :
    IsIso f
-- Mathlib/Algebra/MvPolynomial/Basic.lean
lemma eq_C_of_isEmpty [IsEmpty σ] (p : MvPolynomial σ R) :
    p = C (p.coeff 0)
-- Mathlib/Order/Filter/Basic.lean
theorem eventually_imp_distrib_left {f : Filter α} {p : Prop} {q : α → Prop} :
    (∀ᶠ x in f, p → q x) ↔ p → ∀ᶠ x in f, q x
-- Mathlib/Data/List/Basic.lean
theorem singleton_eq (x : α) : ({x} : List α) = [x]
-- Mathlib/NumberTheory/Padics/PadicNorm.lean
/-- The `p`-adic norm is nonnegative. -/
protected theorem nonneg (q : ℚ) : 0 ≤ padicNorm p q
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
@[to_additive]
theorem one_def : (1 : S) = ⟨1, S.one_mem⟩
-- Mathlib/LinearAlgebra/SModEq.lean
lemma neg (hxy : x ≡ y [SMOD U]) : - x ≡ - y [SMOD U]
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
/-- If there is a nonzero vector and every other vector is a multiple of it,
then the module has dimension one. -/
theorem finrank_eq_one (v : M) (n : v ≠ 0) (h : ∀ w : M, ∃ c : R, c • v = w) : finrank R M = 1
-- Mathlib/Algebra/GroupWithZero/Basic.lean
lemma zpow_add₀ (ha : a ≠ 0) (m n : ℤ) : a ^ (m + n) = a ^ m * a ^ n
-- Mathlib/Data/Sign.lean
@[simp, norm_cast] lemma coe_zpow {α} [GroupWithZero α] [HasDistribNeg α] (a : SignType) (k : ℤ) :
    ↑(a ^ k) = (a : α) ^ k
-- Mathlib/Computability/Reduce.lean
@[symm]
theorem ManyOneEquiv.symm {α β} [Primcodable α] [Primcodable β] {p : α → Prop} {q : β → Prop} :
    ManyOneEquiv p q → ManyOneEquiv q p
-- Mathlib/Analysis/Normed/Module/FiniteDimension.lean
theorem Basis.opNNNorm_le {ι : Type*} [Fintype ι] (v : Basis ι 𝕜 E) {u : E →L[𝕜] F} (M : ℝ≥0)
    (hu : ∀ i, ‖u (v i)‖₊ ≤ M) : ‖u‖₊ ≤ Fintype.card ι • ‖v.equivFunL.toContinuousLinearMap‖₊ * M
-- Mathlib/Algebra/Star/Subsemiring.lean
@[ext]
theorem ext {S T : StarSubsemiring R} (h : ∀ x : R, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Analysis/Convex/Segment.lean
@[simp]
theorem segment_same (x : E) : [x -[𝕜] x] = {x}
-- Mathlib/LinearAlgebra/TensorProduct/Opposite.lean
@[simp]
theorem opAlgEquiv_tmul (a : Aᵐᵒᵖ) (b : Bᵐᵒᵖ) :
    opAlgEquiv R S A B (a ⊗ₜ[R] b) = op (a.unop ⊗ₜ b.unop)
-- Mathlib/Analysis/InnerProductSpace/Rayleigh.lean
theorem eq_smul_self_of_isLocalExtrOn_real (hT : IsSelfAdjoint T) {x₀ : F}
    (hextr : IsLocalExtrOn T.reApplyInnerSelf (sphere (0 : F) ‖x₀‖) x₀) :
    T x₀ = T.rayleighQuotient x₀ • x₀
-- Mathlib/Order/Filter/Basic.lean
theorem EventuallyEq.eventually {l : Filter α} {f g : α → β} (h : f =ᶠ[l] g) :
    ∀ᶠ x in l, f x = g x
-- Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean
lemma IsCondKernelCDF.le_one (hf : IsCondKernelCDF f κ ν) (p : α × β) (x : ℝ) : f p x ≤ 1
-- Mathlib/Data/Real/Sqrt.lean
@[simp] lemma sqrt_one : sqrt 1 = 1
-- Mathlib/Data/Nat/Factorization/PrimePow.lean
theorem isPrimePow_iff_factorization_eq_single {n : ℕ} :
    IsPrimePow n ↔ ∃ p k : ℕ, 0 < k ∧ n.factorization = Finsupp.single p k
-- Mathlib/GroupTheory/GroupAction/Hom.lean
theorem inverse'_inverse'
    {f : X →ₑ[φ] Y} {g : Y → X}
    {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    inverse' (inverse' f g k₂ h₁ h₂) f k₁ h₂ h₁ = f
-- Mathlib/Order/Bounds/Basic.lean
theorem bddBelow_Ici : BddBelow (Ici a)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ioc_subset_Ioc_iff (h₁ : a₁ < b₁) : Ioc a₁ b₁ ⊆ Ioc a₂ b₂ ↔ b₁ ≤ b₂ ∧ a₂ ≤ a₁
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem toHom_inj {f g : M ↪[L] N} : f.toHom = g.toHom ↔ f = g
-- Mathlib/Topology/Algebra/Order/Compact.lean
theorem IsCompact.exists_sInf_image_eq [ClosedIicTopology α] {s : Set β} (hs : IsCompact s)
    (ne_s : s.Nonempty) {f : β → α} (hf : ContinuousOn f s) : ∃ x ∈ s, sInf (f '' s) = f x
-- Mathlib/Topology/Category/TopCat/Opens.lean
/-- The inclusion map from an open subset to the whole space, as a morphism in `TopCat`.
-/
@[simps (config := .asFn)]
def inclusion {X : TopCat.{u}} (U : Opens X) : (toTopCat X).obj U ⟶ X