ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Sites/OneHypercover.lean
/-- The type of `1`-hypercovers of an object `S : C` in a category equipped with a
Grothendieck topology `J`. This can be constructed from a covering of `S` and
a covering of the fibre products of the objects in this covering (see `OneHypercover.mk'`). -/
structure OneHypercover (S : C) extends PreOneHypercover.{w} S where
  mem₀ : toPreOneHypercover.sieve₀ ∈ J S
  mem₁ (i₁ i₂ : I₀) ⦃W : C⦄ (p₁ : W ⟶ X i₁) (p₂ : W ⟶ X i₂) (w : p₁ ≫ f i₁ = p₂ ≫ f i₂) :
    toPreOneHypercover.sieve₁ p₁ p₂ ∈ J W
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The associator isomorphism which associates a binary biproduct. -/
@[simps]
def biprod.associator (P Q R : C) : (P ⊞ Q) ⊞ R ≅ P ⊞ (Q ⊞ R)
-- Mathlib/Algebra/Algebra/Defs.lean
@[simp]
theorem linearMap_apply (r : R) : Algebra.linearMap R A r = algebraMap R A r
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem equivRealProd_symm_apply (p : ℝ × ℝ) : equivRealProd.symm p = p.1 + p.2 * I
-- Mathlib/GroupTheory/GroupAction/Blocks.lean
theorem isBlock_singleton (a : X) : IsBlock G ({a} : Set X)
-- Mathlib/Algebra/Order/Ring/Cone.lean
/-- A positive cone in a ring consists of a positive cone in underlying `AddCommGroup`,
which contains `1` and such that the positive elements are closed under multiplication. -/
structure PositiveCone (α : Type*) [Ring α] extends AddCommGroup.PositiveCone α where
  /-- In a positive cone, `1` is `nonneg` -/
  one_nonneg : nonneg 1
  /-- In a positive cone, if `a` and `b` are `pos` then so is `a * b` -/
  mul_pos : ∀ a b, pos a → pos b → pos (a * b)
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive]
theorem extend_inv [Inv γ] (f : α → β) (g : α → γ) (e : β → γ) :
    Function.extend f g⁻¹ e⁻¹ = (Function.extend f g e)⁻¹
-- .lake/packages/lean4/src/lean/Init/Data/List/Impl.lean
@[csimp] theorem eraseIdx_eq_eraseIdxTR : @eraseIdx = @eraseIdxTR
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem exists_nat_eq_of_le_nat {c : Cardinal} {n : ℕ} (h : c ≤ n) : ∃ m, m ≤ n ∧ c = m
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
@[ext]
lemma Triangle.hom_ext {A B : Triangle C} (f g : A ⟶ B)
    (h₁ : f.hom₁ = g.hom₁) (h₂ : f.hom₂ = g.hom₂) (h₃ : f.hom₃ = g.hom₃) : f = g
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem differentiable_sin : Differentiable ℂ sin
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
/-- Not an instance since `𝕜` can't be inferred. See `NormedSpace.toLocallyConvexSpace` for a
slightly weaker instance version. -/
theorem NormedSpace.toLocallyConvexSpace' [NormedSpace 𝕜 E] [Module ℝ E] [IsScalarTower ℝ 𝕜 E] :
    LocallyConvexSpace ℝ E
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem const_max (hf : LipschitzWith Kf f) (a : ℝ) : LipschitzWith Kf fun x => max a (f x)
-- .lake/packages/lean4/src/lean/Init/Omega/Int.lean
theorem not_le_of_lt {x y : Int} (h : y < x) : ¬ (x ≤ y)
-- Mathlib/Probability/Independence/Conditional.lean
lemma iCondIndepSet_iff (s : ι → Set Ω) (hs : ∀ i, MeasurableSet (s i))
    (μ : Measure Ω) [IsFiniteMeasure μ] :
    iCondIndepSet m' hm' s μ ↔
      ∀ S : Finset ι, μ⟦⋂ i ∈ S, s i | m'⟧ =ᵐ[μ] ∏ i ∈ S, μ⟦s i | m'⟧
