ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- The cardinality of the fiber is preserved under isomorphisms. -/
lemma card_fiber_eq_of_iso {X Y : C} (i : X ≅ Y) : Nat.card (F.obj X) = Nat.card (F.obj Y)
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive coe_prod]
theorem coe_prod (f : M →ₙ* N) (g : M →ₙ* P) : ⇑(f.prod g) = Pi.prod f g
-- Mathlib/Data/Set/Lattice.lean
theorem sigmaToiUnion_bijective (h : Pairwise fun i j => Disjoint (t i) (t j)) :
    Bijective (sigmaToiUnion t)
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive norm_toNNReal]
theorem norm_toNNReal' : ‖a‖.toNNReal = ‖a‖₊
-- Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean
lemma exp_neg (x : EReal) : exp (-x) = (exp x)⁻¹
-- Mathlib/SetTheory/Ordinal/CantorNormalForm.lean
/-- Every coefficient in the Cantor normal form `CNF b o` is less than `b`. -/
theorem CNF_snd_lt {b o : Ordinal.{u}} (hb : 1 < b) {x : Ordinal × Ordinal} :
    x ∈ CNF b o → x.2 < b
-- Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean
/-- A family of submodules in a commutative `R`-algebra `A` is a submodules basis if it satisfies
some axioms ensuring there is a topology on `A` which is compatible with the ring structure and
admits this family as a basis of neighborhoods of zero. -/
structure SubmodulesRingBasis (B : ι → Submodule R A) : Prop where
  /-- Condition for `B` to be a filter basis on `A`. -/
  inter : ∀ i j, ∃ k, B k ≤ B i ⊓ B j
  /-- For any element `a : A` and any set `B` in the submodule basis on `A`,
    there is another basis element `B'` such that `a • B'` is in `B`. -/
  leftMul : ∀ (a : A) (i), ∃ j, a • B j ≤ B i
  /-- For each set `B` in the submodule basis on `A`, there is another basis element `B'` such
    that the set-theoretic product `B' * B'` is in `B`. -/
  mul : ∀ i, ∃ j, (B j : Set A) * B j ⊆ B i
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- See also `finprod_eq_of_bijective`, `Fintype.prod_bijective` and `Finset.prod_bij`. -/
@[to_additive "See also `finsum_eq_of_bijective`, `Fintype.sum_bijective` and `Finset.sum_bij`."]
theorem finprod_comp {g : β → M} (e : α → β) (he₀ : Function.Bijective e) :
    (∏ᶠ i, g (e i)) = ∏ᶠ j, g j
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem lipschitzOnWith_iff_dist_le_mul [PseudoMetricSpace α] [PseudoMetricSpace β] {K : ℝ≥0}
    {s : Set α} {f : α → β} :
    LipschitzOnWith K f s ↔ ∀ x ∈ s, ∀ y ∈ s, dist (f x) (f y) ≤ K * dist x y
-- Mathlib/Data/Sym/Basic.lean
theorem coe_injective : Injective ((↑) : Sym α n → Multiset α)
-- Mathlib/CategoryTheory/Limits/Opposites.lean
/-- Turn a limit for `F.rightOp : J ⥤ Cᵒᵖ` into a limit for `F : Jᵒᵖ ⥤ C`. -/
@[simps]
def isColimitCoconeOfConeRightOp (F : Jᵒᵖ ⥤ C) {c : Cone F.rightOp} (hc : IsLimit c) :
    IsColimit (coconeOfConeRightOp c)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem leadingCoeff_X_pow_add_one {n : ℕ} (hn : 0 < n) : (X ^ n + 1 : R[X]).leadingCoeff = 1
