ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Preadditive/Injective.lean
theorem iso_iff {P Q : C} (i : P ≅ Q) : Injective P ↔ Injective Q
-- Mathlib/Data/Stream/Init.lean
@[simp]
theorem head_map (s : Stream' α) : head (map f s) = f (head s)
-- Mathlib/GroupTheory/Exponent.lean
/-- The exponent is zero iff for all nonzero `n`, one can find a `g` such that `g ^ n ≠ 1`. -/
@[to_additive "The exponent is zero iff for all nonzero `n`, one can find a `g` such that
`n • g ≠ 0`."]
theorem exponent_eq_zero_iff_forall : exponent G = 0 ↔ ∀ n > 0, ∃ g : G, g ^ n ≠ 1
-- Mathlib/Combinatorics/Enumerative/Composition.lean
@[simp]
theorem ones_length (n : ℕ) : (ones n).length = n
-- Mathlib/CategoryTheory/Sites/IsSheafFor.lean
theorem FamilyOfElements.comp_of_compatible (S : Sieve X) {x : FamilyOfElements P S}
    (t : x.Compatible) {f : Y ⟶ X} (hf : S f) {Z} (g : Z ⟶ Y) :
    x (g ≫ f) (S.downward_closed hf g) = P.map g.op (x f hf)
-- Mathlib/Algebra/Group/Opposite.lean
@[simp] lemma op_zpow (x : α) (z : ℤ) : op (x ^ z) = op x ^ z
-- Mathlib/Geometry/Manifold/MFDeriv/UniqueDifferential.lean
/-- If a set in a manifold has the unique derivative property, then its pullback by any extended
chart, in the vector space, also has the unique derivative property. -/
theorem UniqueMDiffOn.uniqueDiffOn_target_inter (hs : UniqueMDiffOn I s) (x : M) :
    UniqueDiffOn 𝕜 ((extChartAt I x).target ∩ (extChartAt I x).symm ⁻¹' s)
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem _root_.MeasurableEmbedding.setIntegral_map {Y} {_ : MeasurableSpace Y} {f : X → Y}
    (hf : MeasurableEmbedding f) (g : Y → E) (s : Set Y) :
    ∫ y in s, g y ∂Measure.map f μ = ∫ x in f ⁻¹' s, g (f x) ∂μ
-- Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean
@[simp]
theorem MonoidWithZero.coe_inverse {M : Type*} [CommMonoidWithZero M] :
    (MonoidWithZero.inverse : M → M) = Ring.inverse
-- Mathlib/Algebra/Order/Ring/Basic.lean
theorem pow_right_mono (h : 1 ≤ a) : Monotone (a ^ ·)
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
lemma C_Ψ₂Sq : C W.Ψ₂Sq = W.ψ₂ ^ 2 - 4 * W.toAffine.polynomial
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma measurable_singularPart_fun_right (κ η : Kernel α γ) (a : α) :
    Measurable (fun x : γ ↦ Real.toNNReal (rnDerivAux κ (κ + η) a x)
      - Real.toNNReal (1 - rnDerivAux κ (κ + η) a x) * rnDeriv κ η a x)
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- Any three points in an orthocentric system are affinely independent. -/
theorem OrthocentricSystem.affineIndependent {s : Set P} (ho : OrthocentricSystem s) {p : Fin 3 → P}
    (hps : Set.range p ⊆ s) (hpi : Function.Injective p) : AffineIndependent ℝ p
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
protected nonrec theorem HasDerivAt.iterate {f : 𝕜 → 𝕜} {f' : 𝕜} (hf : HasDerivAt f f' x)
    (hx : f x = x) (n : ℕ) : HasDerivAt f^[n] (f' ^ n) x
-- Mathlib/RingTheory/HahnSeries/Basic.lean
theorem leadingCoeff_ne_iff {x : HahnSeries Γ R} : x.leadingCoeff ≠ 0 ↔ x ≠ 0
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- A binary bicone morphism between two binary bicones for the same diagram is a morphism of the
binary bicone points which commutes with the cone and cocone legs. -/
structure BinaryBiconeMorphism {P Q : C} (A B : BinaryBicone P Q) where
  /-- A morphism between the two vertex objects of the bicones -/
  hom : A.pt ⟶ B.pt
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  wfst : hom ≫ B.fst = A.fst := by aesop_cat
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  wsnd : hom ≫ B.snd = A.snd := by aesop_cat
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  winl : A.inl ≫ hom = B.inl := by aesop_cat
  /-- The triangle consisting of the two natural transformations and `hom` commutes -/
  winr : A.inr ≫ hom = B.inr := by aesop_cat
-- Mathlib/Topology/DiscreteQuotient.lean
@[simp]
theorem map_id : map _ (leComap_id A) = id
-- Mathlib/Data/ENNReal/Real.lean
theorem iSup_natCast : ⨆ n : ℕ, (n : ℝ≥0∞) = ∞
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem indexesOf_nil [BEq α] : ([] : List α).indexesOf x = []
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[reassoc (attr := simp)]
theorem triangle_assoc_comp_right_inv (X Y : C) :
    (ρ_ X).inv ▷ Y ≫ (α_ X (𝟙_ C) Y).hom = X ◁ (λ_ Y).inv
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- A rotation of a nonzero vector equals that vector if and only if the angle is zero. -/
@[simp]
theorem rotation_eq_self_iff_angle_eq_zero {x : V} (hx : x ≠ 0) (θ : Real.Angle) :
    o.rotation θ x = x ↔ θ = 0
-- Mathlib/Order/Filter/Basic.lean
theorem mem_comap_iff {f : Filter β} {m : α → β} (inj : Injective m) (large : Set.range m ∈ f)
    {S : Set α} : S ∈ comap m f ↔ m '' S ∈ f
-- Mathlib/CategoryTheory/ChosenFiniteProducts/FunctorCategory.lean
@[simp]
lemma leftUnitor_inv_app (F : J ⥤ C) (j : J) :
    (λ_ F).inv.app j = (λ_ (F.obj j)).inv
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem sub_def' (a b : Rat) : a - b = mkRat (a.num * b.den - b.num * a.den) (a.den * b.den)
-- Mathlib/Data/Multiset/Sym.lean
@[simp] theorem sym2_coe (xs : List α) : (xs : Multiset α).sym2 = xs.sym2
-- Mathlib/Data/Fintype/Basic.lean
theorem invFun_restrict [Nonempty α] : (Set.range f).restrict (invFun f) = hf.invOfMemRange
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean
theorem cos_arcsin (x : ℝ) : cos (arcsin x) = √(1 - x ^ 2)
-- Mathlib/Computability/TMToPartrec.lean
theorem exists_code {n} {f : Vector ℕ n →. ℕ} (hf : Nat.Partrec' f) :
    ∃ c : Code, ∀ v : Vector ℕ n, c.eval v.1 = pure <$> f v
-- Mathlib/Data/Set/List.lean
theorem range_list_map (f : α → β) : range (map f) = { l | ∀ x ∈ l, x ∈ range f }
-- Mathlib/Data/Finsupp/Defs.lean
@[simp]
theorem onFinset_apply {s : Finset α} {f : α → M} {hf a} : (onFinset s f hf : α →₀ M) a = f a
-- Mathlib/Data/Num/Lemmas.lean
@[simp]
theorem cast_one' [One α] [Add α] : (PosNum.one : α) = 1
-- Mathlib/LinearAlgebra/FreeModule/Basic.lean
theorem infinite [Infinite R] [Nontrivial M] : Infinite M
-- Mathlib/Topology/Order/OrderClosed.lean
theorem eventually_gt_of_tendsto_gt {l : Filter γ} {f : γ → α} {u v : α} (hv : u < v)
    (h : Filter.Tendsto f l (𝓝 v)) : ∀ᶠ a in l, u < f a
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem u_smooth : ContDiff ℝ ⊤ (u : E → ℝ)
-- Mathlib/Data/List/Zip.lean
@[deprecated getElem_zip (since := "2024-06-12")]
theorem get_zip {l : List α} {l' : List β} {i : Fin (zip l l').length} :
    (zip l l').get i =
      (l.get ⟨i, lt_length_left_of_zip i.isLt⟩, l'.get ⟨i, lt_length_right_of_zip i.isLt⟩)
-- Mathlib/Data/Finset/Basic.lean
theorem union_union_union_comm (s t u v : Finset α) : s ∪ t ∪ (u ∪ v) = s ∪ u ∪ (t ∪ v)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem nonneg_def {a : Int} : NonNeg a ↔ ∃ n : Nat, a = n
-- Mathlib/Analysis/BoxIntegral/Partition/Split.lean
@[simp]
theorem compl_top : (⊤ : Prepartition I).compl = ⊥
-- Mathlib/Topology/Separation.lean
theorem preimage [TopologicalSpace Y] {f : X → Y} {s t : Set Y} (h : SeparatedNhds s t)
    (hf : Continuous f) : SeparatedNhds (f ⁻¹' s) (f ⁻¹' t)
-- Mathlib/Analysis/SpecialFunctions/Complex/Log.lean
theorem log_I : log I = π / 2 * I
-- Mathlib/Algebra/Module/Submodule/Equiv.lean
@[simp]
theorem ofLeftInverse_apply [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂]
    (h : Function.LeftInverse g f) (x : M) : ↑(ofLeftInverse h x) = f x
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
theorem volumeForm_map {F : Type*} [NormedAddCommGroup F] [InnerProductSpace ℝ F]
    [Fact (finrank ℝ F = n)] (φ : E ≃ₗᵢ[ℝ] F) (x : Fin n → F) :
    (Orientation.map (Fin n) φ.toLinearEquiv o).volumeForm x = o.volumeForm (φ.symm ∘ x)
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[to_additive (attr := simp)]
theorem zero_comp : (0 : GroupSeminorm E).comp f = 0
-- Mathlib/Data/Finset/Basic.lean
@[simp, norm_cast]
theorem coe_eq_empty {s : Finset α} : (s : Set α) = ∅ ↔ s = ∅
-- Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean
private lemma piEquivOfFintype_comp_ofTensorProduct_eq :
    piEquivOfFintype I (fun _ : ι ↦ R) ∘ₗ ofTensorProduct I (ι → R) =
      (TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι).toLinearMap
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
lemma bot_lt_mul_inv {I : FractionalIdeal R₁⁰ K} (hI : I ≠ ⊥) : ⊥ < I * I⁻¹
-- Mathlib/Data/Nat/Set.lean
@[simp]
protected theorem range_succ : range succ = { i | 0 < i }
-- Mathlib/Data/Finset/Lattice.lean
theorem iInf_option_toFinset (o : Option α) (f : α → β) : ⨅ x ∈ o.toFinset, f x = ⨅ x ∈ o, f x
-- Mathlib/Data/Num/Bitwise.lean
@[simp] lemma shiftl_eq_shiftLeft (p : Num) (n : Nat) : p.shiftl n = p <<< n
-- Mathlib/Data/Set/Prod.lean
theorem Nonempty.prod : s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem sum_biUnion_boxes {M : Type*} [AddCommMonoid M] (π : Prepartition I)
    (πi : ∀ J, Prepartition J) (f : Box ι → M) :
    (∑ J ∈ π.boxes.biUnion fun J => (πi J).boxes, f J) =
      ∑ J ∈ π.boxes, ∑ J' ∈ (πi J).boxes, f J'
-- Mathlib/Algebra/Homology/HomotopyCategory/Triangulated.lean
@[reassoc]
lemma mappingConeCompHomotopyEquiv_comm₂ :
    (mappingConeCompHomotopyEquiv f g).hom ≫
      (triangle (mappingConeCompTriangle f g).mor₁).mor₃ =
      (mappingConeCompTriangle f g).mor₃
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- If `ν` is a finite measure, and `s ⊆ α × β` is measurable, then `x ↦ ν { y | (x, y) ∈ s }` is
  a measurable function. `measurable_measure_prod_mk_left` is strictly more general. -/
theorem measurable_measure_prod_mk_left_finite [IsFiniteMeasure ν] {s : Set (α × β)}
    (hs : MeasurableSet s) : Measurable fun x => ν (Prod.mk x ⁻¹' s)
-- Mathlib/RingTheory/Polynomial/Content.lean
@[simp]
theorem content_one : content (1 : R[X]) = 1
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem xn_modEq_x2n_sub_lem {n j} (h : j ≤ n) : xn a1 (2 * n - j) + xn a1 j ≡ 0 [MOD xn a1 n]
-- Mathlib/Order/Heyting/Basic.lean
theorem himp_def [∀ i, HImp (π i)] (a b : ∀ i, π i) : a ⇨ b = fun i => a i ⇨ b i
-- Mathlib/Algebra/Lie/Semisimple/Defs.lean
/-- A Lie algebra is simple if it is irreducible as a Lie module over itself via the adjoint
action, and it is non-Abelian. -/
class IsSimple : Prop where
  eq_bot_or_eq_top : ∀ I : LieIdeal R L, I = ⊥ ∨ I = ⊤
  non_abelian : ¬IsLieAbelian L
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
/-- A version of `IsPrimitiveRoot.eq_pow_of_mem_rootsOfUnity` that takes a natural number `k`
as argument instead of a `PNat` (and `ζ : R` instead of `ζ : Rˣ`). -/
lemma eq_pow_of_mem_rootsOfUnity' {k : ℕ} (hk : 0 < k) {ζ : R} (hζ : IsPrimitiveRoot ζ k) {ξ : Rˣ}
    (hξ : ξ ∈ rootsOfUnity (⟨k, hk⟩ : ℕ+) R) :
    ∃ i < k, ζ ^ i = ξ
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem image_symm_eq_preimage (e : M₁ ≃SL[σ₁₂] M₂) (s : Set M₂) :
    e.symm '' s = e ⁻¹' s
-- Mathlib/CategoryTheory/Sites/CoverLifting.lean
/-- If `G` is cocontinuous, then `G.op.ran` pushes sheaves to sheaves.

This is SGA 4 III 2.2. An alternative reference is
https://stacks.math.columbia.edu/tag/00XK (where results
are obtained under the additional assumption that
`C` and `D` have pullbacks).
-/
theorem ran_isSheaf_of_isCocontinuous (ℱ : Sheaf J A) :
    Presheaf.IsSheaf K (G.op.ran.obj ℱ.val)
-- Mathlib/AlgebraicGeometry/Morphisms/Constructors.lean
/-- If `P` is local at the target, to show that `P` is stable under base change, it suffices to
check this for base change along a morphism of affine schemes. -/
lemma stableUnderBaseChange_of_stableUnderBaseChangeOnAffine_of_isLocalAtTarget
    (P : MorphismProperty Scheme) [IsLocalAtTarget P]
    (hP₂ : (of P).StableUnderBaseChange) :
    P.StableUnderBaseChange
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
@[simp] theorem sign_nonneg : 0 ≤ sign x ↔ 0 ≤ x
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Icc_diff_both : Icc a b \ {a, b} = Ioo a b
-- Mathlib/SetTheory/Ordinal/CantorNormalForm.lean
theorem zero_CNF {o : Ordinal} (ho : o ≠ 0) : CNF 0 o = [⟨0, o⟩]
-- Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean
@[simp]
theorem quadraticCharFun_zero : quadraticCharFun F 0 = 0
-- Mathlib/GroupTheory/DoubleCoset.lean
theorem union_quotToDoset (H K : Subgroup G) : ⋃ q, quotToDoset H K q = Set.univ
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem cliqueFree_bot (h : 2 ≤ n) : (⊥ : SimpleGraph α).CliqueFree n
-- Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean
/-- The **Cayley-Hamilton Theorem** for f.g. modules over arbitrary rings states that for each
`R`-endomorphism `φ` of an `R`-module `M` such that `φ(M) ≤ I • M` for some ideal `I`, there
exists some `n` and some `aᵢ ∈ Iⁱ` such that `φⁿ + a₁ φⁿ⁻¹ + ⋯ + aₙ = 0`.

This is the version found in Eisenbud 4.3, which is slightly weaker than Matsumura 2.1
(this lacks the constraint on `n`), and is slightly stronger than Atiyah-Macdonald 2.4.
-/
theorem LinearMap.exists_monic_and_coeff_mem_pow_and_aeval_eq_zero_of_range_le_smul
    [Module.Finite R M] (f : Module.End R M) (I : Ideal R) (hI : LinearMap.range f ≤ I • ⊤) :
    ∃ p : R[X], p.Monic ∧ (∀ k, p.coeff k ∈ I ^ (p.natDegree - k)) ∧ Polynomial.aeval f p = 0
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem Function.Surjective.lieModule_lcs_map_eq (k : ℕ) :
    (lowerCentralSeries R L M k : Submodule R M).map g = lowerCentralSeries R L₂ M₂ k
-- Mathlib/Data/Finset/NAry.lean
/-- If `b` is a right identity for `f : α → β → α`, then `{b}` is a right identity for
`Finset.image₂ f`. -/
theorem image₂_right_identity {f : γ → β → γ} {b : β} (h : ∀ a, f a b = a) (s : Finset γ) :
    image₂ f s {b} = s
-- Mathlib/Topology/MetricSpace/Gluing.lean
theorem toGlueL_isometry (hΦ : Isometry Φ) (hΨ : Isometry Ψ) : Isometry (toGlueL hΦ hΨ)
-- Mathlib/Analysis/SpecialFunctions/Log/Deriv.lean
@[simp]
theorem fderiv.log (hf : DifferentiableAt ℝ f x) (hx : f x ≠ 0) :
    fderiv ℝ (fun x => log (f x)) x = (f x)⁻¹ • fderiv ℝ f x
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
theorem sumInv_comp_sum : sumInv I M ∘ₗ sum I M = LinearMap.id
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
lemma isRightAdjoint (adj : F ⊣ G) : G.IsRightAdjoint
-- Mathlib/GroupTheory/OrderOfElement.lean
@[to_additive]
theorem Subgroup.pow_index_mem {G : Type*} [Group G] (H : Subgroup G) [Normal H] (g : G) :
    g ^ index H ∈ H
-- Mathlib/Order/Antichain.lean
theorem image (hs : IsAntichain r s) (f : α → β) (h : ∀ ⦃a b⦄, r' (f a) (f b) → r a b) :
    IsAntichain r' (f '' s)
-- Mathlib/Topology/Separation.lean
lemma Set.Subsingleton.isClosed [T1Space X] {A : Set X} (h : A.Subsingleton) : IsClosed A
-- Mathlib/Analysis/InnerProductSpace/PiL2.lean
@[simp]
protected theorem repr_reindex (b : OrthonormalBasis ι 𝕜 E) (e : ι ≃ ι') (x : E) (i' : ι') :
    (b.reindex e).repr x i' = b.repr x (e.symm i')
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem isBigO_const_mul_right_iff' {g : α → R} {c : R} (hc : IsUnit c) :
    (f =O[l] fun x => c * g x) ↔ f =O[l] g
-- Mathlib/Analysis/Calculus/FDeriv/Basic.lean
theorem hasFDerivWithinAt_congr_set (h : s =ᶠ[𝓝 x] t) :
    HasFDerivWithinAt f f' s x ↔ HasFDerivWithinAt f f' t x
-- Mathlib/LinearAlgebra/AffineSpace/AffineEquiv.lean
@[simp]
theorem coe_toAffineMap (e : P₁ ≃ᵃ[k] P₂) : (e.toAffineMap : P₁ → P₂) = (e : P₁ → P₂)
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem not_isDiag_of_mem_edgeSet : e ∈ edgeSet G → ¬e.IsDiag
-- Mathlib/Topology/Homotopy/Basic.lean
@[simp]
theorem apply_zero (F : HomotopyWith f₀ f₁ P) (x : X) : F (0, x) = f₀ x
-- Mathlib/Algebra/Group/Subgroup/Finite.lean
@[to_additive (attr := simp 1100, norm_cast)]
theorem val_list_prod (l : List H) : (l.prod : G) = (l.map Subtype.val).prod
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem ceil_map_map_zero_le : ⌈f (g 0)⌉ ≤ ⌈f 0⌉ + ⌈g 0⌉
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem sin_arg (x : ℂ) : Real.sin (arg x) = x.im / abs x
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- A variation of the emetric characterization of Cauchy sequences that deals with
`ℝ≥0` upper bounds. -/
theorem cauchySeq_iff_NNReal [Nonempty β] [SemilatticeSup β] {u : β → α} :
    CauchySeq u ↔ ∀ ε : ℝ≥0, 0 < ε → ∃ N, ∀ n, N ≤ n → edist (u n) (u N) < ε
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean
/-- Oriented angles are continuous when the vectors involved are nonzero. -/
theorem continuousAt_oangle {x : V × V} (hx1 : x.1 ≠ 0) (hx2 : x.2 ≠ 0) :
    ContinuousAt (fun y : V × V => o.oangle y.1 y.2) x
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem head!_append [Inhabited α] (t : List α) {s : List α} (h : s ≠ []) :
    head! (s ++ t) = head! s
-- Mathlib/RingTheory/Ideal/Operations.lean
@[deprecated smul_inf_le (since := "2024-03-31")]
protected theorem smul_inf_le (M₁ M₂ : Submodule R M) :
    I • (M₁ ⊓ M₂) ≤ I • M₁ ⊓ I • M₂
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
theorem isSheaf_iff_multiequalizer [∀ (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)] :
    IsSheaf J P ↔ ∀ (X : C) (S : J.Cover X), IsIso (S.toMultiequalizer P)
-- Mathlib/Order/WithBot.lean
theorem coe_le : ∀ {o : Option α}, b ∈ o → ((a : WithBot α) ≤ o ↔ a ≤ b)
-- Mathlib/Data/Set/Lattice.lean
theorem inj_on_iUnion_of_directed {s : ι → Set α} (hs : Directed (· ⊆ ·) s) {f : α → β}
    (hf : ∀ i, InjOn f (s i)) : InjOn f (⋃ i, s i)
-- Mathlib/NumberTheory/LSeries/Linearity.lean
lemma LSeries.term_add_apply (f g : ℕ → ℂ) (s : ℂ) (n : ℕ) :
    term (f + g) s n = term f s n + term g s n
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem normSq_pos {z : ℂ} : 0 < normSq z ↔ z ≠ 0
-- Mathlib/Analysis/InnerProductSpace/WeakOperatorTopology.lean
@[ext]
lemma ext_inner {A B : E →WOT[𝕜] F} (h : ∀ x y, ⟪y, A x⟫_𝕜 = ⟪y, B x⟫_𝕜) : A = B
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem reverseAux_nil : reverseAux [] r = r
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A map `f : X → Y` is proper if and only if it is continuous and the map
`(Prod.map f id : X × Filter X → Y × Filter X)` is closed. This is stronger than
`isProperMap_iff_universally_closed` since it shows that there's only one space to check to get
properness, but in most cases it doesn't matter. -/
theorem isProperMap_iff_isClosedMap_filter {X : Type u} {Y : Type v} [TopologicalSpace X]
    [TopologicalSpace Y] {f : X → Y} :
    IsProperMap f ↔ Continuous f ∧ IsClosedMap
      (Prod.map f id : X × Filter X → Y × Filter X)
-- Mathlib/MeasureTheory/Group/FundamentalDomain.lean
@[to_additive MeasureTheory.pairwise_disjoint_addFundamentalInterior]
theorem pairwise_disjoint_fundamentalInterior :
    Pairwise (Disjoint on fun g : G => g • fundamentalInterior G s)
-- .lake/packages/batteries/Batteries/Data/UInt.lean
@[simp] theorem UInt8.toUInt16_toNat (x : UInt8) : x.toUInt16.toNat = x.toNat
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/FDeriv.lean
theorem mem_toPartialHomeomorph_source (hf : HasStrictFDerivAt f (f' : E →L[𝕜] F) a) :
    a ∈ (hf.toPartialHomeomorph f).source
-- Mathlib/Probability/Kernel/Composition.lean
@[simp]
lemma prodMkLeft_add (κ η : Kernel α β) :
    prodMkLeft γ (κ + η) = prodMkLeft γ κ + prodMkLeft γ η
-- Mathlib/Tactic/NormNum/Ineq.lean
theorem isNat_lt_false [OrderedSemiring α] {a b : α} {a' b' : ℕ}
    (ha : IsNat a a') (hb : IsNat b b') (h : Nat.ble b' a' = true) : ¬a < b
-- Mathlib/Analysis/Analytic/Composition.lean
@[simp]
theorem id_comp (p : FormalMultilinearSeries 𝕜 E F) (h : p 0 = 0) : (id 𝕜 F).comp p = p
-- Mathlib/Topology/Algebra/Module/LocallyConvex.lean
theorem locallyConvexSpace_iff_exists_convex_subset_zero :
    LocallyConvexSpace 𝕜 E ↔ ∀ U ∈ (𝓝 0 : Filter E), ∃ S ∈ (𝓝 0 : Filter E), Convex 𝕜 S ∧ S ⊆ U
-- Mathlib/Algebra/Order/Floor.lean
theorem lt_of_ceil_lt (h : ⌈a⌉₊ < n) : a < n
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
theorem coe_sSup_of_directedOn {S : Set (NonUnitalSubsemiring R)} (Sne : S.Nonempty)
    (hS : DirectedOn (· ≤ ·) S) : (↑(sSup S) : Set R) = ⋃ s ∈ S, ↑s
-- Mathlib/MeasureTheory/Integral/Asymptotics.lean
/-- If `f` is locally integrable on `[a, ∞)`, and `f =O[atTop] g`, for some
`g` integrable at `atTop`, then `f` is integrable on `[a, ∞)`. -/
theorem LocallyIntegrableOn.integrableOn_of_isBigO_atTop [IsMeasurablyGenerated (atTop (α := α))]
    (hf : LocallyIntegrableOn f (Ici a) μ) (ho : f =O[atTop] g)
    (hg : IntegrableAtFilter g atTop μ) : IntegrableOn f (Ici a) μ
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem not_monic_zero_iff : ¬Monic (0 : R[X]) ↔ (0 : R) ≠ 1
-- Mathlib/CategoryTheory/Monoidal/Functor.lean
/-- The underlying oplax monoidal functor of a (strong) monoidal functor. -/
@[simps]
noncomputable def MonoidalFunctor.toOplaxMonoidalFunctor (F : MonoidalFunctor C D) :
    OplaxMonoidalFunctor C D
-- Mathlib/Analysis/BoundedVariation.lean
/-- The map `(eVariationOn · s)` is lower semicontinuous for pointwise convergence *on `s`*.
Pointwise convergence on `s` is encoded here as uniform convergence on the family consisting of the
singletons of elements of `s`.
-/
protected theorem lowerSemicontinuous (s : Set α) :
    LowerSemicontinuous fun f : α →ᵤ[s.image singleton] E => eVariationOn f s
-- Mathlib/ModelTheory/Algebra/Ring/Basic.lean
theorem mul_def (α : Type*) (t₁ t₂ : Language.ring.Term α) :
    t₁ * t₂ = mulFunc.apply₂ t₁ t₂
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem two_zsmul_ne_zero_iff {θ : Angle} : (2 : ℤ) • θ ≠ 0 ↔ θ ≠ 0 ∧ θ ≠ π
-- Mathlib/Topology/Homeomorph.lean
/-- An inducing equiv between topological spaces is a homeomorphism. -/
@[simps toEquiv] -- Porting note (#11215): TODO: was `@[simps]`
def toHomeomorphOfInducing (f : X ≃ Y) (hf : Inducing f) : X ≃ₜ Y
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem image₂_subset_iff : image₂ f s t ⊆ u ↔ ∀ x ∈ s, ∀ y ∈ t, f x y ∈ u
-- Mathlib/CategoryTheory/Adjunction/Basic.lean
/--
If the unit and counit of a given adjunction are (pointwise) isomorphisms, then we can upgrade the
adjunction to an equivalence.
-/
@[simps!]
noncomputable def toEquivalence (adj : F ⊣ G) [∀ X, IsIso (adj.unit.app X)]
    [∀ Y, IsIso (adj.counit.app Y)] : C ≌ D
-- Mathlib/Probability/Independence/Basic.lean
theorem IndepSets.iUnion {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
    (hyp : ∀ n, IndepSets (s n) s' μ) :
    IndepSets (⋃ n, s n) s' μ
-- Mathlib/RingTheory/Norm/Defs.lean
theorem norm_apply (x : S) : norm R x = LinearMap.det (lmul R S x)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem indicatorConstLp_coeFn_nmem : ∀ᵐ x : α ∂μ, x ∉ s → indicatorConstLp p hs hμs c x = 0
-- Mathlib/Analysis/SpecialFunctions/Gaussian/FourierTransform.lean
theorem integral_rexp_neg_mul_sq_norm {b : ℝ} (hb : 0 < b) :
    ∫ v : V, rexp (- b * ‖v‖^2) = (π / b) ^ (FiniteDimensional.finrank ℝ V / 2 : ℝ)
-- Mathlib/Algebra/Squarefree/Basic.lean
@[simp]
theorem IsUnit.squarefree [CommMonoid R] {x : R} (h : IsUnit x) : Squarefree x
-- Mathlib/Order/CompactlyGenerated/Basic.lean
/-- This property is sometimes referred to as `α` being upper continuous. -/
protected theorem DirectedOn.sSup_inf_eq (h : DirectedOn (· ≤ ·) s) :
    sSup s ⊓ a = ⨆ b ∈ s, b ⊓ a
-- Mathlib/FieldTheory/IntermediateField.lean
theorem lift_le {F : IntermediateField K L} (E : IntermediateField K F) : lift E ≤ F
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroObjects.lean
theorem unop {X : Cᵒᵖ} (h : IsZero X) : IsZero (Opposite.unop X)
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem norm_eq_of_associated {d : ℤ} (hd : d ≤ 0) {x y : ℤ√d} (h : Associated x y) :
    x.norm = y.norm
-- Mathlib/Topology/Irreducible.lean
theorem IrreducibleSpace.isIrreducible_univ (X : Type*) [TopologicalSpace X] [IrreducibleSpace X] :
    IsIrreducible (univ : Set X)
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem union_div : (s₁ ∪ s₂) / t = s₁ / t ∪ s₂ / t
-- Mathlib/LinearAlgebra/Matrix/SchurComplement.lean
theorem schur_complement_eq₂₂ [Fintype m] [Fintype n] [DecidableEq n] (A : Matrix m m 𝕜)
    (B : Matrix m n 𝕜) {D : Matrix n n 𝕜} (x : m → 𝕜) (y : n → 𝕜) [Invertible D]
    (hD : D.IsHermitian) :
    (star (x ⊕ᵥ y)) ᵥ* (fromBlocks A B Bᴴ D) ⬝ᵥ (x ⊕ᵥ y) =
      (star ((D⁻¹ * Bᴴ) *ᵥ x + y)) ᵥ* D ⬝ᵥ ((D⁻¹ * Bᴴ) *ᵥ x + y) +
        (star x) ᵥ* (A - B * D⁻¹ * Bᴴ) ⬝ᵥ x
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem gc_map_comap (f : F) : GaloisConnection (map f) (comap f)
-- Mathlib/Data/Set/Prod.lean
theorem pi_eq_empty_iff' : s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