ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma infs_singleton : s ⊼ {b} = s.image (· ⊓ b)
-- Mathlib/NumberTheory/Divisors.lean
theorem divisor_le {m : ℕ} : n ∈ divisors m → n ≤ m
-- Mathlib/Combinatorics/SimpleGraph/Hasse.lean
@[simp]
theorem hasseDualIso_symm_apply (a : α) : hasseDualIso.symm a = toDual a
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem count_self [Nontrivial α] [DecidableEq (Associates α)] {p : Associates α}
    (hp : Irreducible p) : p.count p.factors = 1
-- Mathlib/Order/SupClosed.lean
lemma SupClosed.directedOn (hs : SupClosed s) : DirectedOn (· ≤ ·) s
-- Mathlib/Logic/Denumerable.lean
theorem prod_ofNat_val (n : ℕ) :
    ofNat (α × β) n = (ofNat α (unpair n).1, ofNat β (unpair n).2)
-- Mathlib/Probability/CondCount.lean
theorem condCount_inter' (hs : s.Finite) :
    condCount s (t ∩ u) = condCount (s ∩ u) t * condCount s u
-- Mathlib/Algebra/Ring/Parity.lean
lemma even_neg_two : Even (-2 : α)
-- Mathlib/Data/Fin/Tuple/NatAntidiagonal.lean
@[simp]
theorem antidiagonalTuple_zero_zero : antidiagonalTuple 0 0 = [![]]
-- Mathlib/CategoryTheory/Localization/DerivabilityStructure/Basic.lean
lemma isRightDerivabilityStructure_iff [Φ.HasRightResolutions] (e : Φ.functor ⋙ L₂ ≅ L₁ ⋙ F) :
    Φ.IsRightDerivabilityStructure ↔ TwoSquare.GuitartExact e.hom
-- Mathlib/Data/Nat/Find.lean
lemma findGreatest_mono [DecidablePred Q] (hPQ : ∀ n, P n → Q n) (hmn : m ≤ n) :
    Nat.findGreatest P m ≤ Nat.findGreatest Q n
-- Mathlib/Data/ENNReal/Inv.lean
theorem mul_le_iff_le_inv {a b r : ℝ≥0∞} (hr₀ : r ≠ 0) (hr₁ : r ≠ ∞) : r * a ≤ b ↔ a ≤ r⁻¹ * b
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem preimage_emetric_closedBall (h : Isometry f) (x : α) (r : ℝ≥0∞) :
    f ⁻¹' EMetric.closedBall (f x) r = EMetric.closedBall x r
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
theorem antilipschitzWith_lineMap {p₁ p₂ : Q} (h : p₁ ≠ p₂) :
    AntilipschitzWith (nndist p₁ p₂)⁻¹ (lineMap p₁ p₂ : 𝕜 → Q)
-- Mathlib/RingTheory/Int/Basic.lean
theorem eq_pow_of_mul_eq_pow_odd {a b c : ℤ} (hab : IsCoprime a b) {k : ℕ} (hk : Odd k)
    (h : a * b = c ^ k) : (∃ d, a = d ^ k) ∧ ∃ e, b = e ^ k
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem sin_eq_neg_one_iff {x : ℂ} : sin x = -1 ↔ ∃ k : ℤ, -(π / 2) + k * (2 * π) = x
-- Mathlib/Topology/Homotopy/Basic.lean
/-- Casting a `Homotopy f₀ f₁` to a `Homotopy g₀ g₁` where `f₀ = g₀` and `f₁ = g₁`.
-/
@[simps]
def cast {f₀ f₁ g₀ g₁ : C(X, Y)} (F : Homotopy f₀ f₁) (h₀ : f₀ = g₀) (h₁ : f₁ = g₁) :
    Homotopy g₀ g₁
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp, fun_prop]
theorem Differentiable.prod (hf₁ : Differentiable 𝕜 f₁) (hf₂ : Differentiable 𝕜 f₂) :
    Differentiable 𝕜 fun x : E => (f₁ x, f₂ x)
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma comap_smul {f : F →+* K} : (σ • w).comap f = w.comap (RingHom.comp σ.symm f)
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
@[simp]
theorem coe_const (p : P2) : ⇑(const k P1 p) = Function.const P1 p
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_X_pow_add_C {n : ℕ} {r : R} : (X ^ n + C r).natDegree = n
-- Mathlib/CategoryTheory/Limits/Constructions/ZeroObjects.lean
@[simp]
theorem prodZeroIso_iso_inv_snd (X : C) : (prodZeroIso X).inv ≫ prod.fst = 𝟙 X
-- Mathlib/MeasureTheory/Measure/Haar/Basic.lean
/-- Let `μ` be a σ-finite left invariant measure on `G`. Then `μ` is equal to the Haar measure
defined by `K₀` iff `μ K₀ = 1`. -/
@[to_additive]
theorem haarMeasure_eq_iff (K₀ : PositiveCompacts G) (μ : Measure G) [SigmaFinite μ]
    [IsMulLeftInvariant μ] :
    haarMeasure K₀ = μ ↔ μ K₀ = 1
