ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean
/-- If `U` is qcqs, then `Γ(X, D(f)) ≃ Γ(X, U)_f` for every `f : Γ(X, U)`.
This is known as the **Qcqs lemma** in [R. Vakil, *The rising sea*][RisingSea]. -/
theorem isIso_ΓSpec_adjunction_unit_app_basicOpen {X : Scheme} [CompactSpace X]
    [QuasiSeparatedSpace X] (f : X.presheaf.obj (op ⊤)) :
    IsIso ((ΓSpec.adjunction.unit.app X).val.c.app (op (PrimeSpectrum.basicOpen f)))
-- Mathlib/Topology/Connected/PathConnected.lean
@[simp]
theorem symm_symm (γ : Path x y) : γ.symm.symm = γ
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
@[simp]
theorem differentiableAt_id' : DifferentiableAt 𝕜 (fun x => x) x
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem smooth_proj : Smooth (IB.prod 𝓘(𝕜, F)) IB (π F E)
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean
@[ext]
theorem explicitCokernel_hom_ext {X Y Z : SemiNormedGrp.{u}} {f : X ⟶ Y}
    (e₁ e₂ : explicitCokernel f ⟶ Z) (h : explicitCokernelπ f ≫ e₁ = explicitCokernelπ f ≫ e₂) :
    e₁ = e₂
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem degree_smul_of_smul_regular {S : Type*} [Monoid S] [DistribMulAction S R] {k : S}
    (p : R[X]) (h : IsSMulRegular R k) : (k • p).degree = p.degree