-- Mathlib/CategoryTheory/Sites/CoverPreserving.lean
theorem compatiblePreservingOfFlat {C : Type u₁} [Category.{v₁} C] {D : Type u₁} [Category.{v₁} D]
    (K : GrothendieckTopology D) (G : C ⥤ D) [RepresentablyFlat G] : CompatiblePreserving K G
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma add_of_X_ne {P Q : Fin 3 → F} (hP : W.Equation P) (hQ : W.Equation Q) (hPz : P z ≠ 0)
    (hQz : Q z ≠ 0) (hx : P x * Q z ^ 2 ≠ Q x * P z ^ 2) :
    W.add P Q = addZ P Q •
      ![W.toAffine.addX (P x / P z ^ 2) (Q x / Q z ^ 2)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        W.toAffine.addY (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3)
          (W.toAffine.slope (P x / P z ^ 2) (Q x / Q z ^ 2) (P y / P z ^ 3) (Q y / Q z ^ 3)),
        1]
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[deprecated getElem?_range' (since := "2024-06-12")]
theorem get?_range' (s step) {m n : Nat} (h : m < n) :
    get? (range' s n step) m = some (s + step * m)
-- Mathlib/RingTheory/MvPolynomial/Basic.lean
@[simp]
lemma algebraMap_def :
    algebraMap (MvPolynomial σ R) (MvPolynomial σ S) = MvPolynomial.map (algebraMap R S)
-- Mathlib/RingTheory/PowerSeries/Order.lean
@[simp]
theorem divided_by_X_pow_order_of_X_eq_one : divided_by_X_pow_order X_ne_zero = (1 : R⟦X⟧)
-- Mathlib/MeasureTheory/Function/AEEqOfIntegral.lean
theorem ae_le_of_forall_setIntegral_le {f g : α → ℝ} (hf : Integrable f μ) (hg : Integrable g μ)
    (hf_le : ∀ s, MeasurableSet s → μ s < ∞ → (∫ x in s, f x ∂μ) ≤ ∫ x in s, g x ∂μ) :
    f ≤ᵐ[μ] g
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp] theorem add_mul_emod_self {a b c : Int} : (a + b * c) % c = a % c
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
@[simp]
theorem pow_dvd_pow_iff {n : ℕ} (hn : n ≠ 0) {a b : R} : a ^ n ∣ b ^ n ↔ a ∣ b
-- Mathlib/MeasureTheory/Function/SimpleFunc.lean
@[simp]
theorem restrict_empty (f : α →ₛ β) : restrict f ∅ = 0
-- Mathlib/Logic/Function/Iterate.lean
theorem foldl_const (f : α → α) (a : α) (l : List β) :
    l.foldl (fun b _ ↦ f b) a = f^[l.length] a
-- Mathlib/LinearAlgebra/DFinsupp.lean
/-- While `simp` can prove this, it is often convenient to avoid unfolding `lsum` into `sumAddHom`
with `DFinsupp.lsum_apply_apply`. -/
theorem lsum_single [Semiring S] [Module S N] [SMulCommClass R S N] (F : ∀ i, M i →ₗ[R] N) (i)
    (x : M i) : lsum S (M := M) F (single i x) = F i x
-- Mathlib/CategoryTheory/Sites/Canonical.lean
/-- A representable functor is a sheaf for the canonical topology. -/
theorem isSheaf_of_representable (P : Cᵒᵖ ⥤ Type v) [P.Representable] :
    Presieve.IsSheaf (canonicalTopology C) P
-- Mathlib/Algebra/Order/Group/OrderIso.lean
/-- `x ↦ x / a` as an order isomorphism. -/
@[to_additive (attr := simps!) "`x ↦ x - a` as an order isomorphism."]
def OrderIso.divRight (a : α) : α ≃o α
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Basic.lean
/-- Return the bound in terms of toNat. -/
theorem isLt (x : BitVec w) : x.toNat < 2^w
-- Mathlib/MeasureTheory/Measure/Trim.lean
theorem ae_le_of_ae_le_trim {E} [LE E] {hm : m ≤ m0} {f₁ f₂ : α → E}
    (h12 : f₁ ≤ᵐ[μ.trim hm] f₂) : f₁ ≤ᵐ[μ] f₂
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma measurableSet_succ_memPartition (t : ℕ → Set α) (n : ℕ) {s : Set α}
    (hs : s ∈ memPartition t n) :
    MeasurableSet[generateFrom (memPartition t (n + 1))] s
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
/-- Subgroups of a group `G` are isomorphic to additive subgroups of `Additive G`. -/
@[simps!]
def Subgroup.toAddSubgroup : Subgroup G ≃o AddSubgroup (Additive G)
-- Mathlib/Probability/Kernel/RadonNikodym.lean
lemma withDensity_rnDeriv_eq_zero_iff_measure_eq_zero (κ η : Kernel α γ)
    [IsFiniteKernel κ] [IsFiniteKernel η] (a : α) :
    withDensity η (rnDeriv κ η) a = 0 ↔ κ a (mutuallySingularSetSlice κ η a)ᶜ = 0
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem fract_nonneg (a : α) : 0 ≤ fract a
-- Mathlib/Data/Real/Hyperreal.lean
theorem InfiniteNeg.neg {x : ℝ*} : InfiniteNeg x → InfinitePos (-x)
-- Mathlib/Algebra/Ring/Subring/Basic.lean
theorem toSubmonoid_injective : Function.Injective (fun s : Subring R => s.toSubmonoid)
-- Mathlib/Combinatorics/SimpleGraph/Density.lean
theorem edgeDensity_le_one (s : Finset α) (t : Finset β) : edgeDensity r s t ≤ 1
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem CPolynomialOn.add {s : Set E} (hf : CPolynomialOn 𝕜 f s) (hg : CPolynomialOn 𝕜 g s) :
    CPolynomialOn 𝕜 (f + g) s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem mem_replicate {a b : α} : ∀ {n}, b ∈ replicate n a ↔ n ≠ 0 ∧ b = a
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] theorem pow_eq {m n : Nat} : m.pow n = m ^ n
-- Mathlib/Order/Filter/Basic.lean
theorem mem_iInf_of_iInter {ι} {s : ι → Filter α} {U : Set α} {I : Set ι} (I_fin : I.Finite)
    {V : I → Set α} (hV : ∀ i, V i ∈ s i) (hU : ⋂ i, V i ⊆ U) : U ∈ ⨅ i, s i
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem nodal_monic : (nodal s v).Monic
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem restrictScalars_zero : (0 : M →L[A] M₂).restrictScalars R = 0
-- Mathlib/Topology/Sheaves/SheafCondition/PairwiseIntersections.lean
/-- The category of single and double intersections of the `U i` maps into the category
of open sets below some `U i`.
-/
@[simps]
def pairwiseToOpensLeCover : Pairwise ι ⥤ OpensLeCover U
-- Mathlib/Dynamics/PeriodicPts.lean
theorem Commute.minimalPeriod_of_comp_dvd_mul {g : α → α} (h : Commute f g) :
    minimalPeriod (f ∘ g) x ∣ minimalPeriod f x * minimalPeriod g x
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
theorem card_biUnion_le_card_mul [DecidableEq β] (s : Finset ι) (f : ι → Finset β) (n : ℕ)
    (h : ∀ a ∈ s, (f a).card ≤ n) : (s.biUnion f).card ≤ s.card * n
