ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/ModelTheory/Substructures.lean
theorem map_iSup {ι : Sort*} (f : M →[L] N) (s : ι → L.Substructure M) :
    (iSup s).map f = ⨆ i, (s i).map f
-- Mathlib/CategoryTheory/Sites/DenseSubsite.lean
lemma coverPreserving [G.IsDenseSubsite J K] : CoverPreserving J K G
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem scale_eq_mul (x) [NF x] : ∀ (o) [NF o], scale x o = oadd x 1 0 * o
-- Mathlib/RingTheory/Multiplicity.lean
theorem unique' {a b : α} {k : ℕ} (hk : a ^ k ∣ b) (hsucc : ¬a ^ (k + 1) ∣ b) :
    k = get (multiplicity a b) ⟨k, hsucc⟩
-- Mathlib/Order/CompleteLattice.lean
theorem iInf_split :
    ∀ (f : β → α) (p : β → Prop), ⨅ i, f i = (⨅ (i) (_ : p i), f i) ⊓ ⨅ (i) (_ : ¬p i), f i
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem support_X_empty (H : (1 : R) = 0) : (X : R[X]).support = ∅
-- Mathlib/Algebra/GroupWithZero/Action/Pi.lean
theorem single_smul {α} [Monoid α] [∀ i, AddMonoid <| f i] [∀ i, DistribMulAction α <| f i]
    [DecidableEq I] (i : I) (r : α) (x : f i) : single i (r • x) = r • single i x
-- Mathlib/Algebra/Order/Sub/Defs.lean
theorem le_tsub_of_add_le_left (h : a + b ≤ c) : b ≤ c - a
-- Mathlib/Data/Set/Basic.lean
theorem inter_comm (a b : Set α) : a ∩ b = b ∩ a
-- Mathlib/Data/List/DropRight.lean
theorem rtake_eq_reverse_take_reverse : l.rtake n = reverse (l.reverse.take n)
-- Mathlib/Data/Finset/Prod.lean
@[simp]
theorem product_disjUnion (ht : Disjoint t t') :
    s ×ˢ t.disjUnion t' ht = (s ×ˢ t).disjUnion (s ×ˢ t') (disjoint_product.mpr <| Or.inr ht)
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem lift_of (F : Multiplicative G →* A) (x : Multiplicative G) :
    lift k G A F (of k G x) = F x
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem mul_single_apply (f : MonoidAlgebra k G) (r : k) (x y : G) :
    (f * single x r) y = f (y * x⁻¹) * r
-- Mathlib/RingTheory/TwoSidedIdeal/Basic.lean
lemma nsmul_mem {x} (n : ℕ) (hx : x ∈ I) : n • x ∈ I
-- Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean
lemma deriv2_negMulLog {x : ℝ} (hx : x ≠ 0) : deriv^[2] negMulLog x = - x⁻¹
-- Mathlib/RingTheory/HahnSeries/Summable.lean
@[simp]
theorem coe_powers : ⇑(powers x hx) = HPow.hPow x
-- Mathlib/CategoryTheory/Comma/StructuredArrow.lean
@[simp]
theorem right_eq_id {X Y : CostructuredArrow S T} (f : X ⟶ Y) : f.right = 𝟙 _
-- Mathlib/LinearAlgebra/QuotientPi.lean
theorem map_add (x y : ((i : ι) → Ms i) ⧸ pi Set.univ p) :
    toFun p (x + y) = toFun p x + toFun p y
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
@[simp]
theorem norm_natCast (n : ℕ) : norm (n : ℤ√d) = n * n
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem mem_factors_of_dvd {a p : α} (ha0 : a ≠ 0) (hp : Irreducible p) (hd : p ∣ a) :
    Associates.mk p ∈ factors (Associates.mk a)
-- Mathlib/LinearAlgebra/Basis.lean
theorem Module.card_fintype [Fintype ι] (b : Basis ι R M) [Fintype R] [Fintype M] :
    card M = card R ^ card ι
