ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Fin/Tuple/Sort.lean
theorem graphEquiv₂_apply (f : Fin n → α) (i : Fin n) :
    graphEquiv₂ f i = graphEquiv₁ f (sort f i)
-- Mathlib/Algebra/GroupWithZero/Hom.lean
lemma toMonoidHom_coe (f : α →*₀ β) : f.toMonoidHom.toFun = f
-- Mathlib/Topology/MetricSpace/Basic.lean
theorem subsingleton_sphere (x : γ) {r : ℝ} (hr : r ≤ 0) : (sphere x r).Subsingleton
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
nonrec theorem uniformInducing_iff [PseudoMetricSpace β] {f : α → β} :
    UniformInducing f ↔ UniformContinuous f ∧
      ∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, dist (f a) (f b) < ε → dist a b < δ
-- Mathlib/FieldTheory/IsPerfectClosure.lean
theorem lift_comp_lift_eq_id [PerfectRing L p] :
    (lift j i p).comp (lift i j p) = RingHom.id L
-- Mathlib/NumberTheory/Dioph.lean
theorem dvd_dioph : Dioph fun v => f v ∣ g v
-- Mathlib/Order/Monotone/Basic.lean
protected theorem Monotone.monotoneOn (hf : Monotone f) (s : Set α) : MonotoneOn f s
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_cubic_lt : degree (C a * X ^ 3 + C b * X ^ 2 + C c * X + C d) < 4
-- Mathlib/Analysis/Calculus/Deriv/Polynomial.lean
protected theorem differentiableAt_aeval : DifferentiableAt 𝕜 (fun x => aeval x q) x
-- Mathlib/MeasureTheory/Function/LpSpace.lean
@[simp]
theorem norm_measure_zero (f : Lp E p (0 : MeasureTheory.Measure α)) : ‖f‖ = 0
-- Mathlib/MeasureTheory/Measure/Hausdorff.lean
/-- Caratheodory theorem. If `m` is a metric outer measure, then every Borel measurable set `t` is
Caratheodory measurable: for any (not necessarily measurable) set `s` we have
`μ (s ∩ t) + μ (s \ t) = μ s`. -/
theorem borel_le_caratheodory (hm : IsMetric μ) : borel X ≤ μ.caratheodory
-- Mathlib/Order/Heyting/Basic.lean
theorem IsCompl.eq_compl (h : IsCompl a b) : a = bᶜ
-- Mathlib/Data/Set/Pointwise/Basic.lean
@[to_additive]
theorem inter_mul_union_subset_union : s₁ ∩ s₂ * (t₁ ∪ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂
-- Mathlib/Topology/MetricSpace/IsometricSMul.lean
@[to_additive (attr := simp)]
theorem smul_closedBall (c : G) (x : X) (r : ℝ≥0∞) : c • closedBall x r = closedBall (c • x) r
-- Mathlib/Topology/Inseparable.lean
theorem surjective_mk : Surjective (mk : X → SeparationQuotient X)
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem IsCoprime.of_mul_add_right_right (h : IsCoprime x (z * x + y)) : IsCoprime x y
-- Mathlib/Order/Synonym.lean
theorem toDual_lt [LT α] {a : α} {b : αᵒᵈ} : toDual a < b ↔ ofDual b < a
-- Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean
theorem order_eq_zero_iff' : p.order = 0 ↔ p = 0 ∨ p 0 ≠ 0
-- Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean
@[simp]
private lemma mem_pairs (k : ℕ) (t : Finset σ × σ) :
    t ∈ pairs σ k ↔ card t.fst ≤ k ∧ (card t.fst = k → t.snd ∈ t.fst)
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
@[simp]
theorem e0_mul_v_mul_e0 (m : M) : e0 Q * v Q m * e0 Q = v Q m
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[simp] theorem pred_castSucc_succ (i : Fin n) :
    pred (castSucc i.succ) (Fin.ne_of_gt (castSucc_pos i.succ_pos)) = castSucc i
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `K / E / F` is a field extension tower, such that `E / F` is purely inseparable, then
for any element `x` of `K` separable over `F`, it has the same minimal polynomials over `F` and
over `E`. -/
theorem minpoly.map_eq_of_isSeparable_of_isPurelyInseparable (x : K)
    (hsep : IsSeparable F x) [IsPurelyInseparable F E] :
    (minpoly F x).map (algebraMap F E) = minpoly E x
-- Mathlib/Algebra/Lie/InvariantForm.lean
@[simp]
lemma orthogonal_toSubmodule (N : LieSubmodule R L M) :
    (orthogonal Φ hΦ_inv N).toSubmodule = Φ.orthogonal N.toSubmodule
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
/-- `rotateLeft` equals the bit fiddling definition of `rotateLeftAux` when the rotation amount is
smaller than the bitwidth. -/
theorem rotateLeft_eq_rotateLeftAux_of_lt {x : BitVec w} {r : Nat} (hr : r < w) :
    x.rotateLeft r = x.rotateLeftAux r
-- Mathlib/Algebra/DirectSum/LinearMap.lean
lemma trace_eq_zero_of_mapsTo_ne [IsNoetherian R M]
    (σ : ι → ι) (hσ : ∀ i, σ i ≠ i) {f : Module.End R M}
    (hf : ∀ i, MapsTo f (N i) (N <| σ i)) :
    trace R M f = 0
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[reassoc]
theorem pushout.inr_desc {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z} [HasPushout f g] (h : Y ⟶ W)
    (k : Z ⟶ W) (w : f ≫ h = g ≫ k) : pushout.inr _ _ ≫ pushout.desc h k w = k
-- Mathlib/RingTheory/LocalRing/Basic.lean
theorem of_isUnit_or_isUnit_of_isUnit_add [Nontrivial R]
    (h : ∀ a b : R, IsUnit (a + b) → IsUnit a ∨ IsUnit b) : LocalRing R
-- Mathlib/Data/List/Intervals.lean
theorem nodup (n m : ℕ) : Nodup (Ico n m)
-- Mathlib/Data/Nat/BitIndices.lean
theorem bitIndices_bit_false (n : ℕ) :
    bitIndices (bit false n) = (bitIndices n).map (· + 1)
-- Mathlib/Algebra/Polynomial/Div.lean
@[simp]
theorem rootMultiplicity_C (r a : R) : rootMultiplicity a (C r) = 0
-- Mathlib/MeasureTheory/Measure/Count.lean
theorem count_apply (hs : MeasurableSet s) : count s = ∑' i : s, 1
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
theorem exists_algebraMap_eq_of_pow_mem_subalgebra {A : Type*} [CommRing A] [Algebra R A]
    {S : Subalgebra R A} [IsIntegrallyClosedIn S A] {x : A} {n : ℕ} (hn : 0 < n)
    (hx : x ^ n ∈ S) : ∃ y : S, algebraMap S A y = x
-- Mathlib/Topology/Maps/Proper/Basic.lean
/-- A continuous map from a compact space to a T₂ space is a proper map. -/
theorem Continuous.isProperMap [CompactSpace X] [T2Space Y] (hf : Continuous f) : IsProperMap f
-- Mathlib/CategoryTheory/Comma/Over.lean
/-- The functor defined by the over categories.-/
@[simps] def mapFunctor : T ⥤ Cat
-- Mathlib/Algebra/Category/ModuleCat/Subobject.lean
@[simp]
theorem toKernelSubobject_arrow {M N : ModuleCat R} {f : M ⟶ N} (x : LinearMap.ker f) :
    (kernelSubobject f).arrow (toKernelSubobject x) = x.1
-- Mathlib/Data/Finset/Image.lean
theorem apply_coe_mem_map (f : α ↪ β) (s : Finset α) (x : s) : f x ∈ s.map f
-- Mathlib/Data/W/Basic.lean
theorem infinite_of_nonempty_of_isEmpty (a b : α) [ha : Nonempty (β a)] [he : IsEmpty (β b)] :
    Infinite (WType β)
-- Mathlib/Data/Matrix/Basic.lean
theorem submatrix_neg [Neg α] (A : Matrix m n α) :
    ((-A).submatrix : (l → m) → (o → n) → Matrix l o α) = -A.submatrix
-- Mathlib/SetTheory/Cardinal/Finite.lean
lemma card_pos_iff : 0 < Nat.card α ↔ Nonempty α ∧ Finite α
-- Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean
theorem AECover.biUnion_Iic_aecover [Preorder ι] {φ : ι → Set α} (hφ : AECover μ atTop φ) :
    AECover μ atTop fun n : ι => ⋃ (k) (_h : k ∈ Iic n), φ k
-- Mathlib/Data/NNReal/Basic.lean
theorem toNNReal_mul {p q : ℝ} (hp : 0 ≤ p) :
    Real.toNNReal (p * q) = Real.toNNReal p * Real.toNNReal q
-- Mathlib/Data/Rat/Defs.lean
@[simp, nolint simpNF, norm_cast] lemma intCast_eq_zero {n : ℤ} : (n : ℚ) = 0 ↔ n = 0
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem toOpposite_apply (r : R) : toOpposite R r = op r
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
@[simp] theorem gcd_one_left (n : Nat) : gcd 1 n = 1
-- Mathlib/Analysis/Convex/Intrinsic.lean
@[simp]
theorem closure_diff_intrinsicInterior (s : Set P) :
    closure s \ intrinsicInterior 𝕜 s = intrinsicFrontier 𝕜 s
-- Mathlib/RingTheory/PolynomialAlgebra.lean
@[simp]
theorem invFun_add {p q} : invFun R A (p + q) = invFun R A p + invFun R A q
-- Mathlib/Data/Complex/Module.lean
@[simp]
theorem coe_basisOneI : ⇑basisOneI = ![1, I]
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := measurability)]
theorem _root_.Multiset.stronglyMeasurable_prod' (l : Multiset (α → M))
    (hl : ∀ f ∈ l, StronglyMeasurable f) : StronglyMeasurable l.prod
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
@[simp]
theorem smul_mem_pointwise_smul_iff₀ {a : M} (ha : a ≠ 0) (S : Subring R) (x : R) :
    a • x ∈ a • S ↔ x ∈ S
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[reassoc]
lemma LeftHomologyData.leftHomologyIso_inv_naturality
    (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData) :
    h₁.homologyIso.inv ≫ homologyMap φ =
      leftHomologyMap' φ h₁ h₂ ≫ h₂.homologyIso.inv
-- Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean
/-- For a vector with invertible quadratic form, $v^{-1} = \frac{v}{Q(v)}$ -/
theorem invOf_ι (m : M) [Invertible (Q m)] [Invertible (ι Q m)] :
    ⅟ (ι Q m) = ι Q (⅟ (Q m) • m)
-- Mathlib/Order/Filter/Prod.lean
theorem Eventually.prod_mk {la : Filter α} {pa : α → Prop} (ha : ∀ᶠ x in la, pa x) {lb : Filter β}
    {pb : β → Prop} (hb : ∀ᶠ y in lb, pb y) : ∀ᶠ p in la ×ˢ lb, pa (p : α × β).1 ∧ pb p.2
-- Mathlib/Data/List/Basic.lean
theorem getLast?_append_of_ne_nil (l₁ : List α) :
    ∀ {l₂ : List α} (_ : l₂ ≠ []), getLast? (l₁ ++ l₂) = getLast? l₂
-- Mathlib/RingTheory/Localization/Basic.lean
/-- If `M` contains `0` then the localization at `M` is trivial. -/
theorem subsingleton (h : 0 ∈ M) : Subsingleton S
-- Mathlib/InformationTheory/Hamming.lean
theorem hammingDist_le_card_fintype {x y : ∀ i, β i} : hammingDist x y ≤ Fintype.card ι
-- Mathlib/Algebra/Lie/Semisimple/Basic.lean
theorem hasTrivialRadical_iff_no_solvable_ideals :
    HasTrivialRadical R L ↔ ∀ I : LieIdeal R L, IsSolvable R I → I = ⊥
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp] theorem cond_true_right  : ∀(c t : Bool), cond c t true  = (!c || t)
-- Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean
/-- Asymptotic bound for the `Γ` function integrand. -/
theorem Gamma_integrand_isLittleO (s : ℝ) :
    (fun x : ℝ => exp (-x) * x ^ s) =o[atTop] fun x : ℝ => exp (-(1 / 2) * x)