-- Mathlib/Algebra/Homology/DerivedCategory/Ext.lean
/-- The composition of `Ext`, as a bilinear map. -/
@[simps!]
noncomputable def bilinearComp (a b c : ℕ) (h : a + b = c) :
    Ext X Y a →+ Ext Y Z b →+ Ext X Z c
-- Mathlib/SetTheory/Game/PGame.lean
theorem moveRight_neg {x : PGame} (i) : (-x).moveRight (toRightMovesNeg i) = -x.moveLeft i
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem quasiMeasurePreserving_div_left [IsMulLeftInvariant μ] (g : G) :
    QuasiMeasurePreserving (fun h : G => g / h) μ μ
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
theorem and_or_inj_left : ∀ {m x y : Bool}, (m && x) = (m && y) → (m || x) = (m || y) → x = y
-- Mathlib/Data/Nat/Defs.lean
lemma le_sqrt : m ≤ sqrt n ↔ m * m ≤ n
-- Mathlib/LinearAlgebra/LinearDisjoint.lean
/-- If `{ m_i }` is an `R`-basis of `M`, if `{ n_i }` is an `R`-basis of `N`,
such that the family `{ m_i * n_j }` in `S` is `R`-linearly independent,
then `M` and `N` are linearly disjoint. -/
theorem of_basis_mul {κ ι : Type*} (m : Basis κ R M) (n : Basis ι R N)
    (H : LinearIndependent R fun (i : κ × ι) ↦ (m i.1).1 * (n i.2).1) : M.LinearDisjoint N
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem formPerm_apply_mem_eq_next (hl : Nodup l) (x : α) (hx : x ∈ l) :
    formPerm l x = next l x hx
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
theorem det_eq_zero_of_row_eq_zero {A : Matrix n n R} (i : n) (h : ∀ j, A i j = 0) : det A = 0
-- Mathlib/Algebra/Order/Floor.lean
theorem map_ceil (f : F) (hf : StrictMono f) (a : α) : ⌈f a⌉ = ⌈a⌉
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[to_additive]
nonrec theorem IsUnit.aemeasurable_const_smul_iff {c : M} (hc : IsUnit c) :
    AEMeasurable (fun x => c • f x) μ ↔ AEMeasurable f μ