-- .lake/packages/batteries/Batteries/Data/RBMap/WF.lean
theorem All.trivial (H : ∀ {x : α}, p x) : ∀ {t : RBNode α}, t.All p
-- Mathlib/Data/Fintype/Card.lean
theorem card_eq_zero_iff : card α = 0 ↔ IsEmpty α
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem AntitoneOn.intervalIntegrable {u : ℝ → E} {a b : ℝ} (hu : AntitoneOn u (uIcc a b)) :
    IntervalIntegrable u μ a b
-- Mathlib/Data/Finsupp/Multiset.lean
theorem toMultiset_sup [DecidableEq α] (f g : α →₀ ℕ) :
    toMultiset (f ⊔ g) = toMultiset f ∪ toMultiset g
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem add_sub_assoc (a b c : Int) : a + b - c = a + (b - c)
-- Mathlib/Analysis/Convex/Cone/Basic.lean
theorem salient_iff_not_flat (S : ConvexCone 𝕜 E) : S.Salient ↔ ¬S.Flat
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt8.le_antisymm {x y : UInt8} (h1 : x ≤ y) (h2 : y ≤ x) : x = y
-- Mathlib/Algebra/Order/BigOperators/Group/List.lean
/-- If `l₁` is a sublist of `l₂` and all elements of `l₂` are greater than or equal to one, then
`l₁.prod ≤ l₂.prod`. One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 1 ≤ a` instead
of `∀ a ∈ l₂, 1 ≤ a` but this lemma is not yet in `mathlib`. -/
@[to_additive sum_le_sum "If `l₁` is a sublist of `l₂` and all elements of `l₂` are nonnegative,
  then `l₁.sum ≤ l₂.sum`.
  One can prove a stronger version assuming `∀ a ∈ l₂.diff l₁, 0 ≤ a` instead of `∀ a ∈ l₂, 0 ≤ a`
  but this lemma is not yet in `mathlib`."]
lemma Sublist.prod_le_prod' [Preorder M] [CovariantClass M M (Function.swap (· * ·)) (· ≤ ·)]
    [CovariantClass M M (· * ·) (· ≤ ·)] {l₁ l₂ : List M} (h : l₁ <+ l₂)
    (h₁ : ∀ a ∈ l₂, (1 : M) ≤ a) : l₁.prod ≤ l₂.prod
-- Mathlib/Algebra/Group/NatPowAssoc.lean
@[simp]
theorem npow_zero (x : M) : x ^ 0 = 1
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem differentiableOn_fst {s : Set (E × F)} : DifferentiableOn 𝕜 Prod.fst s
-- Mathlib/Logic/Equiv/Fin.lean
@[simp]
theorem finAddFlip_apply_natAdd (k : Fin n) (m : ℕ) :
    finAddFlip (Fin.natAdd m k) = Fin.castAdd m k
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem isVonNBounded_ball (r : ℝ) : Bornology.IsVonNBounded 𝕜 (Metric.ball (0 : E) r)
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upcrossingStrat_nonneg : 0 ≤ upcrossingStrat a b f N n ω
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem _root_.IsFractional.div_of_nonzero {I J : Submodule R₁ K} :
    IsFractional R₁⁰ I → IsFractional R₁⁰ J → J ≠ 0 → IsFractional R₁⁰ (I / J)
-- Mathlib/FieldTheory/SeparableClosure.lean
/-- The separable closure in `E` of the separable closure of `F` in `E` is equal to itself. -/
theorem separableClosure.separableClosure_eq_bot :
    separableClosure (separableClosure F E) E = ⊥
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval_zero' : eval (fun _ => 0 : σ → R) = constantCoeff
-- Mathlib/Algebra/Homology/Embedding/Basic.lean
/-- The embedding from `down ℕ` to `up ℤ` with sends `n` to `-n`. -/
@[simps!]
def embeddingDownNat : Embedding (down ℕ) (up ℤ)
-- Mathlib/Probability/Process/Stopping.lean
protected theorem measurableSet_eq_of_countable [Countable ι] (hτ : IsStoppingTime f τ) (i : ι) :
    MeasurableSet[f i] {ω | τ ω = i}
-- Mathlib/Algebra/Group/Hom/Defs.lean
@[to_additive]
protected theorem OneHom.map_one [One M] [One N] (f : OneHom M N) : f 1 = 1
-- Mathlib/Data/DFinsupp/Order.lean
lemma le_def : f ≤ g ↔ ∀ i, f i ≤ g i
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma ofHomotopy_ofEq {φ₁ φ₂ : F ⟶ G} (h : φ₁ = φ₂) :
    ofHomotopy (Homotopy.ofEq h) = 0
-- Mathlib/Data/Multiset/Basic.lean
theorem foldr_swap (f : α → β → β) (H : LeftCommutative f) (b : β) (s : Multiset α) :
    foldr f H b s = foldl (fun x y => f y x) (fun _x _y _z => (H _ _ _).symm) b s
-- Mathlib/Computability/Primrec.lean
theorem sub : @Primrec' 2 fun v => v.head - v.tail.head
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem getLsb_truncate (m : Nat) (x : BitVec n) (i : Nat) :
    getLsb (truncate m x) i = (decide (i < m) && getLsb x i)
-- Mathlib/Analysis/Convex/Segment.lean
theorem openSegment_subset_Ioo (h : x < y) : openSegment 𝕜 x y ⊆ Ioo x y
-- Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean
/-- The elliptic curve mapped over a ring homomorphism `φ : R →+* A`. -/
@[simps (config := { rhsMd := .default }) a₁ a₂ a₃ a₄ a₆ Δ' toWeierstrassCurve]
def map : EllipticCurve A
-- Mathlib/CategoryTheory/Sites/ConcreteSheafification.lean
theorem isIso_toSheafify {P : Cᵒᵖ ⥤ D} (hP : Presheaf.IsSheaf J P) : IsIso (J.toSheafify P)
-- Mathlib/Topology/ContinuousOn.lean
/-- If a function is continuous on a set for some topologies, then it is
continuous on the same set with respect to any coarser topology on the target space. -/
theorem ContinuousOn.mono_rng {α β : Type*} {t₁ : TopologicalSpace α} {t₂ t₃ : TopologicalSpace β}
    (h₁ : t₂ ≤ t₃) {s : Set α} {f : α → β} (h₂ : @ContinuousOn α β t₁ t₂ f s) :
    @ContinuousOn α β t₁ t₃ f s
-- Mathlib/Data/List/Range.lean
theorem pairwise_gt_iota (n : ℕ) : Pairwise (· > ·) (iota n)
-- Mathlib/Topology/Basic.lean
@[simp]
theorem interior_iInter₂_le_nat {n : ℕ} (f : ℕ → Set X) :
    interior (⋂ m ≤ n, f m) = ⋂ m ≤ n, interior (f m)
-- Mathlib/Topology/UniformSpace/Pi.lean
lemma Pi.uniformSpace_comap_precomp (φ : ι' → ι) :
    UniformSpace.comap (· ∘ φ) (Pi.uniformSpace (fun _ ↦ β)) =
    ⨅ i', UniformSpace.comap (eval (φ i')) ‹UniformSpace β›
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem algebraicIndependent_adjoin (hs : AlgebraicIndependent R x) :
    @AlgebraicIndependent ι R (adjoin R (range x))
      (fun i : ι => ⟨x i, subset_adjoin (mem_range_self i)⟩) _ _ _
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_id : ⇑(SupHom.id α) = id
-- Mathlib/Order/Disjoint.lean
theorem Codisjoint.top_le : Codisjoint a b → ⊤ ≤ a ⊔ b
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive (attr := simp)]
theorem top_mul_top : (⊤ : Filter α) * ⊤ = ⊤
-- Mathlib/Data/Set/Prod.lean
theorem subset_pi_eval_image (s : Set ι) (u : Set (∀ i, α i)) : u ⊆ pi s fun i => eval i '' u
-- Mathlib/Data/Finset/Basic.lean
theorem inter_right_comm (s₁ s₂ s₃ : Finset α) : s₁ ∩ s₂ ∩ s₃ = s₁ ∩ s₃ ∩ s₂
-- Mathlib/Analysis/Calculus/FDeriv/Analytic.lean
theorem HasFPowerSeriesAt.hasFDerivAt (h : HasFPowerSeriesAt f p x) :
    HasFDerivAt f (continuousMultilinearCurryFin1 𝕜 E F (p 1)) x
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem noncommProd_mem (S : Submonoid M) {ι : Type*} (t : Finset ι) (f : ι → M) (comm)
    (h : ∀ c ∈ t, f c ∈ S) : t.noncommProd f comm ∈ S
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem contDiffWithinAtProp_self_source {f : E → H'} {s : Set E} {x : E} :
    ContDiffWithinAtProp 𝓘(𝕜, E) I' n f s x ↔ ContDiffWithinAt 𝕜 n (I' ∘ f) s x
-- Mathlib/Data/Nat/Cast/Basic.lean
theorem ext_nat' [AddMonoid A] [AddMonoidHomClass F ℕ A] (f g : F) (h : f 1 = g 1) : f = g
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
theorem truncate_succ (x : BitVec w) :
    truncate (i+1) x = cons (getLsb x i) (truncate i x)
-- Mathlib/Topology/LocallyConstant/Basic.lean
@[to_additive]
theorem div [Div Y] ⦃f g : X → Y⦄ (hf : IsLocallyConstant f) (hg : IsLocallyConstant g) :
    IsLocallyConstant (f / g)
-- Mathlib/Topology/Semicontinuous.lean
theorem ContinuousAt.upperSemicontinuousAt {f : α → γ} (h : ContinuousAt f x) :
    UpperSemicontinuousAt f x
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem stronglyMeasurable_mk {f : α → β} (hfm : AEStronglyMeasurable' m f μ) :
    StronglyMeasurable[m] (hfm.mk f)
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem map_sup (s t : AffineSubspace k P₁) (f : P₁ →ᵃ[k] P₂) : (s ⊔ t).map f = s.map f ⊔ t.map f
-- Mathlib/Analysis/Normed/Group/Constructions.lean
@[simp] lemma norm_ofMul (x : E) : ‖ofMul x‖ = ‖x‖
-- Mathlib/AlgebraicTopology/DoldKan/Degeneracies.lean
@[reassoc (attr := simp)]
theorem σ_comp_PInfty (X : SimplicialObject C) {n : ℕ} (i : Fin (n + 1)) :
    X.σ i ≫ PInfty.f (n + 1) = 0
-- .lake/packages/batteries/Batteries/Classes/Order.lean
theorem LTCmp.cmp_iff_gt [LT α] [LTCmp (α := α) cmp] : cmp x y = .gt ↔ y < x
-- Mathlib/CategoryTheory/Monad/Adjunction.lean
/-- The comonad induced by the Eilenberg-Moore adjunction is the original comonad. -/
@[simps!]
def adjToComonadIso (G : Comonad C) : G.adj.toComonad ≅ G
-- Mathlib/Algebra/Group/Opposite.lean
@[to_additive (attr := simp, norm_cast)]
theorem op_intCast [IntCast α] (n : ℤ) : op (n : α) = n
-- Mathlib/Order/Compare.lean
theorem Eq.cmp_eq_eq (h : x = y) : cmp x y = Ordering.eq
-- Mathlib/GroupTheory/Perm/List.lean
theorem formPerm_apply_of_not_mem (h : x ∉ l) : formPerm l x = x
-- Mathlib/Topology/PartialHomeomorph.lean
/-- A partial homeomorphism defines a homeomorphism between its source and target. -/
@[simps!] -- Porting note: new `simps`
def toHomeomorphSourceTarget : e.source ≃ₜ e.target
-- Mathlib/FieldTheory/Adjoin.lean
theorem coe_iSup_of_directed [Nonempty ι] (dir : Directed (· ≤ ·) t) :
    ↑(iSup t) = ⋃ i, (t i : Set L)
-- Mathlib/CategoryTheory/Comma/Arrow.lean
@[reassoc (attr := simp)]
lemma inv_hom_id_right (e : f ≅ g) : e.inv.right ≫ e.hom.right = 𝟙 _
-- Mathlib/Analysis/Convex/Quasiconvex.lean
theorem quasilinearOn_iff_monotoneOn_or_antitoneOn [LinearOrderedAddCommMonoid β]
    (hs : Convex 𝕜 s) : QuasilinearOn 𝕜 s f ↔ MonotoneOn f s ∨ AntitoneOn f s
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToFun_eq (hT : DominatedFinMeasAdditive μ T C) (hf : Integrable f μ) :
    setToFun μ T hT f = L1.setToL1 hT (hf.toL1 f)
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem top_coeSubmodule : ((⊤ : LieSubmodule R L M) : Submodule R M) = ⊤
-- Mathlib/Data/Finset/Slice.lean
theorem Sized.univ_mem_iff [Fintype α] (hA : A.Sized r) : Finset.univ ∈ A ↔ A = {Finset.univ}
-- Mathlib/Topology/Defs/Induced.lean
/-- We say that restrictions of the topology on `X` to sets from a family `S`
generates the original topology,
if either of the following equivalent conditions hold:

- a set which is relatively open in each `s ∈ S` is open;
- a set which is relatively closed in each `s ∈ S` is closed;
- for any topological space `Y`, a function `f : X → Y` is continuous
  provided that it is continuous on each `s ∈ S`.
-/
structure RestrictGenTopology (S : Set (Set X)) : Prop where
  isOpen_of_forall_induced (u : Set X) : (∀ s ∈ S, IsOpen ((↑) ⁻¹' u : Set s)) → IsOpen u
-- Mathlib/CategoryTheory/Limits/Shapes/SplitEqualizer.lean
/-- Split equalizers are absolute: they are preserved by any functor. -/
@[simps]
def IsSplitEqualizer.map {W : C} {ι : W ⟶ X} (q : IsSplitEqualizer f g ι) (F : C ⥤ D) :
    IsSplitEqualizer (F.map f) (F.map g) (F.map ι)
-- Mathlib/Algebra/Group/Subsemigroup/Basic.lean
@[to_additive (attr := simp)]
theorem coe_copy {s : Set M} (hs : s = S) : (S.copy s hs : Set M) = s
-- Mathlib/GroupTheory/Coxeter/Length.lean
theorem length_mul_ge_length_sub_length' (w₁ w₂ : W) :
    ℓ w₂ - ℓ w₁ ≤ ℓ (w₁ * w₂)
-- Mathlib/Tactic/NormNum/Result.lean
theorem IsRat.of_raw (α) [DivisionRing α] (n : ℤ) (d : ℕ)
    (h : (d : α) ≠ 0) : IsRat (Rat.rawCast n d : α) n d
-- Mathlib/GroupTheory/Coprod/Basic.lean
@[to_additive (attr := simp)] theorem range_inl_sup_range_inr :
    MonoidHom.range (inl : G →* G ∗ H) ⊔ MonoidHom.range inr = ⊤
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean
lemma F_nat_zero_zero_sub_le {t : ℝ} (ht : 0 < t) :
    ‖F_nat 0 0 t - 1‖ ≤ rexp (-π * t) / (1 - rexp (-π * t))
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem le_csInf_iff'' {s : Set α} {a : α} (ne : s.Nonempty) :
    a ≤ sInf s ↔ ∀ b : α, b ∈ s → a ≤ b
-- Mathlib/GroupTheory/Perm/Basic.lean
@[simp]
theorem symm_mul (e : Perm α) : e.symm * e = 1
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
theorem _root_.Continuous.inner_ {f g : ℝ → E} (hf : Continuous f) (hg : Continuous g) :
    Continuous fun x => inner_ 𝕜 (f x) (g x)
-- Mathlib/SetTheory/Cardinal/Cofinality.lean
theorem bsup_lt_ord_lift_of_isRegular {o : Ordinal} {f : ∀ a < o, Ordinal} {c} (hc : IsRegular c)
    (hι : Cardinal.lift.{v, u} o.card < c) :
    (∀ i hi, f i hi < c.ord) → Ordinal.bsup.{u, v} o f < c.ord
-- Mathlib/Topology/Category/CompactlyGenerated.lean
/-- Construct an isomorphism from a homeomorphism. -/
@[simps hom inv]
def isoOfHomeo {X Y : CompactlyGenerated.{u, w}} (f : X ≃ₜ Y) : X ≅ Y
-- Mathlib/Order/Filter/CardinalInter.lean
theorem EventuallyEq.cardinal_bUnion {S : Set ι} (hS : #S < c)
    {s t : ∀ i ∈ S, Set α} (h : ∀ i hi, s i hi =ᶠ[l] t i hi) :
    ⋃ i ∈ S, s i ‹_› =ᶠ[l] ⋃ i ∈ S, t i ‹_›
-- Mathlib/NumberTheory/ArithmeticFunction.lean
theorem sigma_apply {k n : ℕ} : σ k n = ∑ d ∈ divisors n, d ^ k
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The edist to a singleton is the edistance to the single point of this singleton -/
@[simp]
theorem infEdist_singleton : infEdist x {y} = edist x y
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictMonoOn.mapsTo_Ioc (h : StrictMonoOn f (Icc a b)) :
    MapsTo f (Ioc a b) (Ioc (f a) (f b))
-- Mathlib/LinearAlgebra/Basis.lean
theorem prod_apply_inr_fst (i) : (b.prod b' (Sum.inr i)).1 = 0
-- Mathlib/Algebra/Field/Subfield.lean
@[simp, norm_cast]
theorem coe_one : ((1 : s) : K) = 1
-- Mathlib/Order/Filter/Basic.lean
protected lemma EventuallyEq.iInter [Finite ι] {s t : ι → Set α}
    (h : ∀ i, s i =ᶠ[l] t i) : (⋂ i, s i) =ᶠ[l] ⋂ i, t i
-- Mathlib/Data/Multiset/Basic.lean
theorem ssubset_cons {s : Multiset α} {a : α} (ha : a ∉ s) : s ⊂ a ::ₘ s
-- Mathlib/AlgebraicGeometry/Limits.lean
/-- The open cover of the coproduct. -/
@[simps obj map]
noncomputable
def sigmaOpenCover : (∐ f).OpenCover
-- Mathlib/Data/Finset/Sups.lean
lemma infs_self_subset : s ⊼ s ⊆ s ↔ InfClosed (s : Set α)
-- Mathlib/Computability/TuringMachine.lean
theorem tr_eval' {σ₁ σ₂} (f₁ : σ₁ → Option σ₁) (f₂ : σ₂ → Option σ₂) (tr : σ₁ → σ₂)
    (H : Respects f₁ f₂ fun a b ↦ tr a = b) (a₁) : eval f₂ (tr a₁) = tr <$> eval f₁ a₁
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_sdiff_eq_prod_sdiff_iff :
    ∏ i ∈ s \ t, f i = ∏ i ∈ t \ s, f i ↔ ∏ i ∈ s, f i = ∏ i ∈ t, f i
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
/-- If a closed set has a closed thickening with finite measure, then the measure of its closed
`r`-thickenings converge to its measure as `r` tends to `0`. -/
theorem tendsto_measure_cthickening_of_isClosed {μ : Measure α} {s : Set α}
    (hs : ∃ R > 0, μ (cthickening R s) ≠ ∞) (h's : IsClosed s) :
    Tendsto (fun r => μ (cthickening r s)) (𝓝 0) (𝓝 (μ s))
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
@[simp]
theorem cos_pi_div_two : cos (π / 2) = 0
-- Mathlib/Order/Interval/Finset/Fin.lean
theorem Iio_eq_finset_subtype : Iio b = (Iio (b : ℕ)).fin n
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
lemma norm_jacobiTheta₂_term_fderiv_le (n : ℤ) (z τ : ℂ) :
    ‖jacobiTheta₂_term_fderiv n z τ‖ ≤ 3 * π * |n| ^ 2 * ‖jacobiTheta₂_term n z τ‖
-- Mathlib/Topology/Algebra/Module/Basic.lean
/-- Continuous linear equivalences between modules. We only put the type classes that are necessary
for the definition, although in applications `M` and `M₂` will be topological modules over the
topological semiring `R`. -/
-- Porting note (#5171): linter not ported yet; was @[nolint has_nonempty_instance]
structure ContinuousLinearEquiv {R : Type*} {S : Type*} [Semiring R] [Semiring S] (σ : R →+* S)
    {σ' : S →+* R} [RingHomInvPair σ σ'] [RingHomInvPair σ' σ] (M : Type*) [TopologicalSpace M]
    [AddCommMonoid M] (M₂ : Type*) [TopologicalSpace M₂] [AddCommMonoid M₂] [Module R M]
    [Module S M₂] extends M ≃ₛₗ[σ] M₂ where
  continuous_toFun : Continuous toFun := by continuity
  continuous_invFun : Continuous invFun := by continuity
-- Mathlib/Computability/Partrec.lean
theorem nat_rec {f : α → ℕ} {g : α →. σ} {h : α → ℕ × σ →. σ} (hf : Computable f) (hg : Partrec g)
    (hh : Partrec₂ h) : Partrec fun a => (f a).rec (g a) fun y IH => IH.bind fun i => h a (y, i)
-- Mathlib/Analysis/Calculus/Deriv/AffineMap.lean
theorem hasDerivWithinAt_lineMap : HasDerivWithinAt (lineMap a b) (b - a) s x
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem smul_apply (g : G) (b : Basis ι R M) (i : ι) : (g • b) i = g • b i
-- Mathlib/Data/List/Infix.lean
lemma mem_of_mem_dropSlice {n m : ℕ} {l : List α} {a : α} (h : a ∈ l.dropSlice n m) : a ∈ l
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le_of_lt_add_one {a b : Int} (H : a < b + 1) : a ≤ b
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
theorem closure_union (s t : Set R) : closure (s ∪ t) = closure s ⊔ closure t
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
theorem integral_mul_rpow_one_add_sq {t : ℝ} (ht : t ≠ -1) :
    (∫ x : ℝ in a..b, x * (↑1 + x ^ 2) ^ t) =
      (↑1 + b ^ 2) ^ (t + 1) / (↑2 * (t + ↑1)) - (↑1 + a ^ 2) ^ (t + 1) / (↑2 * (t + ↑1))
-- Mathlib/Topology/Bornology/Constructions.lean
theorem boundedSpace_val_set_iff {s : Set α} : BoundedSpace s ↔ IsBounded s
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem mul_def {f g : MonoidAlgebra k G} :
    f * g = f.sum fun a₁ b₁ => g.sum fun a₂ b₂ => single (a₁ * a₂) (b₁ * b₂)
-- Mathlib/Data/PFun.lean
theorem dom_of_mem_fix {f : α →. β ⊕ α} {a : α} {b : β} (h : b ∈ f.fix a) : (f a).Dom
-- Mathlib/Computability/TuringMachine.lean
theorem Tape.map_mk' {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ') (L R : ListBlank Γ) :
    (Tape.mk' L R).map f = Tape.mk' (L.map f) (R.map f)
-- Mathlib/Data/Nat/Digits.lean
theorem digits_append_digits {b m n : ℕ} (hb : 0 < b) :
    digits b n ++ digits b m = digits b (n + b ^ (digits b n).length * m)
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMin.comp_continuous [TopologicalSpace δ] {g : δ → α} {b : δ}
    (hf : IsLocalMin f (g b)) (hg : ContinuousAt g b) : IsLocalMin (f ∘ g) b
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
protected theorem funext [TopologicalSpace β] [T2Space β] {f g : hatα → β} (hf : Continuous f)
    (hg : Continuous g) (h : ∀ a, f (ι a) = g (ι a)) : f = g
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem associated_rightInverse :
    Function.RightInverse (associatedHom S) (BilinMap.toQuadraticMap : _ → QuadraticMap R M R)
-- Mathlib/SetTheory/Surreal/Multiplication.lean
/-- Symmetry properties of `IH24`. -/
lemma ih24_neg : IH24 x₁ x₂ y → IH24 (-x₂) (-x₁) y ∧ IH24 x₁ x₂ (-y)
-- Mathlib/CategoryTheory/Adhesive.lean
theorem IsPushout.isVanKampen_iff (H : IsPushout f g h i) :
    H.IsVanKampen ↔ IsVanKampenColimit (PushoutCocone.mk h i H.w)
-- Mathlib/Topology/Category/UniformSpace.lean
/-- A (bundled) complete separated uniform space. -/
structure CpltSepUniformSpace where
  /-- The underlying space -/
  α : Type u
  [isUniformSpace : UniformSpace α]
  [isCompleteSpace : CompleteSpace α]
  [isT0 : T0Space α]
-- Mathlib/Probability/ConditionalProbability.lean
lemma cond_eq_zero_of_meas_eq_zero (hμs : μ s = 0) : μ[|s] = 0
-- Mathlib/CategoryTheory/Subobject/Limits.lean
/-- The image of `h ≫ f` is always a smaller subobject than the image of `f`. -/
theorem imageSubobject_comp_le {X' : C} (h : X' ⟶ X) (f : X ⟶ Y) [HasImage f] [HasImage (h ≫ f)] :
    imageSubobject (h ≫ f) ≤ imageSubobject f
-- Mathlib/Order/Filter/CountableInter.lean
theorem EventuallyEq.countable_iUnion [Countable ι] {s t : ι → Set α} (h : ∀ i, s i =ᶠ[l] t i) :
    ⋃ i, s i =ᶠ[l] ⋃ i, t i
-- Mathlib/Analysis/CstarAlgebra/Basic.lean
theorem norm_star_mul_self' {x : E} : ‖x⋆ * x‖ = ‖x⋆‖ * ‖x‖
-- Mathlib/Order/InitialSeg.lean
@[ext] lemma ext {f g : r ≼i s} (h : ∀ x, f x = g x) : f = g
-- Mathlib/GroupTheory/Index.lean
@[to_additive (attr := simp)]
theorem relindex_sup_left [K.Normal] : K.relindex (K ⊔ H) = K.relindex H
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem map_comp_inr : (map f₁ f₂ h).comp inr = inr.comp f₂
-- Mathlib/SetTheory/Cardinal/PartENat.lean
lemma toPartENat_eq_iff_of_le_aleph0 {c c' : Cardinal} (hc : c ≤ ℵ₀) (hc' : c' ≤ ℵ₀) :
    toPartENat c = toPartENat c' ↔ c = c'
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem natTrailingDegree_mul_X_pow {p : R[X]} (hp : p ≠ 0) (n : ℕ) :
    (p * X ^ n).natTrailingDegree = p.natTrailingDegree + n
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem isConnected_image {s : Set X} (h : X ≃ₜ Y) :
    IsConnected (h '' s) ↔ IsConnected s
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem toFin_not (x : BitVec w) :
    (~~~x).toFin = x.toFin.rev
-- Mathlib/Algebra/BigOperators/Option.lean
@[to_additive]
theorem mul_prod_eq_prod_insertNone (f : α → M) (x : M) (s : Finset α) :
    x * ∏ i ∈ s, f i = ∏ i ∈ insertNone s, i.elim x f
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem lift_two : lift.{u, v} 2 = 2
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem toNonUnitalSubalgebra_toSubmodule (p : Submodule R A) (h_mul) :
    (p.toNonUnitalSubalgebra h_mul).toSubmodule = p
-- Mathlib/Data/Stream/Init.lean
theorem mem_cons_of_mem {a : α} {s : Stream' α} (b : α) : a ∈ s → a ∈ b::s
-- Mathlib/Analysis/Normed/Group/Hom.lean
@[simp]
theorem coe_sum {ι : Type*} (s : Finset ι) (f : ι → NormedAddGroupHom V₁ V₂) :
    ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, (f i : V₁ → V₂)
-- Mathlib/Data/Sigma/Basic.lean
theorem Sigma.curry_update {γ : ∀ a, β a → Type*} [DecidableEq α] [∀ a, DecidableEq (β a)]
    (i : Σ a, β a) (f : (i : Σ a, β a) → γ i.1 i.2) (x : γ i.1 i.2) :
    Sigma.curry (Function.update f i x) =
      Function.update (Sigma.curry f) i.1 (Function.update (Sigma.curry f i.1) i.2 x)