-- Mathlib/Analysis/Calculus/Deriv/Linear.lean
protected theorem ContinuousLinearMap.hasDerivWithinAt : HasDerivWithinAt e (e 1) s x
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
theorem card_biUnion_le [DecidableEq β] {s : Finset α} {t : α → Finset β} :
    (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
-- Mathlib/Topology/Basic.lean
theorem frontier_eq_closure_inter_closure : frontier s = closure s ∩ closure sᶜ
-- Mathlib/CategoryTheory/GradedObject/Unitor.lean
lemma mapBifunctorLeftUnitor_hasMap :
    HasMap (((mapBifunctor F I J).obj ((single₀ I).obj X)).obj Y) p
-- Mathlib/GroupTheory/GroupAction/SubMulAction/Pointwise.lean
theorem mem_mul {p q : SubMulAction R M} {x : M} : x ∈ p * q ↔ ∃ y ∈ p, ∃ z ∈ q, y * z = x
-- Mathlib/RingTheory/Polynomial/Chebyshev.lean
theorem U_eq (n : ℤ) : U R n = 2 * X * U R (n - 1) - U R (n - 2)
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem add_tsub_assoc_of_le (hc : AddLECancellable c) (h : c ≤ b) (a : α) :
    a + b - c = a + (b - c)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
/-- A strongly measurable function is almost everywhere measurable. -/
@[aesop 5% apply (rule_sets := [Measurable])]
protected theorem aemeasurable {_ : MeasurableSpace α} [TopologicalSpace β]
    [PseudoMetrizableSpace β] [MeasurableSpace β] [BorelSpace β] {μ : Measure α}
    (hf : StronglyMeasurable f) : AEMeasurable f μ
-- Mathlib/Topology/Constructions.lean
theorem isOpenMap_inl : IsOpenMap (@inl X Y)
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
/-- Pointwise, the multiplicative indicators of δ-thickenings of a set eventually coincide
with the multiplicative indicator of the set as δ>0 tends to zero. -/
@[to_additive "Pointwise, the indicators of δ-thickenings of a set eventually coincide
with the indicator of the set as δ>0 tends to zero."]
lemma mulIndicator_thickening_eventually_eq_mulIndicator_closure (f : α → β) (E : Set α) (x : α) :
    ∀ᶠ δ in 𝓝[>] (0 : ℝ),
      (Metric.thickening δ E).mulIndicator f x = (closure E).mulIndicator f x
-- Mathlib/Algebra/MvPolynomial/CommRing.lean
theorem degreeOf_sub_lt {x : σ} {f g : MvPolynomial σ R} {k : ℕ} (h : 0 < k)
    (hf : ∀ m : σ →₀ ℕ, m ∈ f.support → k ≤ m x → coeff m f = coeff m g)
    (hg : ∀ m : σ →₀ ℕ, m ∈ g.support → k ≤ m x → coeff m f = coeff m g) :
    degreeOf x (f - g) < k
-- Mathlib/Topology/Sets/Closeds.lean
@[simp, norm_cast] lemma Closeds.isAtom_coe [T1Space α] {s : Closeds α} :
    IsAtom (s : Set α) ↔ IsAtom s
-- Mathlib/Data/Part.lean
theorem inter_mem_inter [Inter α] (a b : Part α) (ma mb : α) (ha : ma ∈ a) (hb : mb ∈ b) :
    ma ∩ mb ∈ a ∩ b
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
theorem toAffineMap_injective : Injective (toAffineMap : (P₁ ≃ᵃ[k] P₂) → P₁ →ᵃ[k] P₂)
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_nnnorm_eq_sup (f : WithLp ∞ (α × β)) : ‖f‖₊ = ‖f.fst‖₊ ⊔  ‖f.snd‖₊
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem eval₂Hom_congr {f₁ f₂ : R →+* S₁} {g₁ g₂ : σ → S₁} {p₁ p₂ : MvPolynomial σ R} :
    f₁ = f₂ → g₁ = g₂ → p₁ = p₂ → eval₂Hom f₁ g₁ p₁ = eval₂Hom f₂ g₂ p₂
-- Mathlib/Data/Complex/Exponential.lean
theorem tanh_conj : tanh (conj x) = conj (tanh x)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
lemma rightShift_leftShift (a n' : ℤ) (hn' : n + a = n') :
    (γ.leftShift a n' hn').rightShift a n hn' =
      (a * n' + (a * (a - 1)) / 2).negOnePow • γ.shift a
-- Mathlib/Probability/Independence/Kernel.lean
lemma iIndepFun.meas_iInter [Fintype ι] (hf : iIndepFun mβ f κ μ)
    (hs : ∀ i, MeasurableSet[(mβ i).comap (f i)] (s i)) :
    ∀ᵐ a ∂μ, κ a (⋂ i, s i) = ∏ i, κ a (s i)
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Valid'.merge_lemma {a b c : ℕ} (h₁ : 3 * a < b + c + 1) (h₂ : b ≤ 3 * c) :
    2 * (a + b) ≤ 9 * c + 5
-- Mathlib/LinearAlgebra/Projection.lean
@[simp]
theorem coe_equivProdOfSurjectiveOfIsCompl {f : E →ₗ[R] F} {g : E →ₗ[R] G} (hf : range f = ⊤)
    (hg : range g = ⊤) (hfg : IsCompl (ker f) (ker g)) :
    (equivProdOfSurjectiveOfIsCompl f g hf hg hfg : E →ₗ[R] F × G) = f.prod g
-- Mathlib/Data/List/Range.lean
@[simp] theorem range'_one {s step : ℕ} : range' s 1 step = [s]
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem lineDerivWithin_congr_set (h : s =ᶠ[𝓝 x] t) :
    lineDerivWithin 𝕜 f s x v = lineDerivWithin 𝕜 f t x v
-- Mathlib/Algebra/BigOperators/Ring/Multiset.lean
@[simp] lemma prod_eq_zero_iff : s.prod = 0 ↔ (0 : α) ∈ s
-- Mathlib/Order/Heyting/Boundary.lean
theorem boundary_le_hnot : ∂ a ≤ ￢a
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
theorem aedisjoint_compl_left : AEDisjoint μ sᶜ s
-- Mathlib/Data/Option/NAry.lean
theorem map₂_comm {g : β → α → γ} (h_comm : ∀ a b, f a b = g b a) : map₂ f a b = map₂ g b a
-- Mathlib/Topology/Algebra/Module/WeakDual.lean
@[simp]
theorem continuousLinearMapToWeakSpace_eq_toWeakSpace (x : E) :
    continuousLinearMapToWeakSpace 𝕜 E x = toWeakSpace 𝕜 E x
-- Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean
lemma toClass_some {x y : F} (h : W.Nonsingular x y) :
    toClass (some h) = ClassGroup.mk (CoordinateRing.XYIdeal' h)
-- Mathlib/Analysis/NormedSpace/AddTorsorBases.lean
theorem Convex.interior_nonempty_iff_affineSpan_eq_top [FiniteDimensional ℝ V] {s : Set V}
    (hs : Convex ℝ s) : (interior s).Nonempty ↔ affineSpan ℝ s = ⊤
-- Mathlib/Order/SuccPred/CompleteLinearOrder.lean
lemma IsGLB.mem_of_not_isPredLimit (hs : IsGLB s x) (hx : ¬ IsPredLimit x) :
    x ∈ s
-- Mathlib/Order/Filter/Archimedean.lean
theorem Tendsto.atBot_zsmul_neg_const {f : α → ℤ} (hr : r < 0) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x • r) l atTop
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- `AnalyticOn.comp` for functions on product spaces -/
theorem AnalyticOn.comp₂ {h : F × G → H} {f : E → F} {g : E → G} {s : Set (F × G)} {t : Set E}
    (ha : AnalyticOn 𝕜 h s) (fa : AnalyticOn 𝕜 f t) (ga : AnalyticOn 𝕜 g t)
    (m : ∀ x, x ∈ t → (f x, g x) ∈ s) : AnalyticOn 𝕜 (fun x ↦ h (f x, g x)) t
-- Mathlib/RingTheory/RingHom/Finite.lean
theorem finite_stableUnderComposition : StableUnderComposition @Finite
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
lemma ne_zero [CharZero R] : (P.root i : M) ≠ 0
-- Mathlib/RingTheory/Localization/Ideal.lean
theorem mem_map_algebraMap_iff {I : Ideal R} {z} : z ∈ Ideal.map (algebraMap R S) I ↔
    ∃ x : I × M, z * algebraMap R S x.2 = algebraMap R S x.1
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem tmul_pow (a : A) (b : B) (k : ℕ) : a ⊗ₜ[R] b ^ k = (a ^ k) ⊗ₜ[R] (b ^ k)
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
lemma equalizer_mem [G.IsDenseSubsite J K] {U V} (f₁ f₂ : U ⟶ V) (e : G.map f₁ = G.map f₂) :
    Sieve.equalizer f₁ f₂ ∈ J _
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem log_inv (x : ℂ) (hx : x.arg ≠ π) : log x⁻¹ = -log x
-- Mathlib/Data/Finset/Sort.lean
theorem sort_sorted_gt (s : Finset α) : List.Sorted (· > ·) (sort (· ≥ ·) s)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem valuation_eq_iff (x y : K) : A.valuation x = A.valuation y ↔ ∃ a : Aˣ, (a : K) * y = x
-- Mathlib/Topology/UniformSpace/Equiv.lean
@[simp]
theorem prodCongr_symm (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ) :
    (h₁.prodCongr h₂).symm = h₁.symm.prodCongr h₂.symm
-- Mathlib/Algebra/Homology/TotalComplexSymmetry.lean
@[reassoc]
lemma totalFlipIso_hom_f_D₁ (j j' : J) :
    (K.totalFlipIso c).hom.f j ≫ K.D₁ c j j' =
      K.flip.D₂ c j j' ≫ (K.totalFlipIso c).hom.f j'
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem pred_inj :
    ∀ {a b : Fin (n + 1)} {ha : a ≠ 0} {hb : b ≠ 0}, a.pred ha = b.pred hb ↔ a = b
-- Mathlib/NumberTheory/MulChar/Basic.lean
lemma ringHomComp_mul (χ φ : MulChar R R') (f : R' →+* R'') :
    (χ * φ).ringHomComp f = χ.ringHomComp f * φ.ringHomComp f
-- Mathlib/RingTheory/Multiplicity.lean
theorem pow_dvd_of_le_multiplicity {a b : α} {k : ℕ} :
    (k : PartENat) ≤ multiplicity a b → a ^ k ∣ b
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem map_continuous' {β γ : Type v} (f : β → γ) (g : α → Part β) (hg : Continuous' g) :
    Continuous' fun x => f <$> g x
-- Mathlib/Algebra/Module/Zlattice/Covolume.lean
theorem covolume_eq_measure_fundamentalDomain {F : Set E} (h : IsAddFundamentalDomain L F μ) :
    covolume L μ = (μ F).toReal
-- Mathlib/Data/NNReal/Basic.lean
lemma toNNReal_lt_natCast {r : ℝ} {n : ℕ} (hn : n ≠ 0) : r.toNNReal < n ↔ r < n
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@[fun_prop]
lemma continuous_realContinuousMapOfNNReal (φ : C(X, ℝ≥0) →⋆ₐ[ℝ≥0] A)
    (hφ : Continuous φ) : Continuous φ.realContinuousMapOfNNReal
-- Mathlib/Topology/Instances/ENNReal.lean
@[simp]
theorem Metric.diam_closure {α : Type*} [PseudoMetricSpace α] (s : Set α) :
    Metric.diam (closure s) = diam s
-- Mathlib/LinearAlgebra/LinearPMap.lean
@[simp]
theorem neg_apply (f : E →ₗ.[R] F) (x) : (-f) x = -f x
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
/-- The right fraction from `X` to `Y` given by a morphism `f : X ⟶ Y`. -/
@[simps]
def ofHom (f : X ⟶ Y) [W.ContainsIdentities] :
    W.RightFraction X Y
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem gcd_same [NormalizedGCDMonoid α] (a : α) : gcd a a = normalize a
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem zero_of_le_dist (hx : f.rOut ≤ dist x c) : f x = 0
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma isClosed_iff_isUpper : IsClosed s ↔ IsUpperSet s
-- Mathlib/LinearAlgebra/Vandermonde.lean
theorem vandermonde_mul_vandermonde_transpose {n : ℕ} (v w : Fin n → R) (i j) :
    (vandermonde v * (vandermonde w)ᵀ) i j = ∑ k : Fin n, (v i * w j) ^ (k : ℕ)
-- Mathlib/Data/List/Perm.lean
theorem length_permutations (l : List α) : length (permutations l) = (length l)!
-- Mathlib/Data/Finsupp/Defs.lean
theorem erase_update_of_ne (f : α →₀ M) {a a' : α} (ha : a ≠ a') (b : M) :
    erase a (update f a' b) = update (erase a f) a' b
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[reassoc] -- Porting note: simp can solve both versions
theorem biprod.inr_snd {X Y : C} [HasBinaryBiproduct X Y] :
    (biprod.inr : Y ⟶ X ⊞ Y) ≫ (biprod.snd : X ⊞ Y ⟶ Y) = 𝟙 Y
-- Mathlib/RingTheory/Adjoin/Basic.lean
lemma commute_of_mem_adjoin_of_forall_mem_commute {a b : A} {s : Set A}
    (hb : b ∈ adjoin R s) (h : ∀ b ∈ s, Commute a b) :
    Commute a b
-- Mathlib/Data/Matroid/Constructions.lean
theorem not_rkPos_iff : ¬RkPos M ↔ M = loopyOn M.E
-- Mathlib/RingTheory/HahnSeries/Summable.lean
theorem embDomain_succ_smul_powers :
    (x • powers x hx).embDomain ⟨Nat.succ, Nat.succ_injective⟩ =
      powers x hx - ofFinsupp (Finsupp.single 0 1)
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
lemma iteratedFDeriv_aux {α : Type*} [DecidableEq α]
    (s : Set ι) [DecidableEq { x // x ∈ s }] (e : α ≃ s)
    (m : α → ((i : ι) → M₁ i)) (a : α) (z : (i : ι) → M₁ i) :
    (fun i ↦ update m a z (e.symm i) i) =
      (fun i ↦ update (fun j ↦ m (e.symm j) j) (e a) (z (e a)) i)
-- Mathlib/Algebra/Category/ModuleCat/Sheaf/Generators.lean
lemma opEpi_id (σ : M.GeneratingSections) :
    σ.ofEpi (𝟙 M) = σ
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_fn_mkRingHomOfMulSelfOfTwoNeZero (h h_two h_one) :
    (f.mkRingHomOfMulSelfOfTwoNeZero h h_two h_one : β → α) = f
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem proof_irrel_heq {p q : Prop} (hp : p) (hq : q) : HEq hp hq
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean
/-- The angle between the negation of a nonzero vector and that
vector. -/
@[simp]
theorem angle_neg_self_of_nonzero {x : V} (hx : x ≠ 0) : angle (-x) x = π
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive (attr := simp)]
theorem le_one_iff : f ≤ 1 ↔ (1 : Set α) ∈ f
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma negMap_eq {P : Fin 3 → R} : W'.negMap ⟦P⟧ = ⟦W'.neg P⟧
-- Mathlib/CategoryTheory/Iso.lean
@[simp]
theorem hom_inv_id (f : X ⟶ Y) [I : IsIso f] : f ≫ inv f = 𝟙 X
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem _root_.ContinuousLinearMap.intervalIntegral_apply {a b : ℝ} {φ : ℝ → F →L[𝕜] E}
    (hφ : IntervalIntegrable φ μ a b) (v : F) :
    (∫ x in a..b, φ x ∂μ) v = ∫ x in a..b, φ x v ∂μ
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem div_eq_ediv_of_dvd {a b : Int} (h : b ∣ a) : a.div b = a / b
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem leftInverse_splittingOfFinsuppSurjective (f : M →ₗ[R] α →₀ R) (s : Surjective f) :
    LeftInverse f (splittingOfFinsuppSurjective f s)
-- Mathlib/Data/Vector/MapLemmas.lean
/--
  If an accumulation function `f`, given an initial state `s`, produces `s` as its output state
  for all possible input bits, then the state is redundant and can be optimized out
-/
@[simp]
theorem mapAccumr₂_eq_map₂_of_constant_state (f : α → β → σ → σ × γ) (s : σ)
    (h : ∀ a b, (f a b s).fst = s) :
    mapAccumr₂ f xs ys s = (s, (map₂ (fun x y => (f x y s).snd) xs ys))
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem ediv_pos_of_pos_of_dvd {a b : Int} (H1 : 0 < a) (H2 : 0 ≤ b) (H3 : b ∣ a) : 0 < a / b
-- Mathlib/MeasureTheory/Function/UnifTight.lean
theorem unifTight_iff_real {_ : MeasurableSpace α} (f : ι → α → β) (p : ℝ≥0∞) (μ : Measure α) :
    UnifTight f p μ ↔ ∀ ⦃ε : ℝ⦄, 0 < ε → ∃ s : Set α,
      μ s ≠ ∞ ∧ ∀ i, eLpNorm (sᶜ.indicator (f i)) p μ ≤ .ofReal ε
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem id_continuous' : Continuous' (@id α)
-- Mathlib/Data/Fintype/BigOperators.lean
theorem Fintype.card_fun [DecidableEq α] [Fintype α] [Fintype β] :
    Fintype.card (α → β) = Fintype.card β ^ Fintype.card α
-- Mathlib/Data/Real/EReal.lean
lemma mul_top_of_pos : ∀ {x : EReal}, 0 < x → x * ⊤ = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem natAbs_lt_natAbs_of_nonneg_of_lt {a b : Int}
    (w₁ : 0 ≤ a) (w₂ : a < b) : a.natAbs < b.natAbs
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
/-- Sum of a multiset of elements in a `Subsemiring` of a `Semiring` is
in the `add_subsemiring`. -/
protected theorem multiset_sum_mem (m : Multiset R) : (∀ a ∈ m, a ∈ s) → m.sum ∈ s
-- Mathlib/MeasureTheory/Constructions/HaarToSphere.lean
theorem toSphere_apply' {s : Set (sphere (0 : E) 1)} (hs : MeasurableSet s) :
    μ.toSphere s = dim E * μ (Ioo (0 : ℝ) 1 • ((↑) '' s))
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- The algebra of sets generated by a family of sets is an algebra of sets. -/
theorem isSetAlgebra_generateSetAlgebra :
    IsSetAlgebra (generateSetAlgebra 𝒜)
-- Mathlib/CategoryTheory/Bicategory/Free.lean
theorem liftHom₂_congr {a b : FreeBicategory B} {f g : a ⟶ b} {η θ : Hom₂ f g} (H : Rel η θ) :
    liftHom₂ F η = liftHom₂ F θ
-- Mathlib/RingTheory/PowerSeries/Order.lean
/-- The order of a formal power series is exactly `n` if the `n`th coefficient is nonzero,
and the `i`th coefficient is `0` for all `i < n`. -/
theorem order_eq {φ : R⟦X⟧} {n : PartENat} :
    order φ = n ↔ (∀ i : ℕ, ↑i = n → coeff R i φ ≠ 0) ∧ ∀ i : ℕ, ↑i < n → coeff R i φ = 0
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem symm_dual_comp (g : SupBotHom βᵒᵈ γᵒᵈ) (f : SupBotHom αᵒᵈ βᵒᵈ) :
    InfTopHom.dual.symm (g.comp f) =
      (InfTopHom.dual.symm g).comp (InfTopHom.dual.symm f)
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma mop_hom_leftUnitor (X : C) : (λ_ X).hom.mop = (ρ_ (mop X)).hom
-- Mathlib/Tactic/NormNum/Result.lean
theorem IsInt.neg_to_eq {α} [Ring α] {n} :
    {a a' : α} → IsInt a (.negOfNat n) → n = a' → a = -a'
-- Mathlib/MeasureTheory/OuterMeasure/Operations.lean
@[simp]
theorem coe_smul (c : R) (m : OuterMeasure α) : ⇑(c • m) = c • ⇑m
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
/-- If there are zero morphisms, any initial object is a zero object. -/
theorem hasZeroObject_of_hasInitial_object [HasZeroMorphisms C] [HasInitial C] :
    HasZeroObject C
-- Mathlib/Order/Interval/Finset/Defs.lean
theorem Iic_toDual (a : α) : Iic (toDual a) = (Ici a).map toDual.toEmbedding
-- Mathlib/Geometry/Manifold/Algebra/LeftInvariantDerivation.lean
/-- The coercion to function is a monoid homomorphism. -/
@[simps]
def coeFnAddMonoidHom : LeftInvariantDerivation I G →+ C^∞⟮I, G; 𝕜⟯ → C^∞⟮I, G; 𝕜⟯
-- Mathlib/Topology/Irreducible.lean
theorem IsIrreducible.image (H : IsIrreducible s) (f : X → Y) (hf : ContinuousOn f s) :
    IsIrreducible (f '' s)
-- Mathlib/GroupTheory/GroupAction/Hom.lean
lemma inverse_eq_inverse' (f : X →[M] Y₁) (g : Y₁ → X)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
  inverse f g h₁ h₂ =  inverse' f g (congrFun rfl) h₁ h₂
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] lemma _root_.EquivLike.coe_symm_apply_apply {F} [EquivLike F α β] (e : F) (x : α) :
    (e : α ≃ β).symm (e x) = x
-- Mathlib/Order/Max.lean
theorem noBotOrder_iff_noMinOrder (α : Type*) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α
-- Mathlib/SetTheory/Ordinal/FixedPoint.lean
theorem nfpFamily_le_iff {a b} : nfpFamily.{u, v} f a ≤ b ↔ ∀ l, List.foldr f a l ≤ b
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem gcd_sub_self_left {m n : ℕ} (h : m ≤ n) : gcd (n - m) m = gcd n m
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem tendsto_atBot_isGLB (h_mono : Monotone f) (ha : IsGLB (Set.range f) a) :
    Tendsto f atBot (𝓝 a)
-- Mathlib/CategoryTheory/Category/Quiv.lean
/-- Any prefunctor into a category lifts to a functor from the path category. -/
@[simps]
def lift {V : Type u} [Quiver.{v + 1} V] {C : Type*} [Category C] (F : Prefunctor V C) :
    Paths V ⥤ C
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
@[simp] theorem nnnorm_equiv (f : PiLp ∞ β) : ‖WithLp.equiv ⊤ _ f‖₊ = ‖f‖₊
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
theorem centralizer_le (s t : Set A) (h : s ⊆ t) : centralizer R t ≤ centralizer R s
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc, simp]
theorem whiskerRight_id {X Y : C} (f : X ⟶ Y) :
    f ▷ 𝟙_ C = (ρ_ X).hom ≫ f ≫ (ρ_ Y).inv
-- Mathlib/Data/List/Cycle.lean
theorem Subsingleton.nodup {s : Cycle α} (h : Subsingleton s) : Nodup s
-- Mathlib/Order/Interval/Set/Infinite.lean
theorem Icc_infinite : (Icc a b).Infinite
-- Mathlib/Data/Set/Lattice.lean
theorem InjOn.image_biInter_eq {p : ι → Prop} {s : ∀ i, p i → Set α} (hp : ∃ i, p i)
    {f : α → β} (h : InjOn f (⋃ (i) (hi), s i hi)) :
    (f '' ⋂ (i) (hi), s i hi) = ⋂ (i) (hi), f '' s i hi
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
theorem getD_leftInvSeq_mul_self (ω : List B) (j : ℕ) :
    ((lis ω).getD j 1) * ((lis ω).getD j 1) = 1
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
/-- The identity functor is fully faithful. -/
@[simps]
def id : (𝟭 C).FullyFaithful
-- Mathlib/RingTheory/Artinian.lean
theorem isArtinian_of_linearEquiv (f : M ≃ₗ[R] P) [IsArtinian R M] : IsArtinian R P
-- Mathlib/Data/Real/EReal.lean
lemma inv_nonpos_of_nonpos {a : EReal} (h : a ≤ 0) : a⁻¹ ≤ 0
-- Mathlib/MeasureTheory/Group/Prod.lean
/-- The map `(x, y) ↦ (x, x⁻¹y)` is measure-preserving.
This is the function `S⁻¹` in [Halmos, §59],
where `S` is the map `(x, y) ↦ (x, xy)`. -/
@[to_additive measurePreserving_prod_neg_add
"The map `(x, y) ↦ (x, - x + y)` is measure-preserving."]
theorem measurePreserving_prod_inv_mul [IsMulLeftInvariant ν] :
    MeasurePreserving (fun z : G × G => (z.1, z.1⁻¹ * z.2)) (μ.prod ν) (μ.prod ν)
-- Mathlib/ModelTheory/Semantics.lean
@[simp]
theorem realize_subst {φ : L.BoundedFormula α n} {tf : α → L.Term β} {v : β → M} {xs : Fin n → M} :
    (φ.subst tf).Realize v xs ↔ φ.Realize (fun a => (tf a).realize v) xs
-- Mathlib/Topology/Inseparable.lean
theorem inseparable_iff_specializes_and : (x ~ᵢ y) ↔ x ⤳ y ∧ y ⤳ x
-- Mathlib/Probability/Kernel/Basic.lean
theorem comapRight_apply (κ : Kernel α β) (hf : MeasurableEmbedding f) (a : α) :
    comapRight κ hf a = Measure.comap f (κ a)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- Two affine subspaces are equal if they have the same points. -/
theorem coe_injective : Function.Injective ((↑) : AffineSubspace k P → Set P)
-- Mathlib/Algebra/Category/Grp/EquivalenceGroupAddGroup.lean
/-- The functor `CommGroup ⥤ AddCommGroup` by sending `X ↦ additive X` and `f ↦ f`.
-/
@[simps]
def toAddCommGrp : CommGrp ⥤ AddCommGrp
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
@[simp]
lemma toMvPolynomial_id : (id : M₁ →ₗ[R] M₁).toMvPolynomial b₁ b₁ = X
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[simp]
lemma mem_subgroup (a : α) : a ∈ α^*M ↔ ∀ m : M, m • a = a
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
theorem mk_multiset_of_isEmpty (α : Type u) [IsEmpty α] : #(Multiset α) = 1
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- A mono between objects with equally sized fibers is an iso. -/
lemma isIso_of_mono_of_eq_card_fiber {X Y : C} (f : X ⟶ Y) [Mono f]
    (h : Nat.card (F.obj X) = Nat.card (F.obj Y)) : IsIso f
-- Mathlib/Topology/Order/DenselyOrdered.lean
@[simp, nolint simpNF]
theorem tendsto_comp_coe_Ioi_atBot :
    Tendsto (fun x : Ioi a => f x) atBot l ↔ Tendsto f (𝓝[>] a) l
-- Mathlib/Data/Nat/PartENat.lean
@[simp]
theorem toWithTop_le {x y : PartENat} [hx : Decidable x.Dom] [hy : Decidable y.Dom] :
    toWithTop x ≤ toWithTop y ↔ x ≤ y
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem succ_zero_eq_one : Fin.succ (0 : Fin (n + 1)) = 1
-- Mathlib/Data/Option/Basic.lean
@[simp]
theorem get!_some [Inhabited α] (a : α) : (some a).get! = a
-- Mathlib/Control/LawfulFix.lean
theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j
-- Mathlib/Order/JordanHolder.lean
theorem snoc_snoc_swap {s : CompositionSeries X} {x₁ x₂ y₁ y₂ : X} {hsat₁ : IsMaximal s.last x₁}
    {hsat₂ : IsMaximal s.last x₂} {hsaty₁ : IsMaximal (snoc s x₁ hsat₁).last y₁}
    {hsaty₂ : IsMaximal (snoc s x₂ hsat₂).last y₂} (hr₁ : Iso (s.last, x₁) (x₂, y₂))
    (hr₂ : Iso (x₁, y₁) (s.last, x₂)) :
    Equivalent (snoc (snoc s x₁ hsat₁) y₁ hsaty₁) (snoc (snoc s x₂ hsat₂) y₂ hsaty₂)
-- Mathlib/Topology/ContinuousOn.lean
theorem Filter.Tendsto.if_nhdsWithin {f g : α → β} {p : α → Prop} [DecidablePred p] {a : α}
    {s : Set α} {l : Filter β} (h₀ : Tendsto f (𝓝[s ∩ { x | p x }] a) l)
    (h₁ : Tendsto g (𝓝[s ∩ { x | ¬p x }] a) l) :
    Tendsto (fun x => if p x then f x else g x) (𝓝[s] a) l
-- Mathlib/Algebra/Star/SelfAdjoint.lean
theorem mem_iff {x : R} : x ∈ skewAdjoint R ↔ star x = -x
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
@[simp]
theorem mem_split_iff : J ∈ split I i x ↔ ↑J = I.splitLower i x ∨ ↑J = I.splitUpper i x
-- Mathlib/LinearAlgebra/QuadraticForm/IsometryEquiv.lean
@[simp]
theorem coe_toLinearEquiv (f : Q₁.IsometryEquiv Q₂) : ⇑(f : M₁ ≃ₗ[R] M₂) = f
-- Mathlib/AlgebraicGeometry/Morphisms/Basic.lean
/--
`P` is local at the target if
1. `P` respects isomorphisms.
2. If `P` holds for `f : X ⟶ Y`, then `P` holds for `f ∣_ U` for any `U`.
3. If `P` holds for `f ∣_ U` for an open cover `U` of `Y`, then `P` holds for `f`.
-/
protected lemma mk' {P : MorphismProperty Scheme} [P.RespectsIso]
    (restrict : ∀ {X Y : Scheme} (f : X ⟶ Y) (U : X.Opens), P f → P (U.ι ≫ f))
    (of_sSup_eq_top :
      ∀ {X Y : Scheme.{u}} (f : X ⟶ Y) {ι : Type u} (U : ι → X.Opens), iSup U = ⊤ →
        (∀ i, P ((U i).ι ≫ f)) → P f) :
    IsLocalAtSource P
-- Mathlib/Algebra/Star/Pointwise.lean
protected theorem star_mul [Mul α] [StarMul α] (s t : Set α) : (s * t)⋆ = t⋆ * s⋆