-- Mathlib/Topology/FiberBundle/Trivialization.lean
protected theorem eqOn : EqOn (Prod.fst ∘ e) proj e.source
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasDerivAt.scomp_hasDerivWithinAt_of_eq (hg : HasDerivAt g₁ g₁' y)
    (hh : HasDerivWithinAt h h' s x) (hy : y = h x) :
    HasDerivWithinAt (g₁ ∘ h) (h' • g₁') s x
-- Mathlib/Data/Finset/Lattice.lean
theorem sup_id_eq_sSup [CompleteLattice α] (s : Finset α) : s.sup id = sSup s
-- Mathlib/Data/ENNReal/Inv.lean
protected theorem le_div_iff_mul_le (h0 : b ≠ 0 ∨ c ≠ 0) (ht : b ≠ ∞ ∨ c ≠ ∞) :
    a ≤ c / b ↔ a * b ≤ c
-- Mathlib/Algebra/Module/Torsion.lean
@[simp]
theorem pow_pOrder_smul {p : R} (hM : IsTorsion' M <| Submonoid.powers p) (x : M)
    [∀ n : ℕ, Decidable (p ^ n • x = 0)] : p ^ pOrder hM x • x = 0
-- Mathlib/Algebra/Group/Units.lean
@[to_additive]
theorem isUnit_of_mul_isUnit_left [CommMonoid M] {x y : M} (hu : IsUnit (x * y)) : IsUnit x
-- Mathlib/Data/ENNReal/Real.lean
theorem toNNReal_inv (a : ℝ≥0∞) : a⁻¹.toNNReal = a.toNNReal⁻¹
-- Mathlib/Topology/Order/OrderClosed.lean
@[simp]
theorem nhdsWithin_Ico_eq_nhdsWithin_Iio (h : a < b) : 𝓝[Ico a b] b = 𝓝[<] b
-- Mathlib/Analysis/Analytic/Constructions.lean
/-- `(f x)⁻¹` is analytic away from `f x = 0` -/
theorem AnalyticAt.inv {f : E → 𝕝} {x : E} (fa : AnalyticAt 𝕜 f x) (f0 : f x ≠ 0) :
    AnalyticAt 𝕜 (fun x ↦ (f x)⁻¹) x
-- Mathlib/Data/Finset/Basic.lean
theorem filter_erase (a : α) (s : Finset α) : filter p (erase s a) = erase (filter p s) a
-- Mathlib/RepresentationTheory/Character.lean
/-- The character of isomorphic representations is the same. -/
theorem char_iso {V W : FDRep k G} (i : V ≅ W) : V.character = W.character
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive (attr := simp)]
theorem snd_one [One M] [One N] : (1 : M × N).2 = 1
-- Mathlib/Topology/Instances/ENNReal.lean
@[simp]
theorem tsum_iSup_eq {α : Type*} (a : α) {f : α → ℝ≥0∞} : (∑' b : α, ⨆ _ : a = b, f b) = f a
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean
/-- The map `Cocycle (K⟦a⟧) L n' → Cocycle K L n` when `n + a = n'`. -/
@[simps!]
def leftUnshift {n' a : ℤ} (γ : Cocycle (K⟦a⟧) L n') (n : ℤ) (hn : n + a = n') :
    Cocycle K L n
-- Mathlib/Data/Finset/Prod.lean
theorem product_inter_product [DecidableEq α] [DecidableEq β] :
    s ×ˢ t ∩ s' ×ˢ t' = (s ∩ s') ×ˢ (t ∩ t')
-- Mathlib/Topology/Sets/Compacts.lean
@[simp]
theorem coe_prod (K : PositiveCompacts α) (L : PositiveCompacts β) :
    (K.prod L : Set (α × β)) = (K : Set α) ×ˢ (L : Set β)
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem relindex_subgroupOf (hKL : K ≤ L) :
    (H.subgroupOf L).relindex (K.subgroupOf L) = H.relindex K
-- Mathlib/FieldTheory/PrimitiveElement.lean
/-- **Primitive element theorem**: a finite separable field extension `E` of `F` has a
  primitive element, i.e. there is an `α ∈ E` such that `F⟮α⟯ = (⊤ : Subalgebra F E)`. -/
theorem exists_primitive_element : ∃ α : E, F⟮α⟯ = ⊤
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem roots_list_prod (L : List R[X]) :
    (0 : R[X]) ∉ L → L.prod.roots = (L : Multiset R[X]).bind roots
-- Mathlib/Computability/Ackermann.lean
theorem add_add_one_le_ack (m n : ℕ) : m + n + 1 ≤ ack m n
-- Mathlib/Computability/RegularExpressions.lean
@[simp]
theorem zero_rmatch (x : List α) : rmatch 0 x = false
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[simp]
theorem ofEq_coe {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y) :
    (f.ofEq h).toFun = f.toFun
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
/-- Given measures `μ` and `ν`, if `s` is a measure mutually singular to `ν` and `f` is a
measurable function such that `μ = s + fν`, then `f = μ.rnDeriv ν`.

This theorem provides the uniqueness of the `rnDeriv` in the Lebesgue decomposition
theorem, while `MeasureTheory.Measure.eq_singularPart` provides the uniqueness of the
`singularPart`. Here, the uniqueness is given in terms of the measures, while the uniqueness in
terms of the functions is given in `eq_rnDeriv`. -/
theorem eq_withDensity_rnDeriv {s : Measure α} {f : α → ℝ≥0∞} (hf : Measurable f) (hs : s ⟂ₘ ν)
    (hadd : μ = s + ν.withDensity f) : ν.withDensity f = ν.withDensity (μ.rnDeriv ν)
-- Mathlib/Geometry/Manifold/LocalInvariantProperties.lean
theorem liftPropAt_of_liftPropWithinAt (h : LiftPropWithinAt P g s x) (hs : s ∈ 𝓝 x) :
    LiftPropAt P g x
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem toFinset_zero : toFinset (0 : Multiset α) = ∅
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive (attr := simp) norm_nonneg]
theorem norm_nonneg' (a : E) : 0 ≤ ‖a‖
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
/-- The `v`-adic valuation of `r ∈ R` is less than `Multiplicative.ofAdd (-n)` if and only if
`vⁿ` divides the ideal `(r)`. -/
theorem intValuation_le_pow_iff_dvd (r : R) (n : ℕ) :
    v.intValuationDef r ≤ Multiplicative.ofAdd (-(n : ℤ)) ↔ v.asIdeal ^ n ∣ Ideal.span {r}
-- Mathlib/Topology/Order/IntermediateValue.lean
theorem isPreconnected_iff_ordConnected {s : Set α} : IsPreconnected s ↔ OrdConnected s
-- Mathlib/Data/String/Lemmas.lean
lemma length_eq_list_length (l : List Char) : (String.mk l).length = l.length
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive (attr := simp)]
theorem inv_insert (a : α) (s : Set α) : (insert a s)⁻¹ = insert a⁻¹ s⁻¹
-- Mathlib/CategoryTheory/Square.lean
/-- The image of a commutative square by a functor. -/
@[simps]
def map (sq : Square C) (F : C ⥤ D) : Square D
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
@[simp] theorem count_cons_self (a : α) (l : List α) : count a (a :: l) = count a l + 1
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- If all elements of a `Finset` satisfy the predicate `p`, a product
over `s.subtype p` equals that product over `s`. -/
@[to_additive "If all elements of a `Finset` satisfy the predicate `p`, a sum
over `s.subtype p` equals that sum over `s`."]
theorem prod_subtype_of_mem (f : α → β) {p : α → Prop} [DecidablePred p] (h : ∀ x ∈ s, p x) :
    ∏ x ∈ s.subtype p, f x = ∏ x ∈ s, f x
-- Mathlib/Order/Monotone/Basic.lean
/-- If an antitone function is equal at two points, it is equal between all of them -/
theorem Antitone.eq_of_le_of_le {a₁ a₂ : α} (h_anti : Antitone f) (h_fa : f a₁ = f a₂) {i : α}
    (h₁ : a₁ ≤ i) (h₂ : i ≤ a₂) : f i = f a₁
-- Mathlib/Data/Matrix/Notation.lean
theorem vec2_add [Add α] (a₀ a₁ b₀ b₁ : α) : ![a₀, a₁] + ![b₀, b₁] = ![a₀ + b₀, a₁ + b₁]
-- Mathlib/Topology/TietzeExtension.lean
/-- **Tietze extension theorem** for real-valued bounded continuous maps, a version with a closed
embedding and bundled composition. If `e : C(X, Y)` is a closed embedding of a topological space
into a normal topological space and `f : X →ᵇ ℝ` is a bounded continuous function, then there exists
a bounded continuous function `g : Y →ᵇ ℝ` of the same norm such that `g ∘ e = f`. -/
theorem exists_extension_norm_eq_of_closedEmbedding' (f : X →ᵇ ℝ) (e : C(X, Y))
    (he : ClosedEmbedding e) : ∃ g : Y →ᵇ ℝ, ‖g‖ = ‖f‖ ∧ g.compContinuous e = f
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_add_right (a b : α) : toIocDiv hp a (b + p) = toIocDiv hp a b + 1
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
/-- The finrank of a finite product is the sum of the finranks. -/
theorem FiniteDimensional.finrank_pi_fintype
    {ι : Type v} [Fintype ι] {M : ι → Type w} [∀ i : ι, AddCommGroup (M i)]
    [∀ i : ι, Module R (M i)] [∀ i : ι, Module.Free R (M i)] [∀ i : ι, Module.Finite R (M i)] :
    finrank R (∀ i, M i) = ∑ i, finrank R (M i)
-- Mathlib/Data/Set/Basic.lean
theorem Nonempty.not_subset_empty : s.Nonempty → ¬s ⊆ ∅
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_neg_uIcc : @Neg.neg (Set α) Set.neg [[a, b]] = [[-a, -b]]
-- Mathlib/Topology/ContinuousFunction/Bounded.lean
theorem norm_lt_iff_of_compact [CompactSpace α] {f : α →ᵇ β} {M : ℝ} (M0 : 0 < M) :
    ‖f‖ < M ↔ ∀ x, ‖f x‖ < M
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem integral_add_adjacent_intervals (hab : IntervalIntegrable f μ a b)
    (hbc : IntervalIntegrable f μ b c) :
    ((∫ x in a..b, f x ∂μ) + ∫ x in b..c, f x ∂μ) = ∫ x in a..c, f x ∂μ
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
@[simp]
theorem neg_snd : (-x).snd = -x.snd
-- Mathlib/Data/Set/Basic.lean
theorem mem_union_left {x : α} {a : Set α} (b : Set α) : x ∈ a → x ∈ a ∪ b
-- Mathlib/CategoryTheory/Localization/Bousfield.lean
lemma W_iff_isIso {X Y : C} (f : X ⟶ Y) (hX : P X) (hY : P Y) :
    W P f ↔ IsIso f
-- Mathlib/Topology/Sheaves/Functors.lean
@[simp] lemma pushforward_map (f : X ⟶ Y) {F F' : X.Sheaf C} (α : F ⟶ F') :
    ((pushforward C f).map α).1 = (Presheaf.pushforward C f).map α.1
-- Mathlib/Algebra/Group/Defs.lean
@[to_additive three_nsmul]
lemma pow_three (a : M) : a ^ 3 = a * (a * a)
-- Mathlib/Topology/Algebra/Module/WeakDual.lean
/-- The coercion `(fun x y => B x y) : E → (F → 𝕜)` is an embedding. -/
theorem embedding {B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜} (hB : Function.Injective B) :
    Embedding fun (x : WeakBilin B) y => B x y
-- Mathlib/RingTheory/DedekindDomain/Basic.lean
theorem DimensionLEOne.eq_bot_of_lt [Ring.DimensionLEOne R] (p P : Ideal R) [p.IsPrime]
    [P.IsPrime] (hpP : p < P) : p = ⊥
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem mk_coe_of_dist_eq {α β} [PseudoMetricSpace α] [PseudoMetricSpace β] (f : α →ᵈ β) (h) :
    Dilation.mkOfDistEq f h = f
-- Mathlib/CategoryTheory/Limits/Constructions/LimitsOfProductsAndEqualizers.lean
theorem hasFiniteLimits_of_hasTerminal_and_pullbacks [HasTerminal C] [HasPullbacks C] :
    HasFiniteLimits C
-- Mathlib/Data/Finset/NatAntidiagonal.lean
lemma antidiagonal_eq_image (n : ℕ) :
    antidiagonal n = (range (n + 1)).image fun i ↦ (i, n - i)
-- Mathlib/Algebra/Order/Antidiag/Pi.lean
lemma piAntidiag_cons (hi : i ∉ s)  (n : μ) :
    piAntidiag (cons i s hi) n = (antidiagonal n).disjiUnion (fun p : μ × μ ↦
      (piAntidiag s p.snd).map (addRightEmbedding fun t ↦ if t = i then p.fst else 0))
        (pairwiseDisjoint_piAntidiag_map_addRightEmbedding hi _)
-- Mathlib/Data/Matroid/Map.lean
@[simp] lemma map_id : M.map id (injOn_id M.E) = M
-- Mathlib/GroupTheory/Finiteness.lean
/-- An equivalent expression of `Submonoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
@[to_additive "An equivalent expression of `AddSubmonoid.FG` in terms of `Set.Finite` instead of
`Finset`."]
theorem Submonoid.fg_iff (P : Submonoid M) :
    Submonoid.FG P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite
-- Mathlib/Topology/Sets/Compacts.lean
@[simp]
theorem coe_mk (s : Set α) (h) : (mk s h : Set α) = s
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem zero_smul_set_subset (s : Set β) : (0 : α) • s ⊆ 0
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
/-- A structure containing all the information from which one can build a nontrivial transvection.
This structure is easier to manipulate than transvections as one has a direct access to all the
relevant fields. -/
-- porting note (#5171): removed @[nolint has_nonempty_instance]
structure TransvectionStruct where
  (i j : n)
  hij : i ≠ j
  c : R
-- Mathlib/Data/Real/Hyperreal.lean
theorem isSt_symm_real {r s : ℝ} : IsSt r s ↔ IsSt s r
-- Mathlib/Order/SuccPred/Relation.lean
/-- `(n, m)` is in the transitive closure of a reflexive relation `~` if `i ~ succ i` and
  `succ i ~ i` for all `i` between `n` and `m`. -/
theorem transGen_of_succ_of_reflexive (r : α → α → Prop) {n m : α} (hr : Reflexive r)
    (h1 : ∀ i ∈ Ico n m, r i (succ i)) (h2 : ∀ i ∈ Ico m n, r (succ i) i) : TransGen r n m
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
@[reassoc (attr := simp)]
theorem map_fromSpec {V : X.Opens} (hV : IsAffineOpen V) (f : op U ⟶ op V) :
    Spec.map (X.presheaf.map f) ≫ hU.fromSpec = hV.fromSpec
-- Mathlib/Logic/Equiv/Fin.lean
theorem finSuccEquiv'_symm_coe_below {i : Fin (n + 1)} {m : Fin n} (h : Fin.castSucc m < i) :
    (finSuccEquiv' i).symm m = Fin.castSucc m
-- Mathlib/Data/List/Sort.lean
@[simp]
theorem mem_orderedInsert {a b : α} {l : List α} :
    a ∈ orderedInsert r b l ↔ a = b ∨ a ∈ l
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem fib_two_mul_add_one (n : ℕ) : fib (2 * n + 1) = fib (n + 1) ^ 2 + fib n ^ 2
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_diff_add_mk {S T : Set α} (h : T ⊆ S) : #(S \ T : Set α) + #T = #S
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
/-- Balls defined using the distance or the edistance coincide -/
@[simp]
theorem Metric.emetric_ball_nnreal {x : α} {ε : ℝ≥0} : EMetric.ball x ε = ball x ε
-- Mathlib/Tactic/NormNum/IsCoprime.lean
theorem isInt_isCoprime : {x y nx ny : ℤ} →
    IsInt x nx → IsInt y ny → IsCoprime nx ny → IsCoprime x y
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- The functor from augmented objects to arrows. -/
@[simps!]
def toArrow : Augmented C ⥤ Arrow C
-- Mathlib/CategoryTheory/Monoidal/End.lean
@[reassoc]
theorem μ_inv_naturality {m n : M} {X Y : C} (f : X ⟶ Y) :
    (F.μIso m n).inv.app X ≫ (F.obj n).map ((F.obj m).map f) =
      (F.obj _).map f ≫ (F.μIso m n).inv.app Y
-- Mathlib/Algebra/Opposites.lean
@[to_additive]
theorem unop_bijective : Bijective (unop : αᵐᵒᵖ → α)
-- Mathlib/Data/Setoid/Basic.lean
/-- The inductively defined equivalence closure of a binary relation r is the infimum
    of the set of all equivalence relations containing r. -/
theorem eqvGen_eq (r : α → α → Prop) :
    EqvGen.Setoid r = sInf { s : Setoid α | ∀ ⦃x y⦄, r x y → s.Rel x y }
-- Mathlib/Topology/Separation.lean
theorem singleton_mem_nhdsWithin_of_mem_discrete {s : Set X} [DiscreteTopology s] {x : X}
    (hx : x ∈ s) : {x} ∈ 𝓝[s] x
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
theorem _root_.IsFractional.inf_right {I : Submodule R P} :
    IsFractional S I → ∀ J, IsFractional S (I ⊓ J)
-- Mathlib/Order/Filter/Pi.lean
theorem Tendsto.pi_map_coprodᵢ {g : ∀ i, Filter (β i)} (h : ∀ i, Tendsto (m i) (f i) (g i)) :
    Tendsto (fun k : ∀ i, α i => fun i => m i (k i)) (Filter.coprodᵢ f) (Filter.coprodᵢ g)