-- Mathlib/Algebra/Order/GroupWithZero/Canonical.lean
theorem OrderIso.mulLeft₀'_symm {a : α} (ha : a ≠ 0) :
    (OrderIso.mulLeft₀' ha).symm = OrderIso.mulLeft₀' (inv_ne_zero ha)
-- Mathlib/LinearAlgebra/RootSystem/Defs.lean
lemma reflection_apply (x : M) :
    P.reflection i x = x - (P.toLin x (P.coroot i)) • P.root i
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem spanSingleton_div_self {x : K} (hx : x ≠ 0) :
    spanSingleton R₁⁰ x / spanSingleton R₁⁰ x = 1
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma map_sub : (z - z').map Φ = z.map Φ - z'.map Φ
-- Mathlib/Data/ZMod/Basic.lean
theorem intCast_surjective : Function.Surjective ((↑) : ℤ → ZMod n)
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem rat_sub (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (r - x)
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem Dvd.elim {P : Prop} {a b : α} (H₁ : a ∣ b) (H₂ : ∀ c, b = a * c → P) : P
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem toList_formPerm_singleton (x y : α) : toList (formPerm [x]) y = []
-- Mathlib/Geometry/Manifold/Algebra/LieGroup.lean
theorem SmoothWithinAt.inv₀ (hf : SmoothWithinAt I' I f s a) (ha : f a ≠ 0) :
    SmoothWithinAt I' I (fun x => (f x)⁻¹) s a
-- Mathlib/CategoryTheory/Functor/FullyFaithful.lean
@[simp]
theorem fullyFaithfulCancelRight_hom_app {F G : C ⥤ D} {H : D ⥤ E} [Full H] [H.Faithful]
    (comp_iso : F ⋙ H ≅ G ⋙ H) (X : C) :
    (fullyFaithfulCancelRight H comp_iso).hom.app X = H.preimage (comp_iso.hom.app X)
-- Mathlib/Analysis/Complex/ReImTopology.lean
@[simp]
theorem frontier_setOf_re_lt (a : ℝ) : frontier { z : ℂ | z.re < a } = { z | z.re = a }
-- Mathlib/MeasureTheory/Measure/NullMeasurable.lean
protected theorem sInter {s : Set (Set α)} (hs : s.Countable) (h : ∀ t ∈ s, NullMeasurableSet t μ) :
    NullMeasurableSet (⋂₀ s) μ
-- Mathlib/Order/Category/BddLat.lean
theorem bddLat_dual_comp_forget_to_bddOrd :
    BddLat.dual ⋙ forget₂ BddLat BddOrd =
    forget₂ BddLat BddOrd ⋙ BddOrd.dual
-- Mathlib/LinearAlgebra/RootSystem/Basic.lean
private theorem exist_eq_reflection_of_mapsTo  :
    ∃ k, root k = (preReflection (root i) (p.toLin.flip (coroot i))) (root j)
-- Mathlib/CategoryTheory/Limits/Opposites.lean
theorem hasProductsOfShape_of_opposite [HasCoproductsOfShape X Cᵒᵖ] : HasProductsOfShape X C
-- Mathlib/Topology/Order/LowerUpperTopology.lean
@[simp] lemma of_WithUpper_symm_eq : (@ofUpper α).symm = toUpper
-- Mathlib/CategoryTheory/Limits/Types.lean
theorem colimit_eq {j j' : J} {x : F.obj j} {x' : F.obj j'}
    (w : colimit.ι F j x = colimit.ι F j' x') :
      EqvGen (Quot.Rel F) ⟨j, x⟩ ⟨j', x'⟩
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem maximum?_mem [Max α] (min_eq_or : ∀ a b : α, max a b = a ∨ max a b = b) :
    {xs : List α} → xs.maximum? = some a → a ∈ xs
-- Mathlib/Analysis/SpecialFunctions/Log/Basic.lean
theorem lt_log_iff_exp_lt (hy : 0 < y) : x < log y ↔ exp x < y
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem deleteVerts_inter_verts_set_right_eq :
    G'.deleteVerts (s ∩ G'.verts) = G'.deleteVerts s
-- Mathlib/Algebra/Quaternion.lean
@[simp, norm_cast]
theorem natCast_imI (n : ℕ) : (n : ℍ[R,c₁,c₂]).imI = 0
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
nonrec theorem formPerm_reverse (s : Cycle α) (h : Nodup s) :
    formPerm s.reverse (nodup_reverse_iff.mpr h) = (formPerm s h)⁻¹
-- Mathlib/Combinatorics/Colex.lean
@[simp] lemma ofColex_bot : ofColex (⊥ : Colex α) = ∅
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
@[simp]
theorem midpoint_sub_right (v₁ v₂ : V) : midpoint R v₁ v₂ - v₂ = (⅟ 2 : R) • (v₁ - v₂)
-- Mathlib/Control/ULift.lean
@[simp]
theorem map_up (f : α → β) (a : α) : (ULift.up.{u'} a).map f = ULift.up.{v'} (f a)
-- Mathlib/Probability/Martingale/Basic.lean
theorem submartingale [Preorder E] (hf : Martingale f ℱ μ) : Submartingale f ℱ μ
-- Mathlib/Data/Matroid/Restrict.lean
/-- Any independent set can be extended into a larger independent set. -/
theorem Indep.augment (hI : M.Indep I) (hJ : M.Indep J) (hIJ : I.encard < J.encard) :
    ∃ e ∈ J \ I, M.Indep (insert e I)
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem prime_C_iff : Prime (C r) ↔ Prime r
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem ae_le_iff_absolutelyContinuous : ae μ ≤ ae ν ↔ μ ≪ ν
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
nonrec theorem _root_.RCLike.intervalIntegral_ofReal {𝕜 : Type*} [RCLike 𝕜] {a b : ℝ}
    {μ : Measure ℝ} {f : ℝ → ℝ} : (∫ x in a..b, (f x : 𝕜) ∂μ) = ↑(∫ x in a..b, f x ∂μ)
-- Mathlib/Analysis/Complex/Circle.lean
@[simp]
theorem expMapCircle_neg (x : ℝ) : expMapCircle (-x) = (expMapCircle x)⁻¹
-- Mathlib/NumberTheory/ModularForms/CongruenceSubgroups.lean
@[simp]
theorem Gamma1_mem (N : ℕ) (A : SL(2, ℤ)) : A ∈ Gamma1 N ↔
    ((↑ₘA 0 0 : ℤ) : ZMod N) = 1 ∧ ((↑ₘA 1 1 : ℤ) : ZMod N) = 1 ∧ ((↑ₘA 1 0 : ℤ) : ZMod N) = 0
-- Mathlib/LinearAlgebra/Finsupp.lean
@[simp]
theorem lmapDomain_id : (lmapDomain M R _root_.id : (α →₀ M) →ₗ[R] α →₀ M) = LinearMap.id
-- Mathlib/LinearAlgebra/Ray.lean
/-- A vector is in the same ray as a nonnegative multiple of one it is in the same ray as. -/
lemma nonneg_smul_right (h : SameRay R x y) (ha : 0 ≤ a) : SameRay R x (a • y)
-- Mathlib/CategoryTheory/Sites/Over.lean
@[simp]
lemma overEquiv_symm_top {X : C} (Y : Over X) :
    (overEquiv Y).symm ⊤ = ⊤
-- Mathlib/LinearAlgebra/LinearPMap.lean
theorem le_graph_iff {f g : E →ₗ.[R] F} : f.graph ≤ g.graph ↔ f ≤ g
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
@[simp]
theorem norm_ofSubsingleton [Subsingleton ι] (i : ι) (f : G →L[𝕜] G') :
    ‖ofSubsingleton 𝕜 G G' i f‖ = ‖f‖
-- Mathlib/Logic/Basic.lean
theorem exists_unique_const {b : Prop} (α : Sort*) [i : Nonempty α] [Subsingleton α] :
    (∃! _ : α, b) ↔ b
-- Mathlib/Topology/ContinuousFunction/Basic.lean
theorem coe_injective : @Function.Injective C(α, β) (α → β) (↑)
-- Mathlib/Topology/MetricSpace/Holder.lean
protected theorem mono (hf : HolderOnWith C r f s) (ht : t ⊆ s) : HolderOnWith C r f t
-- Mathlib/Algebra/Homology/Additive.lean
@[simp]
theorem zero_f_apply (i : ι) : (0 : C ⟶ D).f i = 0
-- Mathlib/Analysis/Convex/Mul.lean
lemma ConvexOn.smul_concaveOn (hf : ConvexOn 𝕜 s f) (hg : ConcaveOn 𝕜 s g)
    (hf₀ : ∀ ⦃x⦄, x ∈ s → 0 ≤ f x) (hg₀ : ∀ ⦃x⦄, x ∈ s → g x ≤ 0) (hfg : AntivaryOn f g s) :
    ConcaveOn 𝕜 s (f • g)
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem truncate_eq (x : BitVec n) : truncate n x = x
-- Mathlib/Analysis/NormedSpace/AddTorsor.lean
@[simp]
theorem dist_left_midpoint (p₁ p₂ : P) : dist p₁ (midpoint 𝕜 p₁ p₂) = ‖(2 : 𝕜)‖⁻¹ * dist p₁ p₂
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Bitwise/Lemmas.lean
theorem testBit_mul_pow_two :
    testBit (2 ^ i * a) j = (decide (j ≥ i) && testBit a (j-i))
-- Mathlib/Order/Filter/Lift.lean
theorem lift_iInf_of_directed [Nonempty ι] {f : ι → Filter α} {g : Set α → Filter β}
    (hf : Directed (· ≥ ·) f) (hg : Monotone g) : (iInf f).lift g = ⨅ i, (f i).lift g
-- Mathlib/Order/Bounds/Basic.lean
theorem lowerBounds_Ioo {a b : γ} (hab : a < b) : lowerBounds (Ioo a b) = Iic a
-- Mathlib/Logic/Hydra.lean
lemma cutExpand_zero {x} : CutExpand r 0 {x}
-- Mathlib/Algebra/Order/Interval/Set/Group.lean
@[to_additive]
theorem inv_mem_Ioc_iff : a⁻¹ ∈ Set.Ioc c d ↔ a ∈ Set.Ico d⁻¹ c⁻¹
-- Mathlib/Algebra/Module/LinearMap/End.lean
theorem coe_one : ⇑(1 : Module.End R M) = _root_.id
-- Mathlib/Order/Filter/Basic.lean
theorem EventuallyEq.sub_eq [AddGroup β] {f g : α → β} {l : Filter α} (h : f =ᶠ[l] g) :
    f - g =ᶠ[l] 0
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
/-- The total mass of a finite measure depends continuously on the measure. -/
theorem continuous_mass : Continuous fun μ : FiniteMeasure Ω => μ.mass
-- Mathlib/Data/Multiset/Basic.lean
theorem count_cons (a b : α) (s : Multiset α) :
    count a (b ::ₘ s) = count a s + if a = b then 1 else 0
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
theorem fderivWithin_smul_const (hxs : UniqueDiffWithinAt 𝕜 s x)
    (hc : DifferentiableWithinAt 𝕜 c s x) (f : F) :
    fderivWithin 𝕜 (fun y => c y • f) s x = (fderivWithin 𝕜 c s x).smulRight f
-- Mathlib/Data/Nat/Dist.lean
theorem dist_mul_left (k n m : ℕ) : dist (k * n) (k * m) = k * dist n m
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem AlgebraicIndependent.aeval_comp_repr : (aeval x).comp hx.repr = Subalgebra.val _
-- Mathlib/Algebra/Order/ToIntervalMod.lean
@[simp]
theorem toIocDiv_add_left (a b : α) : toIocDiv hp a (p + b) = toIocDiv hp a b + 1
-- Mathlib/Algebra/Category/Ring/Basic.lean
@[simp] lemma forget_map {X Y : CommRingCat} (f : X ⟶ Y) :
    (forget CommRingCat).map f = (f : X → Y)
-- Mathlib/Computability/NFA.lean
@[simp]
theorem eval_append_singleton (x : List α) (a : α) : M.eval (x ++ [a]) = M.stepSet (M.eval x) a
-- Mathlib/SetTheory/Game/PGame.lean
@[simp] theorem Subsequent.moveRight_mk_left {xR : xr → PGame} {i : xl} (xL : xl → PGame) (j) :
    Subsequent ((xL i).moveRight j) (mk xl xr xL xR)
-- Mathlib/SetTheory/Surreal/Dyadic.lean
theorem powHalf_succ_lt_powHalf (n : ℕ) : powHalf (n + 1) < powHalf n
-- Mathlib/LinearAlgebra/FiniteDimensional/Defs.lean
/-- If a submodule is contained in a finite-dimensional
submodule with the same dimension, they are equal. -/
theorem eq_of_le_of_finrank_eq {S₁ S₂ : Submodule K V} [FiniteDimensional K S₂] (hle : S₁ ≤ S₂)
    (hd : finrank K S₁ = finrank K S₂) : S₁ = S₂
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
lemma nsmul_zmod_val_inv_nsmul (hn : (Nat.card α).Coprime n) (a : α) :
    n • (n⁻¹ : ZMod (Nat.card α)).val • a = a
-- Mathlib/Topology/DiscreteQuotient.lean
theorem leComap_id : LEComap (.id X) A A
-- Mathlib/Algebra/Ring/Parity.lean
lemma not_odd_iff : ¬Odd n ↔ n % 2 = 0
-- Mathlib/Tactic/NormNum/Prime.lean
theorem isNat_minFac_1 : {a : ℕ} → IsNat a (nat_lit 1) → IsNat a.minFac 1
-- Mathlib/ModelTheory/ElementaryMaps.lean
@[ext]
theorem ext ⦃f g : M ↪ₑ[L] N⦄ (h : ∀ x, f x = g x) : f = g
-- Mathlib/Algebra/Polynomial/Induction.lean
theorem exists_C_coeff_not_mem : f ∉ I → ∃ i : ℕ, C (coeff f i) ∉ I
-- Mathlib/RingTheory/AdjoinRoot.lean
theorem isRoot_root (f : R[X]) : IsRoot (f.map (of f)) (root f)
-- Mathlib/NumberTheory/PythagoreanTriples.lean
@[simp]
theorem circleEquivGen_symm_apply (hk : ∀ x : K, 1 + x ^ 2 ≠ 0)
    (v : { p : K × K // p.1 ^ 2 + p.2 ^ 2 = 1 ∧ p.2 ≠ -1 }) :
    (circleEquivGen hk).symm v = (v : K × K).1 / ((v : K × K).2 + 1)
-- Mathlib/Algebra/Star/Basic.lean
/-- `StarMemClass S G` states `S` is a type of subsets `s ⊆ G` closed under star. -/
class StarMemClass (S R : Type*) [Star R] [SetLike S R] : Prop where
  /-- Closure under star. -/
  star_mem : ∀ {s : S} {r : R}, r ∈ s → star r ∈ s
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp] theorem coe_mul (e₁ e₂ : α ≃ᵢ α) : ⇑(e₁ * e₂) = e₁ ∘ e₂
-- Mathlib/Topology/Bornology/Basic.lean
@[simp]
theorem cobounded_eq_bot : cobounded α = ⊥
-- Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean
@[ext]
lemma ext {M : ModuleCat B} {α β : KaehlerDifferential f ⟶ M}
    (h : ∀ (b : B), α (d b) = β (d b)) : α = β
-- Mathlib/Order/Interval/Set/Basic.lean
theorem left_mem_Ici : a ∈ Ici a
-- Mathlib/Order/Bounds/Basic.lean
lemma bddBelow_prod {s : Set (α × β)} :
    BddBelow s ↔ BddBelow (Prod.fst '' s) ∧ BddBelow (Prod.snd '' s)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_X_pow_le {R : Type*} [Semiring R] (n : ℕ) : (X ^ n : R[X]).natDegree ≤ n
-- Mathlib/SetTheory/Ordinal/Topology.lean
theorem nhds_left'_eq_nhds_ne (a : Ordinal) : 𝓝[<] a = 𝓝[≠] a
-- Mathlib/Algebra/Ring/Subring/Basic.lean
/-- Product of a multiset of elements in a subring of a `CommRing` is in the subring. -/
protected theorem multiset_prod_mem {R} [CommRing R] (s : Subring R) (m : Multiset R) :
    (∀ a ∈ m, a ∈ s) → m.prod ∈ s
-- Mathlib/MeasureTheory/Decomposition/RadonNikodym.lean
theorem integral_rnDeriv_smul [HaveLebesgueDecomposition μ ν] (hμν : μ ≪ ν)
    [SigmaFinite μ] {f : α → E} :
    ∫ x, (μ.rnDeriv ν x).toReal • f x ∂ν = ∫ x, f x ∂μ
-- Mathlib/Topology/FiberBundle/Trivialization.lean
@[simp]
theorem coe_mem_source : ↑y ∈ e'.source ↔ b ∈ e'.baseSet
-- Mathlib/MeasureTheory/Measure/AEMeasurable.lean
lemma mono_ac (hf : AEMeasurable f ν) (hμν : μ ≪ ν) : AEMeasurable f μ
-- Mathlib/Analysis/Matrix.lean
theorem frobenius_norm_def (A : Matrix m n α) :
    ‖A‖ = (∑ i, ∑ j, ‖A i j‖ ^ (2 : ℝ)) ^ (1 / 2 : ℝ)
-- Mathlib/Order/Filter/Prod.lean
theorem map_prod_map_coprod_le.{u, v, w, x} {α₁ : Type u} {α₂ : Type v} {β₁ : Type w} {β₂ : Type x}
    {f₁ : Filter α₁} {f₂ : Filter α₂} {m₁ : α₁ → β₁} {m₂ : α₂ → β₂} :
    map (Prod.map m₁ m₂) (f₁.coprod f₂) ≤ (map m₁ f₁).coprod (map m₂ f₂)
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[to_additive (attr := measurability)]
theorem measurable_one [One α] : Measurable (1 : β → α)
-- Mathlib/Topology/MetricSpace/Ultra/Basic.lean
lemma isOpen_closedBall {r : ℝ} (hr : r ≠ 0) : IsOpen (closedBall x r)
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem sup_eq_top_iff_isCoprime {R : Type*} [CommSemiring R] (x y : R) :
    span ({x} : Set R) ⊔ span {y} = ⊤ ↔ IsCoprime x y
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
@[deprecated ofNat'_zero_val (since := "2024-02-22")]
theorem ofNat'_zero_val : (Fin.ofNat' 0 h).val = 0
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem spanSingleton_one : spanSingleton S (1 : P) = 1
-- Mathlib/RingTheory/Localization/Integral.lean
@[simp]
theorem integerNormalization_coeff (p : S[X]) (i : ℕ) :
    (integerNormalization M p).coeff i = coeffIntegerNormalization M p i
-- Mathlib/CategoryTheory/Monoidal/CommMon_.lean
/-- The trivial commutative monoid object. We later show this is initial in `CommMon_ C`.
-/
@[simps!]
def trivial : CommMon_ C
-- Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean
theorem localization_comap_range [Algebra R S] (M : Submonoid R) [IsLocalization M S] :
    Set.range (comap (algebraMap R S)) = { p | Disjoint (M : Set R) p.asIdeal }
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
@[simp]
theorem areaForm_rightAngleRotation_left (x y : E) : ω (J x) y = -⟪x, y⟫
-- Mathlib/Topology/Order/MonotoneContinuity.lean
/-- If a function `f` is strictly monotone on a right neighborhood of `a` and the image of this
neighborhood under `f` includes `Ioi (f a)`, then `f` is continuous at `a` from the right. -/
theorem StrictMonoOn.continuousWithinAt_right_of_surjOn {f : α → β} {s : Set α} {a : α}
    (h_mono : StrictMonoOn f s) (hs : s ∈ 𝓝[≥] a) (hfs : SurjOn f s (Ioi (f a))) :
    ContinuousWithinAt f (Ici a) a