-- Mathlib/Topology/Maps/Basic.lean
theorem openEmbedding_of_continuous_injective_open
    (h₁ : Continuous f) (h₂ : Injective f) (h₃ : IsOpenMap f) : OpenEmbedding f
-- Mathlib/RingTheory/PowerBasis.lean
theorem IsIntegral.mem_span_pow [Nontrivial R] {x y : S} (hx : IsIntegral R x)
    (hy : ∃ f : R[X], y = aeval x f) :
    y ∈ Submodule.span R (Set.range fun i : Fin (minpoly R x).natDegree => x ^ (i : ℕ))
-- Mathlib/Order/Filter/AtTopBot.lean
@[simp, nolint simpNF] -- Porting note: linter claims that LHS doesn't simplify. It does.
theorem tendsto_comp_val_Iic_atBot [SemilatticeInf α] {a : α} {f : α → β} {l : Filter β} :
    Tendsto (fun x : Iic a => f x) atBot l ↔ Tendsto f atBot l
-- Mathlib/Topology/Algebra/Module/Multilinear/Basic.lean
theorem pi_apply {ι' : Type*} {M' : ι' → Type*} [∀ i, AddCommMonoid (M' i)]
    [∀ i, TopologicalSpace (M' i)] [∀ i, Module R (M' i)]
    (f : ∀ i, ContinuousMultilinearMap R M₁ (M' i)) (m : ∀ i, M₁ i) (j : ι') : pi f m j = f j m
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
lemma measurable_set_iff : Measurable g ↔ ∀ a, Measurable fun x ↦ a ∈ g x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[deprecated getElem?_map (since := "2024-06-12")]
theorem get?_map (f : α → β) : ∀ l n, (map f l).get? n = (l.get? n).map f
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem compLinearMap_zero [Nonempty ι] (f : M [⋀^ι]→ₗ[R] N) :
    f.compLinearMap (0 : M₂ →ₗ[R] M) = 0
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem iterateFrobenius_zero_apply : iterateFrobenius R p 0 x = x
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
/-- This is an auxiliary data structure useful for constructing adjunctions.
See `Adjunction.mkOfHomEquiv`.
This structure won't typically be used anywhere else.
-/
-- Porting note(#5171): `has_nonempty_instance` linter not ported yet
-- @[nolint has_nonempty_instance]
structure CoreHomEquiv (F : C ⥤ D) (G : D ⥤ C) where
  /-- The equivalence between `Hom (F X) Y` and `Hom X (G Y)` -/
  homEquiv : ∀ X Y, (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)
  /-- The property that describes how `homEquiv.symm` transforms compositions `X' ⟶ X ⟶ G Y` -/
  homEquiv_naturality_left_symm :
    ∀ {X' X Y} (f : X' ⟶ X) (g : X ⟶ G.obj Y),
      (homEquiv X' Y).symm (f ≫ g) = F.map f ≫ (homEquiv X Y).symm g := by
    aesop_cat
  /-- The property that describes how `homEquiv` transforms compositions `F X ⟶ Y ⟶ Y'` -/
  homEquiv_naturality_right :
    ∀ {X Y Y'} (f : F.obj X ⟶ Y) (g : Y ⟶ Y'),
      (homEquiv X Y') (f ≫ g) = (homEquiv X Y) f ≫ G.map g := by
    aesop_cat
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_mul_left_Icc {a b c : α} (ha : 0 ≤ a) (hbc : b ≤ c) :
    (a * ·) '' Icc b c = Icc (a * b) (a * c)
-- Mathlib/MeasureTheory/Group/Measure.lean
/-- Continuity of the measure of translates of a compact set: Given a compact set `k` in a
topological group, for `g` close enough to the origin, `μ (g • k \ k)` is arbitrarily small. -/
@[to_additive]
lemma eventually_nhds_one_measure_smul_diff_lt [LocallyCompactSpace G]
    [IsFiniteMeasureOnCompacts μ] [InnerRegularCompactLTTop μ] {k : Set G}
    (hk : IsCompact k) (h'k : IsClosed k) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
    ∀ᶠ g in 𝓝 (1 : G), μ (g • k \ k) < ε
-- Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean
theorem objSupIsoProdEqLocus_inv_eq_iff {X : TopCat.{u}} (F : X.Sheaf CommRingCat.{u})
    {U V W UW VW : Opens X} (e : W ≤ U ⊔ V) (x) (y : F.1.obj (op W))
    (h₁ : UW = U ⊓ W) (h₂ : VW = V ⊓ W) :
    F.1.map (homOfLE e).op ((F.objSupIsoProdEqLocus U V).inv x) = y ↔
    F.1.map (homOfLE (h₁ ▸ inf_le_left : UW ≤ U)).op x.1.1 =
      F.1.map (homOfLE <| h₁ ▸ inf_le_right).op y ∧
    F.1.map (homOfLE (h₂ ▸ inf_le_left : VW ≤ V)).op x.1.2 =
      F.1.map (homOfLE <| h₂ ▸ inf_le_right).op y
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem edgeSet_singletonSubgraph (v : V) : (G.singletonSubgraph v).edgeSet = ∅
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem nmul_le_iff : a ⨳ b ≤ c ↔ ∀ a' < a, ∀ b' < b, a' ⨳ b ♯ a ⨳ b' < c ♯ a' ⨳ b'
-- Mathlib/Algebra/GroupWithZero/Prod.lean
/-- Division as a multiplicative homomorphism with zero. -/
@[simps]
def divMonoidWithZeroHom [CommGroupWithZero M₀] : M₀ × M₀ →*₀ M₀
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem nonzero_mul_eq_swap_mul (a b : A) : σ (a * b) \ {0} = σ (b * a) \ {0}
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
/-- Let `t i` be a countable covering of a set `T` by measurable sets. Let `f i : t i → β` be a
family of functions that agree on the intersections `t i ∩ t j`. Then the function
`Set.iUnionLift t f _ _ : T → β`, defined as `f i ⟨x, hx⟩` for `hx : x ∈ t i`, is measurable. -/
theorem measurable_iUnionLift [Countable ι] {t : ι → Set α} {f : ∀ i, t i → β}
    (htf : ∀ (i j) (x : α) (hxi : x ∈ t i) (hxj : x ∈ t j), f i ⟨x, hxi⟩ = f j ⟨x, hxj⟩)
    {T : Set α} (hT : T ⊆ ⋃ i, t i) (htm : ∀ i, MeasurableSet (t i)) (hfm : ∀ i, Measurable (f i)) :
    Measurable (iUnionLift t f htf T hT)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem WithTop.sInf_empty [InfSet α] : sInf (∅ : Set (WithTop α)) = ⊤
-- Mathlib/Probability/Independence/Basic.lean
theorem indepFun_iff_map_prod_eq_prod_map_map {mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'}
    [IsFiniteMeasure μ] (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    IndepFun f g μ ↔ μ.map (fun ω ↦ (f ω, g ω)) = (μ.map f).prod (μ.map g)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma map_negY (x y : R) : (W.map f).toAffine.negY (f x) (f y) = f (W.negY x y)
-- Mathlib/Logic/Function/Basic.lean
theorem LeftInverse.rightInverse {f : α → β} {g : β → α} (h : LeftInverse g f) : RightInverse f g
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem disconnect_normal (Sn : S.IsNormal) : S.disconnect.IsNormal
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
@[simp] theorem forall_eq {p : α → Prop} {a' : α} : (∀ a, a = a' → p a) ↔ p a'
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem symm_image_target_eq_source : e.symm '' e.target = e.source
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem sumCongr_inv {α β : Type*} (e : Perm α) (f : Perm β) :
    (sumCongr e f)⁻¹ = sumCongr e⁻¹ f⁻¹
-- Mathlib/Algebra/Symmetrized.lean
@[simp]
theorem sym_symm : (@sym α).symm = unsym
-- Mathlib/Data/ENNReal/Basic.lean
theorem preimage_ennreal_ofReal (h : u.OrdConnected) : (ENNReal.ofReal ⁻¹' u).OrdConnected
-- Mathlib/Order/Filter/Basic.lean
theorem le_map_of_right_inverse {mab : α → β} {mba : β → α} {f : Filter α} {g : Filter β}
    (h₁ : mab ∘ mba =ᶠ[g] id) (h₂ : Tendsto mba g f) : g ≤ map mab f
-- Mathlib/Order/RelClasses.lean
theorem ssubset_of_ne_of_subset [IsAntisymm α (· ⊆ ·)] (h₁ : a ≠ b) (h₂ : a ⊆ b) : a ⊂ b
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem filterMap_val : (filterMap f s' f_inj).1 = s'.1.filterMap f
-- Mathlib/Data/Finset/Card.lean
theorem card_le_card_sdiff_add_card : s.card ≤ (s \ t).card + t.card
-- Mathlib/Order/RelClasses.lean
lemma subset_rfl [IsRefl α (· ⊆ ·)] : a ⊆ a
-- Mathlib/Data/Finset/Sups.lean
lemma image_infs (f : F) (s t : Finset α) : image f (s ⊼ t) = image f s ⊼ image f t
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙHom_closedEmbedding :
    ClosedEmbedding <| (cfcₙHom ha : C(σₙ R a, R)₀ →⋆ₙₐ[R] A)
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
theorem Homeomorph.shearMulRight_coe :
    ⇑(Homeomorph.shearMulRight G) = fun z : G × G => (z.1, z.1 * z.2)
-- Mathlib/Order/Bounds/Basic.lean
@[simp]
theorem upperBounds_empty : upperBounds (∅ : Set α) = univ
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem indep_iSup_directed_limsup (h_le : ∀ n, s n ≤ m0) (h_indep : iIndep s μ)
    (hf : ∀ t, p t → tᶜ ∈ f) (hns : Directed (· ≤ ·) ns) (hnsp : ∀ a, p (ns a)) :
    Indep (⨆ a, ⨆ n ∈ ns a, s n) (limsup s f) μ
-- Mathlib/CategoryTheory/Idempotents/FunctorCategories.lean
/-- Tautological action on maps of the functor `Karoubi (J ⥤ C) ⥤ (J ⥤ Karoubi C)`. -/
@[simps]
def map {P Q : Karoubi (J ⥤ C)} (f : P ⟶ Q) : obj P ⟶ obj Q
-- Mathlib/Algebra/Order/Field/Unbundled/Basic.lean
lemma one_div_nonpos : 1 / a ≤ 0 ↔ a ≤ 0
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_mul_le_div_mul_of_div_le_div (h : a / b ≤ c / d) (he : 0 ≤ e) :
    a / (b * e) ≤ c / (d * e)
-- Mathlib/Data/Nat/Bits.lean
@[simp]
theorem zero_bits : bits 0 = []
-- Mathlib/MeasureTheory/Integral/Average.lean
theorem setIntegral_setAverage (μ : Measure α) [IsFiniteMeasure μ] (f : α → E) (s : Set α) :
    ∫ _ in s, ⨍ a in s, f a ∂μ ∂μ = ∫ x in s, f x ∂μ
-- Mathlib/Topology/Baire/Lemmas.lean
/-- Baire theorem: a countable intersection of dense Gδ sets is dense. Formulated here with
an index set which is a countable set in any type. -/
theorem dense_biInter_of_Gδ {S : Set α} {f : ∀ x ∈ S, Set X} (ho : ∀ s (H : s ∈ S), IsGδ (f s H))
    (hS : S.Countable) (hd : ∀ s (H : s ∈ S), Dense (f s H)) : Dense (⋂ s ∈ S, f s ‹_›)
-- Mathlib/Topology/ContinuousOn.lean
theorem nhdsWithin_iUnion {ι} [Finite ι] (s : ι → Set α) (a : α) :
    𝓝[⋃ i, s i] a = ⨆ i, 𝓝[s i] a
-- Mathlib/Data/DFinsupp/Interval.lean
theorem card_Iic : (Iic f).card = ∏ i ∈ f.support, (Iic (f i)).card
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[measurability, fun_prop]
theorem AEMeasurable.ennreal_toReal {f : α → ℝ≥0∞} {μ : Measure α} (hf : AEMeasurable f μ) :
    AEMeasurable (fun x => ENNReal.toReal (f x)) μ
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem bypass_copy {u v u' v'} (p : G.Walk u v) (hu : u = u') (hv : v = v') :
    (p.copy hu hv).bypass = p.bypass.copy hu hv
-- Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean
theorem HasAffineProperty.diagonal_of_diagonal_of_isPullback
    (P) {Q} [HasAffineProperty P Q]
    {X Y U V : Scheme.{u}} {f : X ⟶ Y} {g : U ⟶ Y}
    [IsAffine U] [IsOpenImmersion g]
    {iV : V ⟶ X} {f' : V ⟶ U} (h : IsPullback iV f' f g) (H : P.diagonal f) :
    Q.diagonal f'
-- Mathlib/Topology/NhdsSet.lean
theorem nhds_le_nhdsSet (h : x ∈ s) : 𝓝 x ≤ 𝓝ˢ s
-- Mathlib/CategoryTheory/Monoidal/Types/Basic.lean
@[simp]
theorem leftUnitor_inv_apply {X : Type u} {x : X} :
    ((λ_ X).inv : X ⟶ 𝟙_ (Type u) ⊗ X) x = (PUnit.unit, x)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem rev_castSucc (k : Fin n) : rev (castSucc k) = succ (rev k)
-- Mathlib/Dynamics/Flow.lean
theorem map_zero_apply (x : α) : ϕ 0 x = x
-- Mathlib/NumberTheory/WellApproximable.lean
/-- **Gallagher's ergodic theorem** on Diophantine approximation. -/
theorem addWellApproximable_ae_empty_or_univ (δ : ℕ → ℝ) (hδ : Tendsto δ atTop (𝓝 0)) :
    (∀ᵐ x, ¬addWellApproximable 𝕊 δ x) ∨ ∀ᵐ x, addWellApproximable 𝕊 δ x
-- Mathlib/Topology/MetricSpace/Dilation.lean
theorem comp_assoc {δ : Type*} [PseudoEMetricSpace δ] (f : α →ᵈ β) (g : β →ᵈ γ)
    (h : γ →ᵈ δ) : (h.comp g).comp f = h.comp (g.comp f)
-- Mathlib/Order/Monotone/Basic.lean
theorem StrictMono.id_le {φ : ℕ → ℕ} (h : StrictMono φ) : ∀ n, n ≤ φ n
-- Mathlib/CategoryTheory/Shift/CommShift.lean
@[simp]
lemma isoAdd_hom_app {a b : A}
    (e₁ : shiftFunctor C a ⋙ F ≅ F ⋙ shiftFunctor D a)
    (e₂ : shiftFunctor C b ⋙ F ≅ F ⋙ shiftFunctor D b) (X : C) :
      (CommShift.isoAdd e₁ e₂).hom.app X =
        F.map ((shiftFunctorAdd C a b).hom.app X) ≫ e₂.hom.app ((shiftFunctor C a).obj X) ≫
          (shiftFunctor D b).map (e₁.hom.app X) ≫ (shiftFunctorAdd D a b).inv.app (F.obj X)
-- Mathlib/CategoryTheory/Subobject/Lattice.lean
theorem le_sSup {A : C} (s : Set (Subobject A)) (f) (hf : f ∈ s) : f ≤ sSup s
-- Mathlib/Algebra/MonoidAlgebra/Division.lean
theorem of'_dvd_iff_modOf_eq_zero {x : k[G]} {g : G} :
    of' k G g ∣ x ↔ x %ᵒᶠ g = 0
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addMap_of_Z_eq_zero_left {P : Fin 3 → F} {Q : PointClass F} (hP : W.Nonsingular P)
    (hQ : W.NonsingularLift Q) (hPz : P z = 0) : W.addMap ⟦P⟧ Q = Q
-- Mathlib/Order/Booleanisation.lean
@[simp] lemma lift_sup_lift (a b : α) : lift a ⊔ lift b = lift (a ⊔ b)
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
theorem smul_apply (c : R) (m : OuterMeasure α) (s : Set α) : (c • m) s = c • m s
-- Mathlib/LinearAlgebra/Eigenspace/Semisimple.lean
lemma IsSemisimple.genEigenspace_eq_eigenspace
    (hf : f.IsSemisimple) (μ : R) {k : ℕ} (hk : 0 < k) :
    f.genEigenspace μ k = f.eigenspace μ
-- Mathlib/RingTheory/Perfection.lean
theorem preVal_zero : preVal K v O hv p 0 = 0
-- Mathlib/Data/PNat/Find.lean
protected theorem find_min : ∀ {m : ℕ+}, m < PNat.find h → ¬p m
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_bind (f : β → γ) (g : α → List β) :
    ∀ l : List α, (l.bind g).map f = l.bind fun a => (g a).map f
-- Mathlib/Algebra/Lie/Weights/Chain.lean
lemma lie_mem_weightSpaceChain_of_weightSpace_eq_bot_left [LieAlgebra.IsNilpotent R H]
    (hp : weightSpace M (p • α + χ) = ⊥)
    {x : L} (hx : x ∈ rootSpace H (-α))
    {y : M} (hy : y ∈ weightSpaceChain M α χ p q) :
    ⁅x, y⁆ ∈ weightSpaceChain M α χ p q
-- Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean
/-- If `g` is surjective, then `lTensor Q g` is surjective -/
theorem LinearMap.lTensor_surjective (hg : Function.Surjective g) :
    Function.Surjective (lTensor Q g)
-- Mathlib/Order/CompleteSublattice.lean
/-- The push forward of a complete sublattice under a complete lattice hom is a complete
sublattice. -/
@[simps] def map (L : CompleteSublattice α) : CompleteSublattice β
-- Mathlib/Data/Finset/NoncommProd.lean
@[to_additive (attr := simp)]
theorem noncommProd_coe (l : List α) (comm) : noncommProd (l : Multiset α) comm = l.prod
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
theorem LinearMap.uncurryLeft_apply (f : M 0 →ₗ[R] MultilinearMap R (fun i : Fin n => M i.succ) M₂)
    (m : ∀ i, M i) : f.uncurryLeft m = f (m 0) (tail m)
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem sub_top (x : EReal) : x - ⊤ = ⊥
-- Mathlib/Data/Finset/Basic.lean
theorem erase_insert_subset (a : α) (s : Finset α) : erase (insert a s) a ⊆ s
-- Mathlib/Order/Sublattice.lean
lemma gc_map_comap (f : LatticeHom α β) : GaloisConnection (map f) (comap f)
-- Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean
@[to_additive (attr := simp)]
theorem mul_eq_one_iff : a * b = 1 ↔ a = 1 ∧ b = 1
-- Mathlib/Computability/Halting.lean
protected theorem nil {n} : @Vec n 0 fun _ => nil
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem exponent_min' (n : ℕ) (hpos : 0 < n) (hG : ∀ g : G, g ^ n = 1) : exponent G ≤ n
-- Mathlib/Algebra/Order/Antidiag/Prod.lean
theorem antidiagonal.snd_le {n : A} {kl : A × A} (hlk : kl ∈ antidiagonal n) : kl.2 ≤ n
-- Mathlib/Algebra/Order/Group/Basic.lean
@[to_additive zsmul_right_inj]
lemma zpow_left_inj (hn : n ≠ 0) : a ^ n = b ^ n ↔ a = b
-- Mathlib/Algebra/Group/Conj.lean
theorem mk_injective : Function.Injective (@ConjClasses.mk α _)
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
@[simp]
theorem zero_nadd : 0 ♯ a = a
-- Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean
nonrec theorem ContinuousWithinAt.const_cpow {b : ℂ} (hf : ContinuousWithinAt f s a)
    (h : b ≠ 0 ∨ f a ≠ 0) : ContinuousWithinAt (fun x => b ^ f x) s a
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem extend_union {s₁ s₂ : Set α} (hd : Disjoint s₁ s₂) (h₁ : P s₁) (h₂ : P s₂) :
    extend m (s₁ ∪ s₂) = extend m s₁ + extend m s₂
-- Mathlib/CategoryTheory/Monad/Limits.lean
/-- (Impl) Prove that the lifted cocone is colimiting. -/
@[simps]
def liftedCoconeIsColimit : IsColimit (liftedCocone D c t)
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[ext high]
theorem ext_of_ring {f g : R →ₗc[R] A} (h : f 1 = g 1) : f = g
-- Mathlib/LinearAlgebra/FinsuppVectorSpace.lean
@[simp]
theorem basis_repr {φ : ι → Type*} (b : ∀ i, Basis (φ i) R M) (g : ι →₀ M) (ix) :
    (Finsupp.basis b).repr g ix = (b ix.1).repr (g ix.1) ix.2
-- Mathlib/Data/List/NatAntidiagonal.lean
@[simp]
theorem antidiagonal_succ {n : ℕ} :
    antidiagonal (n + 1) = (0, n + 1) :: (antidiagonal n).map (Prod.map Nat.succ id)
-- Mathlib/CategoryTheory/MorphismProperty/IsInvertedBy.lean
theorem of_comp {C₁ C₂ C₃ : Type*} [Category C₁] [Category C₂] [Category C₃]
    (W : MorphismProperty C₁) (F : C₁ ⥤ C₂) (hF : W.IsInvertedBy F) (G : C₂ ⥤ C₃) :
    W.IsInvertedBy (F ⋙ G)
-- Mathlib/RingTheory/RingHom/FiniteType.lean
theorem finiteType_is_local : PropertyIsLocal @FiniteType
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_of_equiv {P Q : Fin 3 → R} (h : P ≈ Q) : W'.add P Q = W'.dblXYZ P
-- Mathlib/Data/Nat/Cast/Defs.lean
/-- A type class for natural numbers which are greater than or equal to `2`. -/
class Nat.AtLeastTwo (n : ℕ) : Prop where
  prop : n ≥ 2
-- Mathlib/NumberTheory/Liouville/Residual.lean
theorem IsGδ.setOf_liouville : IsGδ { x | Liouville x }
-- Mathlib/Data/Nat/Defs.lean
protected lemma mul_div_cancel_left' (Hd : a ∣ b) : a * (b / a) = b
-- Mathlib/Data/Set/Basic.lean
theorem not_mem_diff_of_mem {s t : Set α} {x : α} (hx : x ∈ t) : x ∉ s \ t
-- Mathlib/Data/Sign.lean
theorem sign_eq_sign (n : ℤ) : Int.sign n = SignType.sign n
-- Mathlib/Data/ENNReal/Real.lean
@[simp]
lemma ofReal_eq_ofNat {r : ℝ} {n : ℕ} [n.AtLeastTwo] :
    ENNReal.ofReal r = no_index (OfNat.ofNat n) ↔ r = OfNat.ofNat n
-- Mathlib/Data/Finsupp/Defs.lean
@[simp, norm_cast]
theorem fun_support_eq (f : α →₀ M) : Function.support f = f.support
-- Mathlib/LinearAlgebra/DFinsupp.lean
/-- Two `R`-linear maps from `Π₀ i, M i` which agree on each `single i x` agree everywhere.

See note [partially-applied ext lemmas].
After apply this lemma, if `M = R` then it suffices to verify `φ (single a 1) = ψ (single a 1)`. -/
@[ext 1100]
theorem lhom_ext' ⦃φ ψ : (Π₀ i, M i) →ₗ[R] N⦄ (h : ∀ i, φ.comp (lsingle i) = ψ.comp (lsingle i)) :
    φ = ψ
-- Mathlib/Data/Set/Prod.lean
@[simp]
theorem offDiag_nonempty : s.offDiag.Nonempty ↔ s.Nontrivial
-- Mathlib/Data/Nat/Multiplicity.lean
/-- The multiplicity of `p` in `choose (n + k) k` is the number of carries when `k` and `n`
  are added in base `p`. The set is expressed by filtering `Ico 1 b` where `b`
  is any bound greater than `log p (n + k)`. -/
theorem multiplicity_choose' {p n k b : ℕ} (hp : p.Prime) (hnb : log p (n + k) < b) :
    multiplicity p (choose (n + k) k) =
      ((Ico 1 b).filter fun i => p ^ i ≤ k % p ^ i + n % p ^ i).card
-- Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean
theorem range_eq_top (coercive : IsCoercive B) : range B♯ = ⊤
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem IsCycle.of_zpow {n : ℤ} (h1 : IsCycle (f ^ n)) (h2 : f.support ⊆ (f ^ n).support) :
    IsCycle f
-- Mathlib/Order/UpperLower/Basic.lean
theorem prod_mono : s₁ ≤ s₂ → t₁ ≤ t₂ → s₁ ×ˢ t₁ ≤ s₂ ×ˢ t₂
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem erase_subset (a : α) (l : List α) : l.erase a ⊆ l
-- Mathlib/Computability/Primrec.lean
theorem list_indexOf₁ [DecidableEq α] (l : List α) : Primrec fun a => l.indexOf a
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueFreeOn_two : G.CliqueFreeOn s 2 ↔ s.Pairwise (G.Adjᶜ)
-- Mathlib/Order/BooleanAlgebra.lean
theorem sdiff_sup : y \ (x ⊔ z) = y \ x ⊓ y \ z
-- Mathlib/RingTheory/Trace/Basic.lean
theorem traceMatrix_reindex {κ' : Type*} (b : Basis κ A B) (f : κ ≃ κ') :
    traceMatrix A (b.reindex f) = reindex f f (traceMatrix A b)
-- Mathlib/RingTheory/DedekindDomain/Different.lean
/-- If `b` is an `A`-integral basis of `L` with discriminant `b`, then `d • a * x` is integral over
  `A` for all `a ∈ I` and `x ∈ Iᵛ`. -/
lemma isIntegral_discr_mul_of_mem_traceDual
    (I : Submodule B L) {ι} [DecidableEq ι] [Fintype ι]
    {b : Basis ι K L} (hb : ∀ i, IsIntegral A (b i))
    {a x : L} (ha : a ∈ I) (hx : x ∈ Iᵛ) :
    IsIntegral A ((discr K b) • a * x)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem equivOfInverse_apply (f₁ : M₁ →SL[σ₁₂] M₂) (f₂ h₁ h₂ x) :
    equivOfInverse f₁ f₂ h₁ h₂ x = f₁ x
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem map_map (g : β → γ) (f : α → β) (s : Multiset α) : map g (map f s) = map (g ∘ f) s
-- Mathlib/LinearAlgebra/Span.lean
/-- Two linear maps are equal on `Submodule.span s` iff they are equal on `s`. -/
theorem eqOn_span_iff {s : Set M} {f g : F} : Set.EqOn f g (span R s) ↔ Set.EqOn f g s
-- Mathlib/Order/Height.lean
theorem wellFoundedGT_of_chainHeight_ne_top (s : Set α) (hs : s.chainHeight ≠ ⊤) :
    WellFoundedGT s
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_zsmul_add (a b : α) (m : ℤ) : toIocDiv hp a (m • p + b) = m + toIocDiv hp a b
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem ofFin_sub (x : Fin (2^n)) (y : BitVec n) : .ofFin x - y = .ofFin (x - y.toFin)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem empty_data : (#[] : Array α).data = []
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem apply_comp_inclusion {T S : E →ₗ.[R] F} (h : T ≤ S) (x : T.domain) :
    T x = S (Submodule.inclusion h.1 x)