ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
nonrec theorem basis_toMatrix_basisFun_mul [Fintype ι]
    {𝕜} [SeminormedCommRing 𝕜] (b : Basis ι 𝕜 (PiLp p fun _ : ι => 𝕜))
    (A : Matrix ι ι 𝕜) :
    b.toMatrix (PiLp.basisFun _ _ _) * A =
      Matrix.of fun i j => b.repr ((WithLp.equiv _ _).symm (Aᵀ j)) i
-- Mathlib/CategoryTheory/CommSq.lean
theorem iff : HasLift sq ↔ Nonempty sq.LiftStruct
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- Product over a sigma type equals the product of fiberwise products. For rewriting
in the reverse direction, use `Finset.prod_sigma'`.  -/
@[to_additive "Sum over a sigma type equals the sum of fiberwise sums. For rewriting
in the reverse direction, use `Finset.sum_sigma'`"]
theorem prod_sigma {σ : α → Type*} (s : Finset α) (t : ∀ a, Finset (σ a)) (f : Sigma σ → β) :
    ∏ x ∈ s.sigma t, f x = ∏ a ∈ s, ∏ s ∈ t a, f ⟨a, s⟩
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_mono_nnreal {f g : α → ℝ≥0} (h : f ≤ g) : ∫⁻ a, f a ∂μ ≤ ∫⁻ a, g a ∂μ
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
theorem utf8Len_le_of_sublist : ∀ {cs₁ cs₂}, cs₁ <+ cs₂ → utf8Len cs₁ ≤ utf8Len cs₂
-- Mathlib/CategoryTheory/Galois/Prorepresentability.lean
@[ext]
lemma hom_ext {A B : PointedGaloisObject F} {f g : A ⟶ B} (h : f.val = g.val) : f = g
-- Mathlib/CategoryTheory/Filtered/Final.lean
/-- If `C` is cofiltered, then `F : C ⥤ D` is initial if and only if `CostructuredArrow F d` is
    cofiltered for all `d : D`. -/
theorem Functor.initial_iff_isCofiltered_costructuredArrow [IsCofilteredOrEmpty C] :
    Initial F ↔ ∀ d, IsCofiltered (CostructuredArrow F d)
-- Mathlib/Data/Finset/Union.lean
@[simp]
lemma biUnion_subset_iff_forall_subset {α β : Type*} [DecidableEq β] {s : Finset α}
    {t : Finset β} {f : α → Finset β} : s.biUnion f ⊆ t ↔ ∀ x ∈ s, f x ⊆ t
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
/-- Postcomposition of a continuous linear map with a linear isometry preserves
the operator norm. -/
theorem norm_toContinuousLinearMap_comp [RingHomIsometric σ₁₂] (f : F →ₛₗᵢ[σ₂₃] G)
    {g : E →SL[σ₁₂] F} : ‖f.toContinuousLinearMap.comp g‖ = ‖g‖
-- Mathlib/Computability/AkraBazzi/AkraBazzi.lean
/-- The main proof of the lower bound part of the Akra-Bazzi theorem. The factor
`1 + ε n` does not change the asymptotic order, but is needed for the induction step to go
through. -/
lemma smoothingFn_mul_asympBound_isBigO_T :
    (fun (n : ℕ) => (1 + ε n) * asympBound g a b n) =O[atTop] T
-- Mathlib/CategoryTheory/Endofunctor/Algebra.lean
@[simp]
theorem id_eq_id : Coalgebra.Hom.id V = 𝟙 V
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
@[simp]
protected theorem det [Fintype n] (t : TransvectionStruct n R) : det t.toMatrix = 1
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
/-- `MulMemClass S M` says `S` is a type of sets `s : Set M` that are closed under `(*)` -/
class MulMemClass (S : Type*) (M : Type*) [Mul M] [SetLike S M] : Prop where
  /-- A substructure satisfying `MulMemClass` is closed under multiplication. -/
  mul_mem : ∀ {s : S} {a b : M}, a ∈ s → b ∈ s → a * b ∈ s
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem map_comap (μ : Measure β) : (comap f μ).map f = μ.restrict (range f)
-- Mathlib/Data/DFinsupp/Multiset.lean
theorem toDFinsupp_injective : Injective (toDFinsupp : Multiset α → Π₀ _a, ℕ)
-- Mathlib/Order/Filter/Extr.lean
theorem IsExtrFilter.neg (hf : IsExtrFilter f l a) : IsExtrFilter (fun x => -f x) l a
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem restrict_sUnion_congr {S : Set (Set α)} (hc : S.Countable) :
    μ.restrict (⋃₀ S) = ν.restrict (⋃₀ S) ↔ ∀ s ∈ S, μ.restrict s = ν.restrict s
-- Mathlib/Topology/Bases.lean
lemma isOpenMap_eval (i : ι) : IsOpenMap (Function.eval i : (∀ i, π i) → π i)
-- Mathlib/Data/Sum/Interval.lean
lemma mem_sumLexLift :
    c ∈ sumLexLift f₁ f₂ g₁ g₂ a b ↔
      (∃ a₁ b₁ c₁, a = inl a₁ ∧ b = inl b₁ ∧ c = inl c₁ ∧ c₁ ∈ f₁ a₁ b₁) ∨
        (∃ a₁ b₂ c₁, a = inl a₁ ∧ b = inr b₂ ∧ c = inl c₁ ∧ c₁ ∈ g₁ a₁ b₂) ∨
          (∃ a₁ b₂ c₂, a = inl a₁ ∧ b = inr b₂ ∧ c = inr c₂ ∧ c₂ ∈ g₂ a₁ b₂) ∨
            ∃ a₂ b₂ c₂, a = inr a₂ ∧ b = inr b₂ ∧ c = inr c₂ ∧ c₂ ∈ f₂ a₂ b₂
-- Mathlib/Analysis/LocallyConvex/Polar.lean
@[simp]
theorem polar_iUnion {ι} {s : ι → Set E} : B.polar (⋃ i, s i) = ⋂ i, B.polar (s i)
-- Mathlib/RingTheory/WittVector/StructurePolynomial.lean
theorem wittStructureRat_existsUnique (Φ : MvPolynomial idx ℚ) :
    ∃! φ : ℕ → MvPolynomial (idx × ℕ) ℚ,
      ∀ n : ℕ, bind₁ φ (W_ ℚ n) = bind₁ (fun i => rename (Prod.mk i) (W_ ℚ n)) Φ
-- Mathlib/Data/Bool/Count.lean
@[simp]
theorem count_not_add_count (l : List Bool) (b : Bool) : count (!b) l + count b l = length l
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma killingForm_eq :
    killingForm R I = (killingForm R L).restrict I
-- Mathlib/GroupTheory/Coset.lean
@[to_additive]
theorem forall_mk {C : α ⧸ s → Prop} : (∀ x : α ⧸ s, C x) ↔ ∀ x : α, C x
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
/-- The functor which sends `S : SnakeInput C` to its zeroth line `S.L₀`. -/
@[simps]
def functorL₀ : SnakeInput C ⥤ ShortComplex C
-- Mathlib/Data/Real/EReal.lean
theorem natCast_ne_top (n : ℕ) : (n : EReal) ≠ ⊤
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
protected theorem coe_add (x y : S) : (↑(x + y) : A) = ↑x + ↑y
-- Mathlib/RingTheory/Localization/NumDen.lean
theorem mk'_num_den (x : K) : mk' K (num A x) (den A x) = x
-- Mathlib/Algebra/Star/NonUnitalSubalgebra.lean
@[simp]
theorem iSupLift_comp_inclusion {i : ι} (h : K i ≤ T) :
    (iSupLift K dir f hf T hT).comp (inclusion h) = f i
-- Mathlib/Order/LiminfLimsup.lean
theorem mono_bliminf' (h : ∀ᶠ x in f, p x → u x ≤ v x) : bliminf u f p ≤ bliminf v f p
-- Mathlib/Analysis/Normed/Operator/BoundedLinearMaps.lean
protected theorem nhds [CompleteSpace E] (e : E ≃L[𝕜] F) :
    range ((↑) : (E ≃L[𝕜] F) → E →L[𝕜] F) ∈ 𝓝 (e : E →L[𝕜] F)
-- Mathlib/Topology/MetricSpace/GromovHausdorffRealized.lean
private theorem HD_optimalGHDist_le (g : Cb X Y) (hg : g ∈ candidatesB X Y) :
    HD (optimalGHDist X Y) ≤ HD g
-- Mathlib/Algebra/Category/ModuleCat/Presheaf/Limits.lean
/-- Given `F : J ⥤ PresheafOfModules.{v} R`, this is the `BundledCorePresheafOfModules R` which
corresponds to the presheaf of modules which sends `X` to the limit of `F ⋙ evaluation R X`. -/
@[simps]
noncomputable def limitBundledCore : BundledCorePresheafOfModules R
-- Mathlib/Logic/Equiv/PartialEquiv.lean
theorem prod_coe_symm (e : PartialEquiv α β) (e' : PartialEquiv γ δ) :
    ((e.prod e').symm : β × δ → α × γ) = fun p => (e.symm p.1, e'.symm p.2)
-- Mathlib/AlgebraicTopology/AlternatingFaceMapComplex.lean
/-- The inclusion map of the Moore complex in the alternating face map complex,
as a natural transformation -/
@[simps]
def inclusionOfMooreComplex : normalizedMooreComplex A ⟶ alternatingFaceMapComplex A
-- Mathlib/Order/OrdContinuous.lean
protected theorem id : LeftOrdContinuous (id : α → α)
-- Mathlib/Analysis/Calculus/FDeriv/Star.lean
@[fun_prop]
theorem DifferentiableOn.star (h : DifferentiableOn 𝕜 f s) :
    DifferentiableOn 𝕜 (fun y => star (f y)) s
-- Mathlib/Probability/Process/PartitionFiltration.lean
lemma iSup_partitionFiltration_eq_generateFrom_range (ht : ∀ n, MeasurableSet (t n)) :
    ⨆ n, partitionFiltration ht n = generateFrom (Set.range t)
-- Mathlib/RingTheory/HahnSeries/Valuation.lean
theorem addVal_apply {x : HahnSeries Γ R} :
    addVal Γ R x = x.orderTop
-- Mathlib/Data/List/Nodup.lean
theorem nodup_append_comm {l₁ l₂ : List α} : Nodup (l₁ ++ l₂) ↔ Nodup (l₂ ++ l₁)
-- Mathlib/Algebra/Polynomial/Lifts.lean
/-- If `(s : S)` is in the image of `f`, then `C s` lifts. -/
theorem C'_mem_lifts {f : R →+* S} {s : S} (h : s ∈ Set.range f) : C s ∈ lifts f
-- Mathlib/GroupTheory/Subgroup/Centralizer.lean
@[to_additive]
theorem centralizer_univ : centralizer Set.univ = center G
-- Mathlib/Order/Hom/Lattice.lean
@[simp] lemma coe_toTopHom (f : InfTopHom α β) : ⇑f.toTopHom = f
-- Mathlib/Probability/Independence/Basic.lean
theorem indepSet_empty_left [IsProbabilityMeasure μ] (s : Set Ω) : IndepSet ∅ s μ
-- Mathlib/MeasureTheory/Measure/DiracProba.lean
lemma tendsto_diracProba_iff_tendsto [CompletelyRegularSpace X] {x : X} (L : Filter X) :
    Tendsto diracProba L (𝓝 (diracProba x)) ↔ Tendsto id L (𝓝 x)
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem mul_nat (h : LiouvilleWith p x) (hn : n ≠ 0) : LiouvilleWith p (x * n)
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive] lemma exists_mem_ne_one_of_prod_ne_one (h : l.prod ≠ 1) :
    ∃ x ∈ l, x ≠ (1 : M)
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem aleph'_lt {o₁ o₂ : Ordinal} : aleph' o₁ < aleph' o₂ ↔ o₁ < o₂
-- Mathlib/Data/Fin/VecNotation.lean
@[simp]
theorem cons_vecAlt1 (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : Fin m → α) :
    vecAlt1 h (vecCons x (vecCons y u)) = vecCons y (vecAlt1 (by omega) u)
-- Mathlib/Topology/Homotopy/Basic.lean
/-- Given a continuous function `f`, and a proof `h : P f`, we can define a `HomotopyWith f f P` by
`F (t, x) = f x`
-/
@[simps!]
def refl (f : C(X, Y)) (hf : P f) : HomotopyWith f f P
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem mk_sub [∀ i, AddGroup (β i)] {s : Finset ι} {x y : ∀ i : (↑s : Set ι), β i.1} :
    mk s (x - y) = mk s x - mk s y
-- Mathlib/Order/Monotone/Basic.lean
protected theorem antitone [Subsingleton α] (f : α → β) : Antitone f
-- Mathlib/Order/SupClosed.lean
@[simp] lemma isSublattice_univ : IsSublattice (Set.univ : Set α)
-- Mathlib/FieldTheory/Perfect.lean
theorem roots_expand_pow :
    (expand R (p ^ n) f).roots = p ^ n • f.roots.map (iterateFrobeniusEquiv R p n).symm
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma _root_.Monotone.image_uIcc_subset (hf : Monotone f) : f '' uIcc a b ⊆ uIcc (f a) (f b)
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem span_gramSchmidt_Iio (f : ι → E) (c : ι) :
    span 𝕜 (gramSchmidt 𝕜 f '' Set.Iio c) = span 𝕜 (f '' Set.Iio c)
-- Mathlib/Algebra/QuaternionBasis.lean
/-- Transform a `QuaternionAlgebra.Basis` through an `AlgHom`. -/
@[simps i j k]
def compHom (F : A →ₐ[R] B) : Basis B c₁ c₂
-- Mathlib/NumberTheory/LegendreSymbol/ZModChar.lean
/-- `χ₄` takes values in `{0, 1, -1}` -/
theorem isQuadratic_χ₄ : χ₄.IsQuadratic
-- Mathlib/Data/Num/Lemmas.lean
@[norm_cast]
theorem dvd_to_nat {m n : PosNum} : (m : ℕ) ∣ n ↔ m ∣ n
-- Mathlib/GroupTheory/Transfer.lean
@[to_additive]
theorem diff_inv : (diff ϕ S T)⁻¹ = diff ϕ T S
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
protected theorem congr_equiv {p : SeminormFamily 𝕜 E ι} [t : TopologicalSpace E]
    (hp : WithSeminorms p) (e : ι' ≃ ι) : WithSeminorms (p ∘ e)
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
theorem Summable.tendsto_atTop_of_pos [LinearOrderedField α] [TopologicalSpace α] [OrderTopology α]
    {f : ℕ → α} (hf : Summable f⁻¹) (hf' : ∀ n, 0 < f n) : Tendsto f atTop atTop
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
@[simp]
theorem image_closedBall (x : E) (r : ℝ) : e '' Metric.closedBall x r = Metric.closedBall (e x) r
-- Mathlib/RingTheory/TwoSidedIdeal/Lattice.lean
lemma top_ringCon : (⊤ : TwoSidedIdeal R).ringCon = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem isPrefixOf_cons_nil [BEq α] : isPrefixOf (a::as) ([] : List α) = false
-- Mathlib/Logic/Relation.lean
theorem transitive_transGen : Transitive (TransGen r)
-- Mathlib/RingTheory/EuclideanDomain.lean
theorem isCoprime_div_gcd_div_gcd (hq : q ≠ 0) :
    IsCoprime (p / GCDMonoid.gcd p q) (q / GCDMonoid.gcd p q)
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)]
theorem coprodAssoc_apply_inl_inr (x : N) : coprodAssoc M N P (inl (inr x)) = inr (inl x)
-- Mathlib/CategoryTheory/Elements.lean
@[simp]
theorem to_comma_map_right {X Y} (f : X ⟶ Y) : ((toStructuredArrow F).map f).right = f.val
-- Mathlib/Analysis/Convex/Hull.lean
theorem convexHull_min : s ⊆ t → Convex 𝕜 t → convexHull 𝕜 s ⊆ t
-- Mathlib/Data/Set/List.lean
@[simp]
theorem range_list_getD (d : α) : (range fun n : Nat => l[n]?.getD d) = insert d { x | x ∈ l }
-- Mathlib/Computability/Primrec.lean
theorem left : Primrec₂ fun (a : α) (_ : β) => a
-- Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean
theorem norm_real (c : ℝ) :
    mixedEmbedding.norm ((fun _ ↦ c, fun _ ↦ c) : (E K)) = |c| ^ finrank ℚ K
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma nonsingular_of_equiv {P Q : Fin 3 → R} (h : P ≈ Q) : W'.Nonsingular P ↔ W'.Nonsingular Q
-- Mathlib/RingTheory/IsAdjoinRoot.lean
/-- Unicity of `lift`: a map that agrees on `R` and `h.root` agrees with `lift` everywhere. -/
theorem eq_lift (h : IsAdjoinRoot S f) (g : S →+* T) (hmap : ∀ a, g (algebraMap R S a) = i a)
    (hroot : g h.root = x) : g = h.lift i x hx
-- Mathlib/Topology/Algebra/WithZeroTopology.lean
theorem hasBasis_nhds_of_ne_zero {x : Γ₀} (h : x ≠ 0) :
    HasBasis (𝓝 x) (fun _ : Unit => True) fun _ => {x}
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Ici_def (a : α) : { x | a ≤ x } = Ici a
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma homMk_eq_of_leftFractionRel {X Y : C} (z₁ z₂ : W.LeftFraction X Y)
    (h : LeftFractionRel z₁ z₂) :
    homMk z₁ = homMk z₂
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
@[simp]
theorem coeFn_smul (a : S) (Q : QuadraticMap R M N) : ⇑(a • Q) = a • ⇑Q
-- Mathlib/Topology/UniformSpace/Basic.lean
/-- A uniform space is a generalization of the "uniform" topological aspects of a
  metric space. It consists of a filter on `α × α` called the "uniformity", which
  satisfies properties analogous to the reflexivity, symmetry, and triangle properties
  of a metric.

  A metric space has a natural uniformity, and a uniform space has a natural topology.
  A topological group also has a natural uniformity, even when it is not metrizable. -/
class UniformSpace (α : Type u) extends TopologicalSpace α where
  /-- The uniformity filter. -/
  protected uniformity : Filter (α × α)
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  protected symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  protected comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
  /-- The uniformity agrees with the topology: the neighborhoods filter of each point `x`
  is equal to `Filter.comap (Prod.mk x) (𝓤 α)`. -/
  protected nhds_eq_comap_uniformity (x : α) : 𝓝 x = comap (Prod.mk x) uniformity
-- Mathlib/Data/List/Infix.lean
theorem eq_of_infix_of_length_eq (h : l₁ <:+: l₂) : l₁.length = l₂.length → l₁ = l₂
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem radical_le_radical_iff : radical I ≤ radical J ↔ I ≤ radical J
-- Mathlib/RingTheory/AdicCompletion/Functoriality.lean
theorem map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (x : AdicCompletion I M) :
    map I g (map I f x) = map I (g ∘ₗ f) x
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem symm_trans_target_eq (e e' : Trivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ
-- Mathlib/Data/Finset/Lattice.lean
protected theorem codisjoint_inf_right :
    Codisjoint a (s.inf f) ↔ ∀ ⦃i⦄, i ∈ s → Codisjoint a (f i)
-- Mathlib/Analysis/Calculus/Gradient/Basic.lean
theorem HasGradientWithinAt.congr_mono (h : HasGradientWithinAt f f' s x) (ht : ∀ x ∈ t, f₁ x = f x)
    (hx : f₁ x = f x) (h₁ : t ⊆ s) : HasGradientWithinAt f₁ f' t x
-- Mathlib/Analysis/Normed/Module/Complemented.lean
@[simp]
theorem equivProdOfSurjectiveOfIsCompl_apply {f : E →L[𝕜] F} {g : E →L[𝕜] G} (hf : range f = ⊤)
    (hg : range g = ⊤) (hfg : IsCompl (ker f) (ker g)) (x : E) :
    equivProdOfSurjectiveOfIsCompl f g hf hg hfg x = (f x, g x)
-- Mathlib/CategoryTheory/Subobject/Basic.lean
@[reassoc (attr := simp)]
theorem ofLE_comp_ofLE {B : C} (X Y Z : Subobject B) (h₁ : X ≤ Y) (h₂ : Y ≤ Z) :
    ofLE X Y h₁ ≫ ofLE Y Z h₂ = ofLE X Z (h₁.trans h₂)
-- Mathlib/NumberTheory/SmoothNumbers.lean
/-- If `p` is positive and `n` is `p`-smooth, then every product `p^e * n` is `(p+1)`-smooth. -/
lemma pow_mul_mem_smoothNumbers {p n : ℕ} (hp : p ≠ 0) (e : ℕ) (hn : n ∈ smoothNumbers p) :
    p ^ e * n ∈ smoothNumbers (succ p)
-- Mathlib/RingTheory/TensorProduct/Basic.lean
@[simp]
theorem rid_tmul (r : R) (a : A) : TensorProduct.rid R S A (a ⊗ₜ r) = r • a
-- Mathlib/AlgebraicGeometry/Restrict.lean
@[simp] lemma Scheme.restrictFunctor_obj_hom (U : X.Opens) :
  (X.restrictFunctor.obj U).hom = U.ι
-- Mathlib/Algebra/Order/Group/PosPart.lean
@[to_additive posPart_nonneg] lemma one_le_oneLePart (a : α) : 1 ≤ a⁺ᵐ
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- The space of constant maps is equivalent to the space of maps that are multilinear with respect
to an empty family. -/
@[simps]
def constLinearEquivOfIsEmpty [IsEmpty ι] : M₂ ≃ₗ[S] MultilinearMap R M₁ M₂
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem sub_lt_of_pos_le (h₀ : 0 < a) (h₁ : a ≤ b) : b - a < b
-- Mathlib/Topology/Connected/Basic.lean
theorem isConnected_connectedComponentIn_iff {x : α} {F : Set α} :
    IsConnected (connectedComponentIn F x) ↔ x ∈ F
-- Mathlib/Computability/RegularExpressions.lean
@[simp]
theorem plus_def (P Q : RegularExpression α) : plus P Q = P + Q
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The cokernel of `biproduct.ι f i` is `⨁ Subtype.restrict {i}ᶜ f`. -/
@[simps!]
def cokernelBiproductιIso : cokernel (biproduct.ι f i) ≅ ⨁ Subtype.restrict (fun j => j ≠ i) f
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
protected theorem add_left_neg (x : M ⊗[R] N) : -x + x = 0
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
theorem midpoint_comm (x y : P) : midpoint R x y = midpoint R y x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem cos_nat_mul_two_pi (n : ℕ) : cos (n * (2 * π)) = 1
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem mem_of_closed' {s : Set α} (hs : IsClosed s) {a : α} :
    a ∈ s ↔ ∀ ε > 0, ∃ b ∈ s, dist a b < ε
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem apply_coe_mem_map (f : M →ₙ* N) (S : Subsemigroup M) (x : S) : f x ∈ S.map f
-- Mathlib/Data/Finsupp/Multiset.lean
theorem toFinsupp_add (s t : Multiset α) : toFinsupp (s + t) = toFinsupp s + toFinsupp t
-- Mathlib/FieldTheory/RatFunc/Basic.lean
@[simp]
theorem mk_eq_div (p q : K[X]) : RatFunc.mk p q = algebraMap _ _ p / algebraMap _ _ q
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
/-- Given a localization map `f : M →* N`, and `z w : N`, there exist `z' w' : M` and `d : S`
such that `f z' / f d = z` and `f w' / f d = w`. -/
@[to_additive
    "Given a localization map `f : M →+ N`, and `z w : N`, there exist `z' w' : M` and `d : S`
such that `f z' - f d = z` and `f w' - f d = w`."]
theorem surj₂ (f : LocalizationMap S N) (z w : N) : ∃ z' w' : M, ∃ d : S,
    (z * f.toMap d = f.toMap z') ∧  (w * f.toMap d = f.toMap w')
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_himp_left (hs : s.Nonempty) (f : ι → α) (a : α) :
    (s.sup fun b => a ⇨ f b) = a ⇨ s.sup f
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem mk_coe (f : α →+* β) (h₁ h₂ h₃ h₄) : RingHom.mk ⟨⟨f, h₁⟩, h₂⟩ h₃ h₄ = f
-- Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean
theorem toFiniteMeasure_continuous :
    Continuous (toFiniteMeasure : ProbabilityMeasure Ω → FiniteMeasure Ω)
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem incidenceSet_subset (v : V) : G.incidenceSet v ⊆ G.edgeSet
-- Mathlib/CategoryTheory/Limits/Presheaf.lean
@[reassoc (attr := simp)]
lemma presheafHom_naturality {P Q : Cᵒᵖ ⥤ Type v₁} (f : P ⟶ Q) :
    presheafHom φ P ≫ whiskerLeft F.op (G.map f) = f ≫ presheafHom φ Q
-- Mathlib/Data/Nat/Defs.lean
lemma div_eq_sub_mod_div : m / n = (m - m % n) / n
-- Mathlib/Topology/Connected/Clopen.lean
theorem frontier_eq_empty_iff [PreconnectedSpace α] {s : Set α} :
    frontier s = ∅ ↔ s = ∅ ∨ s = univ
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem univ_id : univ.{u, u + 1} = #Ordinal
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1_add_left (hT : DominatedFinMeasAdditive μ T C)
    (hT' : DominatedFinMeasAdditive μ T' C') (f : α →₁[μ] E) :
    setToL1 (hT.add hT') f = setToL1 hT f + setToL1 hT' f
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem mfderiv_bijective {x : M} (hx : x ∈ e.source) : Function.Bijective (mfderiv I I' e x)
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
theorem ext_elem [Finite ι] {q₁ q₂ : P} (h : ∀ i, b.coord i q₁ = b.coord i q₂) : q₁ = q₂
-- Mathlib/LinearAlgebra/DFinsupp.lean
/-- The supremum of a family of submodules is equal to the range of `DFinsupp.lsum`; that is
every element in the `iSup` can be produced from taking a finite number of non-zero elements
of `p i`, coercing them to `N`, and summing them. -/
theorem iSup_eq_range_dfinsupp_lsum (p : ι → Submodule R N) :
    iSup p = LinearMap.range (DFinsupp.lsum ℕ (M := fun i ↦ ↥(p i)) fun i => (p i).subtype)
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem coe_comp (f : B →⋆ₙₐ[R] C) (g : A →⋆ₙₐ[R] B) : ⇑(comp f g) = f ∘ g
-- Mathlib/LinearAlgebra/Matrix/ZPow.lean
theorem zpow_sub_one {A : M} (h : IsUnit A.det) (n : ℤ) : A ^ (n - 1) = A ^ n * A⁻¹
-- Mathlib/Order/Filter/AtTopBot.lean
theorem atTop_eq_generate_Ici [SemilatticeSup α] : atTop = generate (range (Ici (α := α)))
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma mem_uIcc_of_le (ha : a ≤ x) (hb : x ≤ b) : x ∈ [[a, b]]
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem lintegral_nnnorm_eq_of_ae_nonneg {f : α → ℝ} (h_nonneg : 0 ≤ᵐ[μ] f) :
    ∫⁻ x, ‖f x‖₊ ∂μ = ∫⁻ x, ENNReal.ofReal (f x) ∂μ
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem succ_last (n : Nat) : (last n).succ = last n.succ
-- Mathlib/LinearAlgebra/Determinant.lean
/-- If we fix a background basis `e`, then for any other basis `v`, we can characterise the
coordinates provided by `v` in terms of determinants relative to `e`. -/
theorem Basis.det_smul_mk_coord_eq_det_update {v : ι → M} (hli : LinearIndependent R v)
    (hsp : ⊤ ≤ span R (range v)) (i : ι) :
    e.det v • (Basis.mk hli hsp).coord i = e.det.toMultilinearMap.toLinearMap v i
-- Mathlib/Logic/Function/Basic.lean
@[simp]
theorem update_noteq {a a' : α} (h : a ≠ a') (v : β a') (f : ∀ a, β a) : update f a' v a = f a
-- Mathlib/Topology/Algebra/Group/Basic.lean
@[to_additive]
theorem singleton_mul_mem_nhds (a : α) {b : α} (h : s ∈ 𝓝 b) : {a} * s ∈ 𝓝 (a * b)
-- Mathlib/Analysis/Calculus/Implicit.lean
@[simp]
theorem toPartialHomeomorph_coe : ⇑φ.toPartialHomeomorph = φ.prodFun
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem hasCoproducts_of_opposite [HasProducts.{v₂} Cᵒᵖ] : HasCoproducts.{v₂} C
-- Mathlib/Algebra/Order/Hom/Ring.lean
@[simp, norm_cast]
theorem coe_toOrderIso (f : α ≃+*o β) : DFunLike.coe (f : α ≃o β) = f
-- Mathlib/Algebra/Order/Group/Unbundled/Abs.lean
@[to_additive] lemma mabs_inf_div_inf_le_mabs (a b c : α) : |(a ⊓ c) / (b ⊓ c)|ₘ ≤ |a / b|ₘ
-- Mathlib/Data/Prod/Basic.lean
theorem id_prod : (fun p : α × β ↦ (p.1, p.2)) = id
-- Mathlib/RingTheory/Nilpotent/Defs.lean
theorem IsNilpotent.mk [Zero R] [Pow R ℕ] (x : R) (n : ℕ) (e : x ^ n = 0) : IsNilpotent x
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α]
    {s : Set M} (htop : Submonoid.closure s = ⊤)
    (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z) : IsScalarTower M N α
-- Mathlib/RingTheory/Valuation/Basic.lean
theorem map_sub (x y : R) : min (v x) (v y) ≤ v (x - y)
-- Mathlib/Topology/ExtremallyDisconnected.lean
/-- Lemma 2.1 in [Gleason, *Projective topological spaces*][gleason1958]:
if $\rho$ is a continuous surjection from a topological space $E$ to a topological space $A$
satisfying the "Zorn subset condition", then $\rho(G)$ is contained in
the closure of $A \setminus \rho(E \setminus G)$ for any open set $G$ of $E$. -/
lemma image_subset_closure_compl_image_compl_of_isOpen {ρ : E → A} (ρ_cont : Continuous ρ)
    (ρ_surj : ρ.Surjective) (zorn_subset : ∀ E₀ : Set E, E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ)
    {G : Set E} (hG : IsOpen G) : ρ '' G ⊆ closure ((ρ '' Gᶜ)ᶜ)
-- Mathlib/Analysis/Seminorm.lean
theorem closedBall_antitone {p q : Seminorm 𝕜 E} (h : q ≤ p) :
    p.closedBall x r ⊆ q.closedBall x r
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem cycleType_finRotate {n : ℕ} : cycleType (finRotate (n + 2)) = {n + 2}