-- Mathlib/Algebra/GroupWithZero/Hom.lean
@[simp] lemma mk_coe (f : α →*₀ β) (h1 hmul) : mk f h1 hmul = f
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem smul_set_subset_iff : a • s ⊆ t ↔ ∀ ⦃b⦄, b ∈ s → a • b ∈ t
-- Mathlib/ModelTheory/Syntax.lean
/-- Relabels a term's variables along a bijection. -/
@[simps]
def relabelEquiv (g : α ≃ β) : L.Term α ≃ L.Term β
-- Mathlib/Topology/Constructions.lean
/-- `Pi.mulSingle i x` is continuous in `x`. -/
-- Porting note (#11215): TODO: restore @[continuity]
@[to_additive "`Pi.single i x` is continuous in `x`."]
theorem continuous_mulSingle [∀ i, One (π i)] [DecidableEq ι] (i : ι) :
    Continuous fun x => (Pi.mulSingle i x : ∀ i, π i)
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_union_add_inter' (hs : MeasurableSet s) (t : Set α) :
    μ.restrict (s ∪ t) + μ.restrict (s ∩ t) = μ.restrict s + μ.restrict t
-- Mathlib/Data/DFinsupp/Order.lean
@[simp]
theorem support_inf : (f ⊓ g).support = f.support ∩ g.support
-- Mathlib/GroupTheory/Exponent.lean
@[to_additive]
theorem exponent_eq_iSup_orderOf (h : ∀ g : G, 0 < orderOf g) :
    exponent G = ⨆ g : G, orderOf g
-- Mathlib/Algebra/Polynomial/Coeff.lean
theorem C_dvd_iff_dvd_coeff (r : R) (φ : R[X]) : C r ∣ φ ↔ ∀ i, r ∣ φ.coeff i
-- Mathlib/Algebra/Star/Subalgebra.lean
@[simp]
theorem subtype_comp_inclusion {S₁ S₂ : StarSubalgebra R A} (h : S₁ ≤ S₂) :
    S₂.subtype.comp (inclusion h) = S₁.subtype
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- If we single out one member of an affine-independent family of points and affinely transport
all others along the line joining them to this member, the resulting new family of points is affine-
independent.

This is the affine version of `LinearIndependent.units_smul`. -/
theorem AffineIndependent.units_lineMap {p : ι → P} (hp : AffineIndependent k p) (j : ι)
    (w : ι → Units k) : AffineIndependent k fun i => AffineMap.lineMap (p j) (p i) (w i : k)
-- Mathlib/Data/Int/Log.lean
@[mono]
theorem log_mono_right {b : ℕ} {r₁ r₂ : R} (h₀ : 0 < r₁) (h : r₁ ≤ r₂) : log b r₁ ≤ log b r₂
-- Mathlib/GroupTheory/Index.lean
@[to_additive two_smul_mem_of_index_two]
theorem sq_mem_of_index_two (h : H.index = 2) (a : G) : a ^ 2 ∈ H
-- Mathlib/Order/PropInstances.lean
@[simp]
theorem inf_Prop_eq : (· ⊓ ·) = (· ∧ ·)
-- Mathlib/Probability/Independence/Kernel.lean
@[to_additive]
theorem iIndepFun.indepFun_finset_prod_of_not_mem (hf_Indep : iIndepFun (fun _ ↦ m) f κ μ)
    (hf_meas : ∀ i, Measurable (f i)) {s : Finset ι} {i : ι} (hi : i ∉ s) :
    IndepFun (∏ j ∈ s, f j) (f i) κ μ
-- Mathlib/CategoryTheory/Localization/Construction.lean
/-- The canonical bijection between objects in a category and its
localization with respect to a morphism_property `W` -/
@[simps]
def objEquiv : C ≃ W.Localization
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem vadd_mem_fundamentalDomain [Fintype ι] (y : span ℤ (Set.range b)) (x : E) :
    y +ᵥ x ∈ fundamentalDomain b ↔ y = -floor b x
-- Mathlib/GroupTheory/Solvable.lean
@[simp]
theorem derivedSeries_zero : derivedSeries G 0 = ⊤
-- Mathlib/Data/List/Sigma.lean
theorem not_eq_key {a} {l : List (Sigma β)} : a ∉ l.keys ↔ ∀ s : Sigma β, s ∈ l → a ≠ s.1
-- Mathlib/CategoryTheory/Subobject/Basic.lean
@[simp]
theorem ofLEMk_comp {B A : C} {X : Subobject B} {f : A ⟶ B} [Mono f] (h : X ≤ mk f) :
    ofLEMk X f h ≫ f = X.arrow
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
protected theorem bijective (e : M ≃* N) : Function.Bijective e
-- Mathlib/Topology/PartitionOfUnity.lean
theorem support_toPOUFun_subset (i : ι) : support (f.toPOUFun i) ⊆ support (f i)
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
/-- If a function is analytic on a set `s`, so are its successive Fréchet derivative. -/
theorem AnalyticOn.iteratedFDeriv [CompleteSpace F] (h : AnalyticOn 𝕜 f s) (n : ℕ) :
    AnalyticOn 𝕜 (iteratedFDeriv 𝕜 n f) s
-- Mathlib/Data/ENNReal/Inv.lean
@[simp] theorem div_pos_iff : 0 < a / b ↔ a ≠ 0 ∧ b ≠ ∞
-- Mathlib/Order/RelIso/Basic.lean
protected theorem wellFounded [RelHomClass F r s] (f : F) : WellFounded s → WellFounded r
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem someExistsOneDivLT_spec (hi : ¬s ≤[i] 0) :
    someExistsOneDivLT s i ⊆ i ∧
      MeasurableSet (someExistsOneDivLT s i) ∧
        (1 / (findExistsOneDivLT s i + 1) : ℝ) < s (someExistsOneDivLT s i)
-- Mathlib/Topology/Bornology/Basic.lean
lemma eventually_ne_cobounded (a : α) : ∀ᶠ x in cobounded α, x ≠ a
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem mem_closure_iff {s : Set R} {x} :
    x ∈ closure s ↔ x ∈ AddSubgroup.closure (Subsemigroup.closure s : Set R)
-- Mathlib/RingTheory/Ideal/Operations.lean
/-- An element `x` lies in the span of `v` iff it can be written as sum `∑ cᵢ • vᵢ = x`.
-/
theorem mem_ideal_span_range_iff_exists_fun [Fintype α] {x : R} {v : α → R} :
    x ∈ Ideal.span (Set.range v) ↔ ∃ c : α → R, ∑ i, c i * v i = x
-- Mathlib/LinearAlgebra/Matrix/Block.lean
theorem det_of_lowerTriangular [LinearOrder m] (M : Matrix m m R) (h : M.BlockTriangular toDual) :
    M.det = ∏ i : m, M i i
-- Mathlib/Order/Closure.lean
theorem closure_iSup_closure (f : ι → α) : u (l (⨆ i, u (l (f i)))) = u (l (⨆ i, f i))
-- Mathlib/Topology/Instances/ENNReal.lean
theorem not_summable_iff_tendsto_nat_atTop {f : ℕ → ℝ≥0} :
    ¬Summable f ↔ Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop atTop
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
@[simp]
protected theorem map_smul [DecidableEq ι] (m : ∀ i, M₁ i) (i : ι) (c : R) (x : M₁ i) :
    f (update m i (c • x)) = c • f (update m i x)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIcoDiv_zsmul_sub_toIcoMod (a b : α) : toIcoDiv hp a b • p + toIcoMod hp a b = b
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem ker_eq_bot' {f : F} : ker f = ⊥ ↔ ∀ m, f m = 0 → m = 0
-- Mathlib/Data/Real/EReal.lean
theorem toReal_add {x y : EReal} (hx : x ≠ ⊤) (h'x : x ≠ ⊥) (hy : y ≠ ⊤) (h'y : y ≠ ⊥) :
    toReal (x + y) = toReal x + toReal y
-- Mathlib/Algebra/Homology/Additive.lean
@[simp]
theorem singleMapHomologicalComplex_hom_app_ne {i j : ι} (h : i ≠ j) (X : W₁) :
    ((singleMapHomologicalComplex F c j).hom.app X).f i = 0
-- Mathlib/Data/Prod/Basic.lean
theorem map_def {f : α → γ} {g : β → δ} : Prod.map f g = fun p : α × β ↦ (f p.1, g p.2)
-- Mathlib/Algebra/Order/Sub/WithTop.lean
@[simp, norm_cast]
theorem coe_sub {a b : α} : (↑(a - b) : WithTop α) = ↑a - ↑b
-- Mathlib/Data/Finsupp/AList.lean
theorem lookupFinsupp_eq_iff_of_ne_zero [DecidableEq α] {l : AList fun _x : α => M} {a : α} {x : M}
    (hx : x ≠ 0) : l.lookupFinsupp a = x ↔ x ∈ l.lookup a
-- Mathlib/Data/Nat/Dist.lean
theorem dist_eq_zero {n m : ℕ} (h : n = m) : dist n m = 0
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_left_le_of_le_add {a b c : Int} (h : a ≤ b + c) : a - b ≤ c
-- Mathlib/Combinatorics/SimpleGraph/Acyclic.lean
theorem isAcyclic_iff_path_unique : G.IsAcyclic ↔ ∀ ⦃v w : V⦄ (p q : G.Path v w), p = q
-- Mathlib/CategoryTheory/Comma/Presheaf.lean
/-- Intermediate stage of assembling the unit. -/
@[simps]
def unitAuxAuxAux {F : Cᵒᵖ ⥤ Type v} (η : F ⟶ A) (X : C) :
    YonedaCollection (restrictedYonedaObj η) X ≅ F.obj (op X)
-- Mathlib/Data/Nat/Factorization/PrimePow.lean
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow
-- Mathlib/FieldTheory/SplittingField/IsSplittingField.lean
theorem IsIntegral.mem_intermediateField_of_minpoly_splits {x : L} (int : IsIntegral K x)
    {F : IntermediateField K L} (h : Splits (algebraMap K F) (minpoly K x)) : x ∈ F
-- Mathlib/Order/WellFounded.lean
protected theorem lt_succ_iff {r : α → α → Prop} [wo : IsWellOrder α r] {x : α} (h : ∃ y, r x y)
    (y : α) : r y (wo.wf.succ x) ↔ r y x ∨ y = x
-- Mathlib/LinearAlgebra/Span.lean
theorem mem_span_insert' {x y} {s : Set M} :
    x ∈ span R (insert y s) ↔ ∃ a : R, x + a • y ∈ span R s
-- Mathlib/RingTheory/PolynomialAlgebra.lean
@[simp] theorem matPolyEquiv_map_C (M : Matrix n n R) : matPolyEquiv (M.map C) = C M
-- Mathlib/MeasureTheory/Function/EssSup.lean
theorem essSup_congr_ae {f g : α → β} (hfg : f =ᵐ[μ] g) : essSup f μ = essSup g μ
-- Mathlib/FieldTheory/Perfect.lean
theorem roots_expand_image_frobenius [DecidableEq R] :
    (expand R p f).roots.toFinset.image (frobenius R p) = f.roots.toFinset
-- Mathlib/Data/Multiset/Basic.lean
theorem union_comm (s t : Multiset α) : s ∪ t = t ∪ s
-- Mathlib/Topology/Homotopy/Path.lean
theorem hpath_hext {p₁ : Path x₀ x₁} {p₂ : Path x₂ x₃} (hp : ∀ t, p₁ t = p₂ t) :
    @HEq (Path.Homotopic.Quotient _ _) ⟦p₁⟧ (Path.Homotopic.Quotient _ _) ⟦p₂⟧
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_ssubset_Icc_right (hI : a₂ ≤ b₂) (ha : a₂ ≤ a₁) (hb : b₁ < b₂) :
    Icc a₁ b₁ ⊂ Icc a₂ b₂
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- The sum of weighted homogeneous polynomials of degree `n` is weighted homogeneous of
  weighted degree `n`. -/
theorem sum {ι : Type*} (s : Finset ι) (φ : ι → MvPolynomial σ R) (n : M) {w : σ → M}
    (h : ∀ i ∈ s, IsWeightedHomogeneous w (φ i) n) : IsWeightedHomogeneous w (∑ i ∈ s, φ i) n
-- Mathlib/Data/DFinsupp/Basic.lean
/-- Equality of sigma types is sufficient (but not necessary) to show equality of `DFinsupp`s. -/
theorem single_eq_of_sigma_eq {i j} {xi : β i} {xj : β j} (h : (⟨i, xi⟩ : Sigma β) = ⟨j, xj⟩) :
    DFinsupp.single i xi = DFinsupp.single j xj
-- Mathlib/CategoryTheory/Monoidal/End.lean
/-- If `m ⊗ n ≅ 𝟙_M` and `n ⊗ m ≅ 𝟙_M` (subject to some commuting constraints),
  then `F.obj m` and `F.obj n` forms a self-equivalence of `C`. -/
@[simps]
noncomputable def equivOfTensorIsoUnit (m n : M) (h₁ : m ⊗ n ≅ 𝟙_ M) (h₂ : n ⊗ m ≅ 𝟙_ M)
    (H : h₁.hom ▷ m ≫ (λ_ m).hom = (α_ m n m).hom ≫ m ◁ h₂.hom ≫ (ρ_ m).hom) : C ≌ C
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_bool : #Bool = 2
-- Mathlib/Data/Set/Image.lean
theorem preimage_eq_empty_iff {s : Set β} : f ⁻¹' s = ∅ ↔ Disjoint s (range f)
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
theorem ofConjAct_zero : ofConjAct (0 : ConjAct G₀) = 0
-- Mathlib/Combinatorics/SimpleGraph/Maps.lean
/-- A graph embedding induces an embedding of edge sets. -/
@[simps]
def mapEdgeSet : G.edgeSet ↪ G'.edgeSet
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem ofLeftInverse_apply {g : S → R} {f : R →+* S} (h : Function.LeftInverse g f) (x : R) :
    ↑(ofLeftInverse h x) = f x
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
theorem self_mem_adjoin_singleton (x : A) : x ∈ adjoin R ({x} : Set A)
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_iff_infinite_and_pos {x : ℝ*} : InfinitePos x ↔ Infinite x ∧ 0 < x
-- Mathlib/Logic/Basic.lean
theorem not_imp_not : ¬a → ¬b ↔ b → a
-- Mathlib/NumberTheory/ModularForms/Basic.lean
@[simp, norm_cast]
lemma coe_intCast (Γ : Subgroup SL(2, ℤ)) (z : ℤ) :
    ⇑(z : ModularForm Γ 0) = z
-- Mathlib/Algebra/Ring/BooleanRing.lean
@[simp]
theorem add_self : a + a = 0
-- Mathlib/NumberTheory/ZetaValues.lean
theorem hasSum_one_div_nat_pow_mul_fourier {k : ℕ} (hk : 2 ≤ k) {x : ℝ} (hx : x ∈ Icc (0 : ℝ) 1) :
    HasSum
      (fun n : ℕ =>
        (1 : ℂ) / (n : ℂ) ^ k * (fourier n (x : 𝕌) + (-1 : ℂ) ^ k * fourier (-n) (x : 𝕌)))
      (-(2 * π * I) ^ k / k ! * bernoulliFun k x)
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
@[simp]
theorem csSup_Icc (h : a ≤ b) : sSup (Icc a b) = b
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem strictMono_mul_right_of_pos [MulPosStrictMono α]
    (ha : 0 < a) : StrictMono fun x => x * a
-- Mathlib/RingTheory/IsAdjoinRoot.lean
/-- If `f` is monic, the powers of `h.root` form a basis. -/
@[simps! gen dim basis]
def powerBasis (h : IsAdjoinRootMonic S f) : PowerBasis R S
-- Mathlib/Algebra/GroupPower/IterateHom.lean
@[to_additive]
theorem SemiconjBy.function_semiconj_mul_left (h : SemiconjBy a b c) :
    Function.Semiconj (a * ·) (b * ·) (c * ·)
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem lcm_mul_right {m n k : ℕ} : (m * n).lcm (k * n) = m.lcm k * n
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem closure_preimage_le (f : F) (s : Set S) :
    closure ((f : R → S) ⁻¹' s) ≤ (closure s).comap f
-- Mathlib/Analysis/Convex/GaugeRescale.lean
theorem mapsTo_gaugeRescale_interior (h₀ : t ∈ 𝓝 0) (hc : Convex ℝ t) :
    MapsTo (gaugeRescale s t) (interior s) (interior t)
-- Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean
/-- A polynomial of weightedTotalDegree `⊥` is weighted_homogeneous of degree `⊥`. -/
theorem isWeightedHomogeneous_of_total_degree_zero [SemilatticeSup M] [OrderBot M] (w : σ → M)
    {p : MvPolynomial σ R} (hp : weightedTotalDegree w p = (⊥ : M)) :
    IsWeightedHomogeneous w p (⊥ : M)
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
theorem cpow_add {x : ℂ} (y z : ℂ) (hx : x ≠ 0) : x ^ (y + z) = x ^ y * x ^ z
-- Mathlib/LinearAlgebra/SymplecticGroup.lean
theorem symplectic_det (hA : A ∈ symplecticGroup l R) : IsUnit <| det A
-- Mathlib/LinearAlgebra/Isomorphisms.lean
theorem quotientInfEquivSupQuotient_symm_apply_right (p p' : Submodule R M) {x : ↥(p ⊔ p')}
    (hx : (x : M) ∈ p') : (quotientInfEquivSupQuotient p p').symm (Submodule.Quotient.mk x)
    = 0
-- Mathlib/CategoryTheory/Triangulated/Basic.lean
/-- The functor `C ⥤ Triangle C` which sends `X` to `contractibleTriangle X`. -/
@[simps]
def contractibleTriangleFunctor [HasZeroObject C] [HasZeroMorphisms C] : C ⥤ Triangle C
-- Mathlib/Algebra/BigOperators/Fin.lean
@[to_additive (attr := simp)]
theorem prod_univ_two [CommMonoid β] (f : Fin 2 → β) : ∏ i, f i = f 0 * f 1
-- Mathlib/CategoryTheory/Square.lean
/-- The equivalence `Square C ≌ Arrow (Arrow C)` which sends a
commutative square `sq` to the obvious arrow from the left morphism of `sq`
to the right morphism of `sq`. -/
@[simps]
def arrowArrowEquivalence : Square C ≌ Arrow (Arrow C)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := mono)]
theorem toSubmonoid_mono : Monotone (toSubmonoid : Subgroup G → Submonoid G)
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
theorem arrow_mk_iso_iff (P : MorphismProperty C) [RespectsIso P] {W X Y Z : C}
    {f : W ⟶ X} {g : Y ⟶ Z} (e : Arrow.mk f ≅ Arrow.mk g) : P f ↔ P g
