ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp] theorem domCongr_refl : domCongr k A (MulEquiv.refl G) = AlgEquiv.refl
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem prime_of_degree_eq_one (hp1 : degree p = 1) : Prime p
-- Mathlib/Data/Fintype/BigOperators.lean
/-- The number of dependent maps `f : Π j, s j` for which the `i` component is `a` is the product
over all `j ≠ i` of `(s j).card`.

Note that this is just a composition of easier lemmas, but there's some glue missing to make that
smooth enough not to need this lemma. -/
lemma card_filter_piFinset_eq_of_mem (s : ∀ i, Finset (α i)) (i : ι) {a : α i} (ha : a ∈ s i) :
    ((piFinset s).filter fun f ↦ f i = a).card = ∏ j ∈ univ.erase i, (s j).card
-- Mathlib/NumberTheory/LucasLehmer.lean
@[simp] theorem zero_snd : (0 : X q).2 = 0
-- Mathlib/Topology/ContinuousFunction/Ideals.lean
@[simp]
theorem mem_idealOfSet_compl_singleton (x : X) (f : C(X, R)) :
    f ∈ idealOfSet R ({x}ᶜ : Set X) ↔ f x = 0
-- Mathlib/Data/Nat/Fib/Basic.lean
theorem gcd_fib_add_mul_self (m n : ℕ) : ∀ k, gcd (fib m) (fib (n + k * m)) = gcd (fib m) (fib n)
-- Mathlib/Data/ZMod/Basic.lean
theorem natCast_eq_iff (p : ℕ) (n : ℕ) (z : ZMod p) [NeZero p] :
    ↑n = z ↔ ∃ k, n = z.val + p * k
-- Mathlib/SetTheory/Cardinal/Basic.lean
/-- A variant of `ciSup_of_empty` but with `0` on the RHS for convenience -/
protected theorem iSup_of_empty {ι} (f : ι → Cardinal) [IsEmpty ι] : iSup f = 0
-- Mathlib/CategoryTheory/Galois/Decomposition.lean
/-- Key technical lemma: the twisted inclusion `selfProdPermIncl h b` maps `a` to `F.map u b`. -/
private lemma selfProdTermIncl_fib_eq (b : F.obj A) :
    F.map u b = F.map (selfProdPermIncl h b) a
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- An angle in a right-angled triangle is at most `π / 2`. -/
theorem angle_le_pi_div_two_of_angle_eq_pi_div_two {p₁ p₂ p₃ : P} (h : ∠ p₁ p₂ p₃ = π / 2) :
    ∠ p₂ p₃ p₁ ≤ π / 2
-- Mathlib/CategoryTheory/Limits/Preserves/Shapes/Zero.lean
lemma map_isZero (F : C ⥤ D) [PreservesZeroMorphisms F] {X : C} (hX : IsZero X) :
    IsZero (F.obj X)
-- Mathlib/Order/Bounded.lean
theorem unbounded_gt_iff_unbounded_ge [Preorder α] [NoMinOrder α] :
    Unbounded (· > ·) s ↔ Unbounded (· ≥ ·) s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem zip_append :
    ∀ {l₁ r₁ : List α} {l₂ r₂ : List β} (_h : length l₁ = length l₂),
      zip (l₁ ++ r₁) (l₂ ++ r₂) = zip l₁ l₂ ++ zip r₁ r₂