-- Mathlib/RingTheory/Localization/NumDen.lean
theorem exists_reduced_fraction (x : K) :
    ∃ (a : A) (b : nonZeroDivisors A), IsRelPrime a b ∧ mk' K a b = x
-- Mathlib/Analysis/SpecialFunctions/Polynomials.lean
theorem abs_div_tendsto_atTop_of_degree_gt (hdeg : Q.degree < P.degree) (hQ : Q ≠ 0) :
    Tendsto (fun x => |eval x P / eval x Q|) atTop atTop
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive]
theorem lift_of_eq_id (α) : lift of = MonoidHom.id (FreeGroup α)
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma leftHomology_ext_iff {A : C} (f₁ f₂ : S.leftHomology ⟶ A) :
    f₁ = f₂ ↔ S.leftHomologyπ ≫ f₁ = S.leftHomologyπ ≫ f₂
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
/-- The power function `x ↦ x^s` is integrable on `(0, t)` iff `-1 < s`. -/
lemma integrableOn_Ioo_rpow_iff {s t : ℝ} (ht : 0 < t) :
    IntegrableOn (fun x ↦ x ^ s) (Ioo (0 : ℝ) t) ↔ -1 < s
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem sigmaCongrRight_refl {α} {β : α → Sort _} :
    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a)
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem roots_mem_integralClosure {f : R[X]} (hf : f.Monic) {a : S}
    (ha : a ∈ f.aroots S) : a ∈ integralClosure R S
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
lemma exists_mem_toTriangle {x y : α ⊕ β ⊕ γ} (hxy : (graph t).Adj x y) :
    ∃ z ∈ t, x ∈ toTriangle z ∧ y ∈ toTriangle z
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem blocks_sum : c.blocks.sum = n
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
@[simp]
theorem translationNumber_one : τ 1 = 0
-- Mathlib/SetTheory/Game/Birthday.lean
@[simp]
theorem birthday_add : ∀ x y : PGame.{u}, (x + y).birthday = x.birthday ♯ y.birthday
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
@[simp]
lemma equiv_mkInv (L : C ⥤ D) [L.IsLocalization W] {X Y : C} (f : Y ⟶ X) (hf : W f)
    [HasSmallLocalizedHom.{w} W X Y] :
    equiv.{w} W L (mkInv f hf) = (Localization.isoOfHom L W f hf).inv
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem card_le_ofNat {o} {n : ℕ} [n.AtLeastTwo] :
    card o ≤ (no_index (OfNat.ofNat n)) ↔ o ≤ OfNat.ofNat n
-- Mathlib/Data/Complex/Exponential.lean
theorem cosh_add : cosh (x + y) = cosh x * cosh y + sinh x * sinh y
-- Mathlib/Order/Hom/Lattice.lean
@[simp] theorem dual_id : LatticeHom.dual (LatticeHom.id α) = LatticeHom.id _
-- Mathlib/Data/List/OfFn.lean
@[simp]
theorem ofFn_eq_nil_iff {n : ℕ} {f : Fin n → α} : ofFn f = [] ↔ n = 0
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem aleph'_nat : ∀ n : ℕ, aleph' n = n
-- Mathlib/Topology/MetricSpace/ThickenedIndicator.lean
theorem thickenedIndicator_subset {δ : ℝ} (δ_pos : 0 < δ) {E₁ E₂ : Set α} (subset : E₁ ⊆ E₂) :
    ⇑(thickenedIndicator δ_pos E₁) ≤ thickenedIndicator δ_pos E₂
-- Mathlib/Data/Int/Defs.lean
lemma le_add_one_iff : m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1
-- Mathlib/Order/OmegaCompletePartialOrder.lean
/-- An omega-complete partial order is a partial order with a supremum
operation on increasing sequences indexed by natural numbers (which we
call `ωSup`). In this sense, it is strictly weaker than join complete
semi-lattices as only ω-sized totally ordered sets have a supremum.