-- Mathlib/Algebra/Module/Equiv/Defs.lean
@[simp]  -- Porting note: norm_cast
theorem comp_coe [Module R M] [Module R M₂] [Module R M₃] (f : M ≃ₗ[R] M₂) (f' : M₂ ≃ₗ[R] M₃) :
    (f' : M₂ →ₗ[R] M₃).comp (f : M →ₗ[R] M₂) = (f.trans f' : M ≃ₗ[R] M₃)
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
@[simp]
theorem rank_bot : Module.rank R (⊥ : Submodule R M) = 0
-- Mathlib/Topology/UniformSpace/UniformEmbedding.lean
theorem completeSpace_coe_iff_isComplete {s : Set α} : CompleteSpace s ↔ IsComplete s
-- Mathlib/Algebra/Homology/TotalComplex.lean
lemma ιTotalOrZero_eq (i₁ : I₁) (i₂ : I₂) (i₁₂ : I₁₂)
    (h : ComplexShape.π c₁ c₂ c₁₂ (i₁, i₂) = i₁₂) :
    K.ιTotalOrZero c₁₂ i₁ i₂ i₁₂ = K.ιTotal c₁₂ i₁ i₂ i₁₂ h
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
@[simp]
theorem length_listTransvecCol : (listTransvecCol M).length = r
-- Mathlib/Topology/MetricSpace/Isometry.lean
@[simp] theorem toEquiv_inj {e₁ e₂ : α ≃ᵢ β} : e₁.toEquiv = e₂.toEquiv ↔ e₁ = e₂
-- Mathlib/RingTheory/Ideal/Norm.lean
theorem norm_dvd_iff {x : S} (hx : Prime (Algebra.norm ℤ x)) {y : ℤ} :
    Algebra.norm ℤ x ∣ y ↔ x ∣ y
-- Mathlib/Data/Finmap.lean
theorem mem_list_toFinmap (a : α) (xs : List (Sigma β)) :
    a ∈ xs.toFinmap ↔ ∃ b : β a, Sigma.mk a b ∈ xs
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
/-- To construct an isomorphism between tridents,
it suffices to give an isomorphism between the cone points
and check that it commutes with the `ι` morphisms.
-/
@[simps]
def Trident.ext [Nonempty J] {s t : Trident f} (i : s.pt ≅ t.pt)
    (w : i.hom ≫ t.ι = s.ι := by aesop_cat) : s ≅ t
-- Mathlib/Analysis/Normed/Lp/WithLp.lean
@[simp]
theorem equiv_sub : WithLp.equiv p V (x - y) = WithLp.equiv p V x - WithLp.equiv p V y
-- Mathlib/GroupTheory/Perm/Support.lean
theorem pow_eq_on_of_mem_support (h : ∀ x ∈ f.support ∩ g.support, f x = g x) (k : ℕ) :
    ∀ x ∈ f.support ∩ g.support, (f ^ k) x = (g ^ k) x
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem tendsto_dist_left_cobounded_atTop (c : α) : Tendsto (dist c) (cobounded α) atTop
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.sup (h : IsBigOWith c l f g) (h' : IsBigOWith c l' f g) :
    IsBigOWith c (l ⊔ l') f g
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
/-- An auxiliary lemma for manipulating sequence indices. -/
theorem lift_index_left_left {f : PadicSeq p} (hf : ¬f ≈ 0) (v2 v3 : ℕ) :
    padicNorm p (f (stationaryPoint hf)) =
    padicNorm p (f (max (stationaryPoint hf) (max v2 v3)))
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem infinite_iff {α : Type u} : Infinite α ↔ ℵ₀ ≤ #α
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
@[simp]
lemma fromColumns_apply_inl (A₁ : Matrix m n₁ R) (A₂ : Matrix m n₂ R) (i : m) (j : n₁) :
    (fromColumns A₁ A₂) i (Sum.inl j) = A₁ i j
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
@[deprecated getElem?_take_eq_if (since := "2024-06-12")]
theorem get?_take_eq_if {l : List α} {n m : Nat} :
    (l.take n).get? m = if m < n then l.get? m else none
-- Mathlib/Analysis/Seminorm.lean
theorem mem_closedBall_self (hr : 0 ≤ r) : x ∈ closedBall p x r
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem coe_lt_top (x : ℝ) : (x : EReal) < ⊤
-- Mathlib/RingTheory/Localization/Basic.lean
theorem to_map_eq_zero_iff {x : R} (hM : M ≤ nonZeroDivisors R) : algebraMap R S x = 0 ↔ x = 0
-- Mathlib/Algebra/Lie/Subalgebra.lean
theorem lieSpan_eq : lieSpan R L (K : Set L) = K
-- Mathlib/MeasureTheory/Integral/CircleIntegral.lean
nonrec theorem add (hf : CircleIntegrable f c R) (hg : CircleIntegrable g c R) :
    CircleIntegrable (f + g) c R
-- Mathlib/Computability/Partrec.lean
theorem vector_mOfFn :
    ∀ {n} {f : Fin n → α →. σ},
      (∀ i, Partrec (f i)) → Partrec fun a : α => Vector.mOfFn fun i => f i a
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
protected theorem eq_div_of_mul_eq_right {a b c : Int}
    (H1 : a ≠ 0) (H2 : a * b = c) : b = c.div a
-- Mathlib/NumberTheory/LegendreSymbol/Basic.lean
theorem eq_neg_one_iff_not_one {a : ℤ} (ha : (a : ZMod p) ≠ 0) :
    legendreSym p a = -1 ↔ ¬legendreSym p a = 1
-- Mathlib/Data/Finset/NoncommProd.lean
@[to_additive]
theorem noncommProd_cons' (s : Multiset α) (a : α) (comm) :
    noncommProd (a ::ₘ s) comm = noncommProd s (comm.mono fun _ => mem_cons_of_mem) * a
-- Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean
theorem image_inversion_perpBisector (hR : R ≠ 0) (hy : y ≠ c) :
    inversion c R '' perpBisector c y = sphere (inversion c R y) (R ^ 2 / dist y c) \ {c}
-- Mathlib/Data/List/Basic.lean
@[simp default+1] -- Porting note: this used to be just @[simp]
lemma length_injective [Subsingleton α] : Injective (length : List α → ℕ)
-- Mathlib/Analysis/BoundedVariation.lean
theorem MonotoneOn.locallyBoundedVariationOn {f : α → ℝ} {s : Set α} (hf : MonotoneOn f s) :
    LocallyBoundedVariationOn f s
-- Mathlib/Topology/Order/MonotoneConvergence.lean
theorem Monotone.ge_of_tendsto [TopologicalSpace α] [Preorder α] [OrderClosedTopology α]
    [SemilatticeSup β] {f : β → α} {a : α} (hf : Monotone f) (ha : Tendsto f atTop (𝓝 a)) (b : β) :
    f b ≤ a
-- Mathlib/CategoryTheory/Monoidal/Rigid/Basic.lean
@[simp]
theorem tensorRightHomEquiv_whiskerLeft_comp_evaluation {X Y : C} [HasRightDual X] [HasRightDual Y]
    (f : X ⟶ Y) : (tensorRightHomEquiv _ _ _ _) ((Yᘁ) ◁ f ≫ ε_ _ _) = fᘁ ≫ (λ_ _).inv
-- Mathlib/Order/GaloisConnection.lean
theorem bddBelow_u_image {s : Set β} : BddBelow (u '' s) ↔ BddBelow s
-- Mathlib/Algebra/GeomSum.lean
@[simp]
theorem neg_one_geom_sum [Ring α] {n : ℕ} :
    ∑ i ∈ range n, (-1 : α) ^ i = if Even n then 0 else 1
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem exists_max_root [LinearOrder R] (p : R[X]) (hp : p ≠ 0) : ∃ x₀, ∀ x, p.IsRoot x → x ≤ x₀
-- Mathlib/Analysis/Calculus/MeanValue.lean
/-- Variant of the mean value inequality on a convex set. Version with `fderiv`. -/
theorem norm_image_sub_le_of_norm_fderiv_le' (hf : ∀ x ∈ s, DifferentiableAt 𝕜 f x)
    (bound : ∀ x ∈ s, ‖fderiv 𝕜 f x - φ‖ ≤ C) (hs : Convex ℝ s) (xs : x ∈ s) (ys : y ∈ s) :
    ‖f y - f x - φ (y - x)‖ ≤ C * ‖y - x‖
-- Mathlib/Data/ENNReal/Inv.lean
@[simp] theorem inv_eq_top : a⁻¹ = ∞ ↔ a = 0
-- Mathlib/Analysis/Normed/Field/Basic.lean
@[simp]
theorem nnnorm_pow (a : α) (n : ℕ) : ‖a ^ n‖₊ = ‖a‖₊ ^ n
-- Mathlib/Topology/Constructions.lean
theorem Filter.Tendsto.snd_nhds {l : Filter X} {f : X → Y × Z} {p : Y × Z}
    (h : Tendsto f l (𝓝 p)) : Tendsto (fun a ↦ (f a).2) l (𝓝 <| p.2)
-- Mathlib/Data/Setoid/Partition.lean
theorem finite_classes_ker {α β : Type*} [Finite β] (f : α → β) : (Setoid.ker f).classes.Finite
-- Mathlib/RingTheory/Polynomial/Opposites.lean
@[simp]
theorem coeff_opRingEquiv (p : R[X]ᵐᵒᵖ) (n : ℕ) :
    (opRingEquiv R p).coeff n = op ((unop p).coeff n)
-- Mathlib/Dynamics/Ergodic/MeasurePreserving.lean
theorem restrict_preimage_emb {f : α → β} (hf : MeasurePreserving f μa μb)
    (h₂ : MeasurableEmbedding f) (s : Set β) :
    MeasurePreserving f (μa.restrict (f ⁻¹' s)) (μb.restrict s)
-- Mathlib/NumberTheory/Multiplicity.lean
theorem Nat.two_pow_sub_pow {x y : ℕ} (hxy : 2 ∣ x - y) (hx : ¬2 ∣ x) {n : ℕ} (hn : Even n) :
    multiplicity 2 (x ^ n - y ^ n) + 1 =
      multiplicity 2 (x + y) + multiplicity 2 (x - y) + multiplicity 2 n
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean
theorem cos_ne_zero_iff {θ : ℂ} : cos θ ≠ 0 ↔ ∀ k : ℤ, θ ≠ (2 * k + 1) * π / 2
-- Mathlib/Control/Lawful.lean
@[simp]
theorem run_monadMap {n} [MonadFunctorT n m] (f : ∀ {α}, n α → n α) :
    (monadMap (@f) x : OptionT m α).run = monadMap (@f) x.run
-- Mathlib/Algebra/Group/Commute/Defs.lean
@[to_additive]
protected theorem semiconjBy {a b : S} (h : Commute a b) : SemiconjBy a b b
-- Mathlib/Data/Sym/Sym2.lean
@[simp]
theorem fromRel_proj_prop {sym : Symmetric r} {z : α × α} : Sym2.mk z ∈ fromRel sym ↔ r z.1 z.2
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upperCrossingTime_stabilize (hnm : n ≤ m) (hn : upperCrossingTime a b f N n ω = N) :
    upperCrossingTime a b f N m ω = N
-- Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean
/-- If you add multiples of previous rows to the next row, the determinant doesn't change. -/
theorem det_eq_of_forall_row_eq_smul_add_pred {n : ℕ} {A B : Matrix (Fin (n + 1)) (Fin (n + 1)) R}
    (c : Fin n → R) (A_zero : ∀ j, A 0 j = B 0 j)
    (A_succ : ∀ (i : Fin n) (j), A i.succ j = B i.succ j + c i * A (Fin.castSucc i) j) :
    det A = det B
-- Mathlib/CategoryTheory/Limits/Presheaf.lean
/-- The legs of the cocone `coconeOfRepresentable` are natural in the choice of presheaf. -/
theorem coconeOfRepresentable_naturality {P₁ P₂ : Cᵒᵖ ⥤ Type v₁} (α : P₁ ⟶ P₂) (j : P₁.Elementsᵒᵖ) :
    (coconeOfRepresentable P₁).ι.app j ≫ α =
      (coconeOfRepresentable P₂).ι.app ((CategoryOfElements.map α).op.obj j)
-- Mathlib/Data/List/Lattice.lean
theorem mem_of_mem_inter_left : a ∈ l₁ ∩ l₂ → a ∈ l₁
-- Mathlib/Init/Algebra/Classes.lean
theorem trans [IsTrans α r] {a b c : α} : a ≺ b → b ≺ c → a ≺ c
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
theorem IsOrtho.mono_right {U V₁ V₂ : Submodule 𝕜 E} (hV : V₂ ≤ V₁) (h : U ⟂ V₁) : U ⟂ V₂
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasFDerivWithinAt.cpow (hf : HasFDerivWithinAt f f' s x) (hg : HasFDerivWithinAt g g' s x)
    (h0 : f x ∈ slitPlane) : HasFDerivWithinAt (fun x => f x ^ g x)
      ((g x * f x ^ (g x - 1)) • f' + (f x ^ g x * Complex.log (f x)) • g') s x
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem toReal_coe_eq_self_sub_two_mul_int_mul_pi_iff {θ : ℝ} {k : ℤ} :
    (θ : Angle).toReal = θ - 2 * k * π ↔ θ ∈ Set.Ioc ((2 * k - 1 : ℝ) * π) ((2 * k + 1) * π)
-- Mathlib/Algebra/EuclideanDomain/Basic.lean
protected theorem gcd_eq_zero_iff {a b : R} : gcd a b = 0 ↔ a = 0 ∧ b = 0
-- Mathlib/Order/Bounded.lean
theorem unbounded_ge_inter_not_ge [SemilatticeInf α] (a : α) :
    Unbounded (· ≥ ·) (s ∩ { b | ¬a ≤ b }) ↔ Unbounded (· ≥ ·) s
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
@[elementwise (attr := simp)]
theorem binaryCoproductIso_inl_comp_hom (X Y : Type u) :
    Limits.coprod.inl ≫ (binaryCoproductIso X Y).hom = Sum.inl
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem ne_zero_of_mul_ne_zero_right (h : n * m ≠ 0) : m ≠ 0
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem map_inr (g : G) : map f₁ f₂ h (inr g) = inr (f₂ g)
-- Mathlib/Topology/Sequences.lean
protected theorem IsCompact.isSeqCompact {s : Set X} (hs : IsCompact s) : IsSeqCompact s
-- Mathlib/Algebra/Module/Submodule/Ker.lean
/-- The increasing sequence of submodules consisting of the kernels of the iterates of a linear map.
-/
@[simps]
def iterateKer (f : M →ₗ[R] M) : ℕ →o Submodule R M
-- Mathlib/SetTheory/Ordinal/Basic.lean
@[simp]
theorem card_nat (n : ℕ) : card.{u} n = n
-- Mathlib/Order/Antichain.lean
theorem Set.Subsingleton.isWeakAntichain (hs : s.Subsingleton) : IsWeakAntichain s
-- .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean
@[simp] theorem swap_swap (x : α ⊕ β) : swap (swap x) = x
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem descPochhammer_eq_ascPochhammer (n : ℕ) :
    descPochhammer ℤ n = (ascPochhammer ℤ n).comp ((X : ℤ[X]) - n + 1)
-- Mathlib/RingTheory/PrimeSpectrum.lean
theorem sup_vanishingIdeal_le (t t' : Set (PrimeSpectrum R)) :
    vanishingIdeal t ⊔ vanishingIdeal t' ≤ vanishingIdeal (t ∩ t')
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem Submartingale.sum_mul_upcrossingStrat_le [IsFiniteMeasure μ] (hf : Submartingale f ℱ μ) :
    μ[∑ k ∈ Finset.range n, upcrossingStrat a b f N k * (f (k + 1) - f k)] ≤ μ[f n] - μ[f 0]
-- Mathlib/MeasureTheory/Covering/Differentiation.lean
/-- As an intermediate step to show that `μ.withDensity (v.limRatioMeas hρ) = ρ`, we show here
that `ρ ≤ t μ.withDensity (v.limRatioMeas hρ)` for any `t > 1`. -/
theorem le_mul_withDensity {s : Set α} (hs : MeasurableSet s) {t : ℝ≥0} (ht : 1 < t) :
    ρ s ≤ t * μ.withDensity (v.limRatioMeas hρ) s
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem le_sup_shrink_equiv {s : Set Ordinal.{u}} (hs : Small.{u} s) (a) (ha : a ∈ s) :
    a ≤ sup.{u, u} fun x => ((@equivShrink s hs).symm x).val
-- Mathlib/Data/Set/Pointwise/Interval.lean
theorem image_add_const_Iio : (fun x => x + a) '' Iio b = Iio (b + a)
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem range_snd : range (snd R M M₂) = ⊤
-- Mathlib/Data/Part.lean
@[simp]
theorem get_some {a : α} (ha : (some a).Dom) : get (some a) ha = a
-- Mathlib/Algebra/Polynomial/Roots.lean
theorem rootSet_maps_to' {p : T[X]} {S S'} [CommRing S] [IsDomain S] [Algebra T S] [CommRing S']
    [IsDomain S'] [Algebra T S'] (hp : p.map (algebraMap T S') = 0 → p.map (algebraMap T S) = 0)
    (f : S →ₐ[T] S') : (p.rootSet S).MapsTo f (p.rootSet S')
-- Mathlib/Analysis/SpecificLimits/Normed.lean
/-- The **alternating series test** for monotone sequences. -/
theorem Monotone.tendsto_alternating_series_of_tendsto_zero (hfa : Monotone f)
    (hf0 : Tendsto f atTop (𝓝 0)) :
    ∃ l, Tendsto (fun n ↦ ∑ i ∈ range n, (-1) ^ i * f i) atTop (𝓝 l)
-- Mathlib/Analysis/Analytic/Composition.lean
/-- The first coefficient of `id 𝕜 E` is the identity. -/
@[simp]
theorem id_apply_one (v : Fin 1 → E) : (FormalMultilinearSeries.id 𝕜 E) 1 v = v 0
-- Mathlib/Analysis/Normed/Lp/PiLp.lean
theorem lipschitzWith_equiv_aux : LipschitzWith 1 (WithLp.equiv p (∀ i, β i))
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
@[simp]
theorem mkContinuousMultilinear_apply (f : MultilinearMap 𝕜 E (MultilinearMap 𝕜 E' G)) {C : ℝ}
    (H : ∀ m₁ m₂, ‖f m₁ m₂‖ ≤ (C * ∏ i, ‖m₁ i‖) * ∏ i, ‖m₂ i‖) (m : ∀ i, E i) :
    ⇑(mkContinuousMultilinear f C H m) = f m
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem TendstoUniformlyOn.div (hf : TendstoUniformlyOn f g l s)
    (hf' : TendstoUniformlyOn f' g' l s) : TendstoUniformlyOn (f / f') (g / g') l s
-- Mathlib/Topology/Algebra/Star.lean
/-- The star operation bundled as a continuous map. -/
@[simps]
def starContinuousMap : C(R, R)
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem num_denom_mul (x y : RatFunc K) :
    (x * y).num * (x.denom * y.denom) = x.num * y.num * (x * y).denom
-- Mathlib/CategoryTheory/EffectiveEpi/Comp.lean
lemma effectiveEpiFamily_of_effectiveEpi_epi_comp {α : Type*} {B : C} {X Y : α → C}
    (f : (a : α) → X a ⟶ B) (g : (a : α) → Y a ⟶ X a) [∀ a, Epi (g a)]
    [EffectiveEpiFamily _ (fun a ↦ g a ≫ f a)] : EffectiveEpiFamily _ f
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp] theorem le_ofFin (x : BitVec n) (y : Fin (2^n)) :
  x ≤ BitVec.ofFin y ↔ x.toFin ≤ y
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem nnnorm_snd (a : 𝓜(𝕜, A)) : ‖a.snd‖₊ = ‖a‖₊
-- Mathlib/Topology/Algebra/Order/Floor.lean
theorem tendsto_fract_left' [OrderClosedTopology α] [TopologicalAddGroup α] (n : ℤ) :
    Tendsto (fract : α → α) (𝓝[<] n) (𝓝 1)
-- Mathlib/LinearAlgebra/TensorProduct/Tower.lean
@[simp]
theorem assoc_tmul (m : M) (p : P) (q : Q) :
    assoc R A B M P Q ((m ⊗ₜ p) ⊗ₜ q) = m ⊗ₜ (p ⊗ₜ q)
-- Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean
/-- Assumes right covariance.
The lemma assuming left covariance is `Left.one_lt_mul`. -/
@[to_additive Right.add_pos "Assumes right covariance.
The lemma assuming left covariance is `Left.add_pos`."]
theorem Right.one_lt_mul [CovariantClass α α (swap (· * ·)) (· < ·)] {a b : α} (ha : 1 < a)
    (hb : 1 < b) :
    1 < a * b
-- Mathlib/Data/Matrix/RowCol.lean
theorem col_vecMul [Fintype m] [NonUnitalNonAssocSemiring α] (M : Matrix m n α) (v : m → α) :
    Matrix.col ι (v ᵥ* M) = (Matrix.row ι v * M)ᵀ
-- Mathlib/Order/Monotone/Monovary.lean
theorem AntivaryOn.comp_monotone_on_left (h : AntivaryOn f g s) (hf : Monotone f') :
    AntivaryOn (f' ∘ f) g s
-- Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean
/-- Shows that the integer parts of the stream are at least one. -/
theorem one_le_succ_nth_stream_b {ifp_succ_n : IntFractPair K}
    (succ_nth_stream_eq : IntFractPair.stream v (n + 1) = some ifp_succ_n) : 1 ≤ ifp_succ_n.b
-- Mathlib/Data/Sum/Interval.lean
@[simp]
theorem Ico_inl_inr : Ico (inl a₁) (inr b₂) = ∅
-- Mathlib/AlgebraicTopology/SplitSimplicialObject.lean
/-- The functor `SimplicialObject.Split C ⥤ C` which sends a simplicial object equipped
with a splitting to its nondegenerate `n`-simplices. -/
@[simps]
def evalN (n : ℕ) : Split C ⥤ C
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
/-- Consider a real set `s`. If a property is true almost everywhere in `s ∩ (a, b)` for
all `a, b ∈ s`, then it is true almost everywhere in `s`. Formulated with bare membership.
See also `ae_restrict_of_ae_restrict_inter_Ioo`. -/
theorem ae_of_mem_of_ae_of_mem_inter_Ioo {μ : Measure ℝ} [NoAtoms μ] {s : Set ℝ} {p : ℝ → Prop}
    (h : ∀ a b, a ∈ s → b ∈ s → a < b → ∀ᵐ x ∂μ, x ∈ s ∩ Ioo a b → p x) :
    ∀ᵐ x ∂μ, x ∈ s → p x
-- Mathlib/LinearAlgebra/Determinant.lean
/-- The determinants of a `LinearEquiv` and its inverse multiply to 1. -/
@[simp]
theorem LinearEquiv.det_symm_mul_det {A : Type*} [CommRing A] [Module A M] (f : M ≃ₗ[A] M) :
    LinearMap.det (f.symm : M →ₗ[A] M) * LinearMap.det (f : M →ₗ[A] M) = 1
-- Mathlib/SetTheory/Game/Basic.lean
/-- `x * y * z` is equivalent to `x * (y * z).`-/
theorem mul_assoc_equiv (x y z : PGame) : x * y * z ≈ x * (y * z)
-- Mathlib/Data/DFinsupp/Basic.lean
@[simp]
theorem extendWith_single_zero [DecidableEq ι] [∀ i, Zero (α i)] (i : ι) (x : α (some i)) :
    (single i x).extendWith 0 = single (some i) x
-- Mathlib/Order/WellFoundedSet.lean
@[simp]
protected theorem wellFoundedOn [IsStrictOrder α r] (s : Finset α) :
    Set.WellFoundedOn (↑s : Set α) r
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem existsNatOneDivLTMeasure_of_not_negative (hi : ¬s ≤[i] 0) :
    ∃ n : ℕ, ExistsOneDivLT s i n
-- Mathlib/Topology/Separation.lean
theorem isOpen_ne_fun [T2Space X] {f g : Y → X} (hf : Continuous f) (hg : Continuous g) :
    IsOpen { y : Y | f y ≠ g y }
-- Mathlib/Order/Interval/Set/OrderEmbedding.lean
@[simp] theorem preimage_Icc : e ⁻¹' Icc (e x) (e y) = Icc x y
-- Mathlib/CategoryTheory/Limits/Shapes/SplitEqualizer.lean
/--
The pair `f,g` is a cosplit pair if there is an `h : W ⟶ X` so that `f, g, h` forms a split
equalizer in `C`.
-/
class HasSplitEqualizer : Prop where
  /-- There is some split equalizer -/
  splittable : ∃ (W : C) (h : W ⟶ X), Nonempty (IsSplitEqualizer f g h)
-- Mathlib/Algebra/Order/Archimedean.lean
/-- Every x greater than or equal to 1 is between two successive
natural-number powers of every y greater than one. -/
theorem exists_nat_pow_near (hx : 1 ≤ x) (hy : 1 < y) : ∃ n : ℕ, y ^ n ≤ x ∧ x < y ^ (n + 1)
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem adjugate_mul (A : Matrix n n α) : adjugate A * A = A.det • (1 : Matrix n n α)
-- Mathlib/Data/Real/Pi/Bounds.lean
theorem pi_gt_314 : 3.14 < π
-- Mathlib/CategoryTheory/Limits/Opposites.lean
/-- The canonical isomorphism relating `(Span f g).op` and `Cospan f.op g.op` -/
@[simps!]
def opSpan {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) :
    (span f g).op ≅ walkingSpanOpEquiv.functor ⋙ cospan f.op g.op
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
protected theorem Measurable.piecewise {_ : DecidablePred (· ∈ s)} (hs : MeasurableSet s)
    (hf : Measurable f) (hg : Measurable g) : Measurable (piecewise s f g)
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[ext]
theorem prod_ext {f g : M × N₂ →L[R] N₃} (hl : f.comp (inl _ _ _) = g.comp (inl _ _ _))
    (hr : f.comp (inr _ _ _) = g.comp (inr _ _ _)) : f = g
-- Mathlib/Topology/MetricSpace/Gluing.lean
theorem glueDist_swap (Φ : Z → X) (Ψ : Z → Y) (ε : ℝ) :
    ∀ x y, glueDist Ψ Φ ε x.swap y.swap = glueDist Φ Ψ ε x y
-- Mathlib/Algebra/FreeMonoid/Count.lean
theorem countP_apply (l : FreeAddMonoid α) : countP p l = List.countP p l
-- Mathlib/Topology/ContinuousOn.lean
@[fun_prop]
theorem ContinuousOn.comp'' {g : β → γ} {f : α → β} {s : Set α} {t : Set β} (hg : ContinuousOn g t)
    (hf : ContinuousOn f s) (h : Set.MapsTo f s t) : ContinuousOn (fun x => g (f x)) s
-- Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean
/-- An upper estimate on the remainder. This estimate works with `m ∈ ℝ` satisfying `2 ≤ m` and is
weaker than the estimate `LiouvilleNumber.remainder_lt'` above. However, this estimate is
more useful for the proof. -/
theorem remainder_lt (n : ℕ) {m : ℝ} (m2 : 2 ≤ m) : remainder m n < 1 / (m ^ n !) ^ n
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
@[simp]
theorem map_objs_eq (hφ : Function.Injective φ.obj) : (map φ hφ S).objs = φ.obj '' S.objs
-- Mathlib/Algebra/EuclideanDomain/Defs.lean
@[simp]
theorem xgcd_zero_left {s t r' s' t' : R} : xgcdAux 0 s t r' s' t' = (r', s', t')
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
theorem le_of_succ_le {n m : Nat} (h : succ n ≤ m) : n ≤ m
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem BinaryBiproduct.bicone_fst : (BinaryBiproduct.bicone X Y).fst = biprod.fst
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
@[simp] lemma hasLineDerivWithinAt_univ :
    HasLineDerivWithinAt 𝕜 f f' univ x v ↔ HasLineDerivAt 𝕜 f f' x v
-- Mathlib/Algebra/Algebra/Bilinear.lean
theorem commute_mulLeft_right (a b : A) : Commute (mulLeft R a) (mulRight R b)
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
protected theorem single_apply_ne (p) (i : α) (a : E i) {j : α} (hij : j ≠ i) :
    lp.single p i a j = 0
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
theorem IsIntegral.of_mem_closure'' {S : Type*} [CommRing S] {f : R →+* S} (G : Set S)
    (hG : ∀ x ∈ G, f.IsIntegralElem x) : ∀ x ∈ Subring.closure G, f.IsIntegralElem x
-- Mathlib/Init/Algebra/Classes.lean
@[elab_without_expected_type]
theorem incomp_trans_of [IsIncompTrans α r] {a b c : α} :
    ¬a ≺ b ∧ ¬b ≺ a → ¬b ≺ c ∧ ¬c ≺ b → ¬a ≺ c ∧ ¬c ≺ a
-- Mathlib/Logic/Basic.lean
theorem Fact.elim {p : Prop} (h : Fact p) : p