See the definition on page 114 of [gunter1992]. -/
class OmegaCompletePartialOrder (α : Type*) extends PartialOrder α where
  /-- The supremum of an increasing sequence -/
  ωSup : Chain α → α
  /-- `ωSup` is an upper bound of the increasing sequence -/
  le_ωSup : ∀ c : Chain α, ∀ i, c i ≤ ωSup c
  /-- `ωSup` is a lower bound of the set of upper bounds of the increasing sequence -/
  ωSup_le : ∀ (c : Chain α) (x), (∀ i, c i ≤ x) → ωSup c ≤ x
-- Mathlib/Logic/Small/Group.lean
@[simp]
lemma equivShrink_sub [Sub α] [Small α] (x y : α) :
    equivShrink α (x - y) = equivShrink α x - equivShrink α y
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
private theorem testBit_limit {x i : Nat} (x_lt_succ : x < 2^(i+1)) :
    testBit x i = decide (x ≥ 2^i)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[csimp] theorem repeat_eq_repeatTR : @repeat = @repeatTR
-- Mathlib/RingTheory/LocalRing/Basic.lean
theorem of_unique_nonzero_prime (h : ∃! P : Ideal R, P ≠ ⊥ ∧ Ideal.IsPrime P) : LocalRing R
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
lemma toNNReal_mul_add_neg_mul_add_mul_neg_eq (f g : C(X, ℝ)₀) :
    ((f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal) =
    ((-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal)
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
@[reassoc]
lemma leftHomologyMap_comp [HasLeftHomology S₁] [HasLeftHomology S₂] [HasLeftHomology S₃]
    (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃) :
    leftHomologyMap (φ₁ ≫ φ₂) = leftHomologyMap φ₁ ≫ leftHomologyMap φ₂
-- Mathlib/Algebra/Order/Rearrangement.lean
/-- **Rearrangement Inequality**: Pointwise scalar multiplication of `f` and `g` is minimized when
`f` and `g` antivary together. Stated by permuting the entries of `f`. -/
theorem Antivary.sum_smul_le_sum_comp_perm_smul (hfg : Antivary f g) :
    ∑ i, f i • g i ≤ ∑ i, f (σ i) • g i
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
theorem isClosedMap_smul_left (c : E) : IsClosedMap fun x : 𝕜 => x • c
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[reassoc (attr := simp)]
lemma germ_stalkIso_hom {X : Scheme.{u}} (U : X.Opens)
    {V : U.toScheme.Opens} (x : V) :
      U.toScheme.presheaf.germ x ≫ (U.stalkIso x.1).hom =
        X.presheaf.germ ⟨x.1.1, show x.1.1 ∈ U.ι ''ᵁ V from ⟨x.1, x.2, rfl⟩⟩
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
lemma isIso_of_isIso_map (hF : F.FullyFaithful) {X Y : C} (f : X ⟶ Y) [IsIso (F.map f)] :
    IsIso f
-- Mathlib/Algebra/Order/Group/Abs.lean
@[to_additive] lemma mabs_mul_eq_mul_mabs_iff (a b : α) :
    |a * b|ₘ = |a|ₘ * |b|ₘ ↔ 1 ≤ a ∧ 1 ≤ b ∨ a ≤ 1 ∧ b ≤ 1
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem getLsb_intMax_eq (w : Nat) : (intMax w).getLsb i = decide (i < w)
-- Mathlib/Order/Interval/Set/Monotone.lean
protected theorem MonotoneOn.Ici (hf : MonotoneOn f s) : AntitoneOn (fun x => Ici (f x)) s
-- Mathlib/Algebra/BigOperators/Finsupp.lean
@[simp]
theorem sum_hom_add_index [AddZeroClass M] [AddCommMonoid N] {f g : α →₀ M} (h : α → M →+ N) :
    ((f + g).sum fun x => h x) = (f.sum fun x => h x) + g.sum fun x => h x
-- Mathlib/Topology/MetricSpace/Basic.lean
@[simp]
theorem dist_eq_zero {x y : γ} : dist x y = 0 ↔ x = y
-- Mathlib/Data/Multiset/Fintype.lean
/-- Another way to coerce a `Multiset` to a type is to go through `m.toEnumFinset` and coerce
that `Finset` to a type. -/
@[simps]
def Multiset.coeEquiv (m : Multiset α) : m ≃ m.toEnumFinset
-- Mathlib/Algebra/Module/LinearMap/Defs.lean
/-- The linear map version of `Function.Surjective.injective_comp_right` -/
lemma _root_.Function.Surjective.injective_linearMapComp_right (hg : Surjective g) :
    Injective fun f : M₂ →ₛₗ[σ₂₃] M₃ ↦ f.comp g