ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Multiset/Nodup.lean
theorem Nodup.inter_left [DecidableEq α] (t) : Nodup s → Nodup (s ∩ t)
-- Mathlib/Algebra/DirectSum/Module.lean
@[simp]
theorem sigmaLuncurry_apply (f : ⨁ (i) (j), δ i j) (i : ι) (j : α i) :
    sigmaLuncurry R f ⟨i, j⟩ = f i j
-- Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean
/-- Applying `secondInter` twice returns the original point. -/
@[simp]
theorem Sphere.secondInter_secondInter (s : Sphere P) (p : P) (v : V) :
    s.secondInter (s.secondInter p v) v = p
-- Mathlib/Algebra/Order/Interval/Finset.lean
@[simp] lemma image_add_left_Ico (a b c : α) : (Ico a b).image (c + ·) = Ico (c + a) (c + b)
-- Mathlib/Data/Multiset/Dedup.lean
theorem Multiset.Nodup.le_nsmul_iff_le {α : Type*} {s t : Multiset α} {n : ℕ} (h : s.Nodup)
    (hn : n ≠ 0) : s ≤ n • t ↔ s ≤ t
-- Mathlib/Data/Fin/Tuple/Basic.lean
@[simp]
theorem snoc_comp_castSucc {n : ℕ} {α : Sort _} {a : α} {f : Fin n → α} :
    (snoc f a : Fin (n + 1) → α) ∘ castSucc = f
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
/-- The Hurwitz zeta function is differentiable everywhere except at `s = 1`. This is true
even in the delicate case `a = 0` and `s = 0` (where the completed zeta has a pole, but this is
cancelled out by the Gamma factor). -/
lemma differentiableAt_hurwitzZetaEven (a : UnitAddCircle) {s : ℂ} (hs' : s ≠ 1) :
    DifferentiableAt ℂ (hurwitzZetaEven a) s
-- Mathlib/Algebra/Order/Monoid/Unbundled/WithTop.lean
@[simp] lemma coe_ofNat (n : ℕ) [n.AtLeastTwo] :
    (no_index (OfNat.ofNat n : α) : WithTop α) = OfNat.ofNat n
-- Mathlib/Algebra/Polynomial/DenomsClearable.lean
theorem denomsClearable_of_natDegree_le (N : ℕ) (a : R) (bu : bi * i b = 1) :
    ∀ f : R[X], f.natDegree ≤ N → DenomsClearable a b N f i
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem mem_nonUnitalSubalgebraOfNonUnitalSubsemiring {x : R} {S : NonUnitalSubsemiring R} :
    x ∈ nonUnitalSubalgebraOfNonUnitalSubsemiring S ↔ x ∈ S
-- Mathlib/Data/Set/Function.lean
theorem BijOn.congr (h₁ : BijOn f₁ s t) (h : EqOn f₁ f₂ s) : BijOn f₂ s t
-- Mathlib/Order/OmegaCompletePartialOrder.lean
@[simp] theorem map_coe : ⇑(map c f) = f ∘ c
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_add_pi (x : ℂ) : sin (x + π) = -sin x
-- Mathlib/Algebra/Order/Sub/Canonical.lean
protected theorem tsub_lt_tsub_left_of_le (hab : AddLECancellable (a - b)) (h₁ : b ≤ a)
    (h : c < b) : a - b < a - c
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem rotateRight_nil : ([] : List α).rotateRight n = []
-- Mathlib/RingTheory/Norm/Basic.lean
@[simp]
theorem norm_eq_zero_iff [IsDomain R] [IsDomain S] [Module.Free R S] [Module.Finite R S] {x : S} :
    norm R x = 0 ↔ x = 0
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
@[simp] theorem forgetMonoidal_μ (X Y : Comon_ C) : (forgetMonoidal C).μ X Y = 𝟙 (X.X ⊗ Y.X)
-- Mathlib/GroupTheory/HNNExtension.lean
@[simp]
theorem prod_group_smul (g : G) (w : NormalWord d) :
    (g • w).prod φ = of g * (w.prod φ)
-- Mathlib/Data/List/Chain.lean
theorem Chain'.init (h : Chain' R l) : Chain' R l.dropLast
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_inf_distrib_left (f : ι → α) (a : α) :
    a ⊓ s.sup' hs f = s.sup' hs fun i ↦ a ⊓ f i
-- Mathlib/Order/Hom/Lattice.lean
theorem toFun_eq_coe (f : InfTopHom α β) : f.toFun = f
-- Mathlib/Algebra/Polynomial/Basic.lean
@[simp]
theorem coeff_inj : p.coeff = q.coeff ↔ p = q
-- Mathlib/CategoryTheory/Localization/Equivalence.lean
/-- Basic constructor of an equivalence between localized categories -/
lemma isEquivalence : G'.IsEquivalence
-- Mathlib/ModelTheory/Graph.lean
@[simp]
theorem _root_.SimpleGraph.simpleGraphOfStructure (G : SimpleGraph V) :
    @simpleGraphOfStructure V G.structure _ = G
-- Mathlib/Topology/UniformSpace/AbstractCompletion.lean
theorem uniformContinuous_compare : UniformContinuous (pkg.compare pkg')
-- Mathlib/Order/RelSeries.lean
lemma length_le_length_longestOf [r.FiniteDimensional] (x : RelSeries r) :
    x.length ≤ (RelSeries.longestOf r).length
-- Mathlib/RepresentationTheory/Basic.lean
/-- If we equip `k[G]` with the `k`-linear `G`-representation induced by the left regular action of
`G` on itself, the resulting object is isomorphic as a `k[G]`-module to `k[G]` with its natural
`k[G]`-module structure. -/
@[simps]
noncomputable def ofMulActionSelfAsModuleEquiv :
    (ofMulAction k G G).asModule ≃ₗ[MonoidAlgebra k G] MonoidAlgebra k G
-- Mathlib/Combinatorics/Pigeonhole.lean
/-- The pigeonhole principle for finitely many pigeons counted by heads: there is a pigeonhole with
at least as many pigeons as the ceiling of the average number of pigeons across all pigeonholes. -/
theorem exists_lt_card_fiber_of_nsmul_lt_card_of_maps_to (hf : ∀ a ∈ s, f a ∈ t)
    (ht : t.card • b < s.card) : ∃ y ∈ t, b < (s.filter fun x => f x = y).card
-- Mathlib/Order/Interval/Set/Basic.lean
@[simp]
theorem Iio_subset_Iic_iff [DenselyOrdered α] : Iio a ⊆ Iic b ↔ a ≤ b
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem toLex_lt_toLex [LT α] [LT β] {a b : α ⊕ β} :
    toLex a < toLex b ↔ Lex (· < ·) (· < ·) a b
-- Mathlib/Order/LiminfLimsup.lean
theorem limsup_eq_iInf_iSup_of_nat {u : ℕ → α} : limsup u atTop = ⨅ n : ℕ, ⨆ i ≥ n, u i
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem modifyNth_zero_cons (f : α → α) (a : α) (l : List α) :
    (a :: l).modifyNth f 0 = f a :: l
-- Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean
/-- Implementation of `SheafConditionPairwiseIntersections.coneEquiv`. -/
@[simps]
def coneEquivInverseObj (c : Limits.Cone (SheafConditionEqualizerProducts.diagram F U)) :
    Limits.Cone ((diagram U).op ⋙ F)
-- Mathlib/CategoryTheory/Bicategory/Kan/IsKan.lean
@[simp]
theorem uniqueUpToIso_inv_right (P : IsKan s) (Q : IsKan t) :
    (uniqueUpToIso P Q).inv.right = Q.desc s
-- Mathlib/Order/UpperLower/Basic.lean
protected theorem compl_top : (⊤ : LowerSet α).compl = ⊤
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
/-- If a function has a Taylor series at order at least `1`, then the term of order `1` of this
series is a derivative of `f`. -/
theorem HasFTaylorSeriesUpTo.hasFDerivAt (h : HasFTaylorSeriesUpTo n f p) (hn : 1 ≤ n) (x : E) :
    HasFDerivAt f (continuousMultilinearCurryFin1 𝕜 E F (p x 1)) x
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem volume_preserving_finTwoArrow (α : Type u) [MeasureSpace α]
    [SigmaFinite (volume : Measure α)] :
    MeasurePreserving (@MeasurableEquiv.finTwoArrow α _) volume volume
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
theorem _root_.lipschitzWith_max : LipschitzWith 1 fun p : ℝ × ℝ => max p.1 p.2
-- Mathlib/Order/RelIso/Basic.lean
protected theorem bijective (e : r ≃r s) : Bijective e
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem continuousWithinAt (e : M₁ ≃SL[σ₁₂] M₂) {s : Set M₁} {x : M₁} :
    ContinuousWithinAt (e : M₁ → M₂) s x
-- Mathlib/Data/Countable/Basic.lean
lemma Sigma.uncountable (a : α) [Uncountable (π a)] : Uncountable (Sigma π)
-- Mathlib/Data/PFun.lean
theorem preimage_subset_dom (s : Set β) : f.preimage s ⊆ f.Dom
-- Mathlib/Topology/MetricSpace/Dilation.lean
@[simp]
theorem coe_mul (f g : α →ᵈ α) : ⇑(f * g) = f ∘ g
-- Mathlib/Order/Interval/Finset/Basic.lean
@[simp]
theorem Ioo_filter_lt (a b c : α) : (Ioo a b).filter (· < c) = Ioo a (min b c)
-- Mathlib/Analysis/Normed/Operator/LinearIsometry.lean
theorem mul_def (f g : E →ₗᵢ[R] E) : (f * g : E →ₗᵢ[R] E) = f.comp g
-- Mathlib/Analysis/Convex/StrictConvexSpace.lean
theorem StrictConvexSpace.of_norm_add_ne_two
    (h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2) : StrictConvexSpace ℝ E
-- Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean
/-- Three points are collinear if and only if they are not affinely independent. -/
theorem collinear_iff_not_affineIndependent_set {p₁ p₂ p₃ : P} :
    Collinear k ({p₁, p₂, p₃} : Set P) ↔ ¬AffineIndependent k ![p₁, p₂, p₃]
-- Mathlib/Algebra/Polynomial/BigOperators.lean
/-- The leading coefficient of a product of polynomials is equal to
the product of the leading coefficients, provided that this product is nonzero.

See `Polynomial.leadingCoeff_prod` (without the `'`) for a version for integral domains,
where this condition is automatically satisfied.
-/
theorem leadingCoeff_prod' (h : (∏ i ∈ s, (f i).leadingCoeff) ≠ 0) :
    (∏ i ∈ s, f i).leadingCoeff = ∏ i ∈ s, (f i).leadingCoeff
-- Mathlib/Algebra/Module/LocalizedModule.lean
private theorem mul_smul_aux (x y : T) (p : LocalizedModule S M) :
    (x * y) • p = x • y • p
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_self_eq_norm_sq_to_K (x : E) : ⟪x, x⟫ = (‖x‖ : 𝕜) ^ 2
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma Y_sub_polynomialY : Y - W.polynomialY = W.negPolynomial
-- Mathlib/Data/Fintype/Basic.lean
@[simp]
theorem Finset.univ_eq_attach {α : Type u} (s : Finset α) : (univ : Finset s) = s.attach
-- Mathlib/MeasureTheory/Measure/FiniteMeasureProd.lean
/-- The second marginal of a product probability measure is the second probability measure. -/
@[simp] lemma map_snd_prod : (μ.prod ν).map measurable_snd.aemeasurable = ν
-- Mathlib/LinearAlgebra/LinearPMap.lean
@[simp]
theorem toFun_eq_coe (f : E →ₗ.[R] F) (x : f.domain) : f.toFun x = f x
-- Mathlib/Data/Matroid/Restrict.lean
theorem basis_restrict_iff (hR : R ⊆ M.E := by aesop_mat) :
    (M ↾ R).Basis I X ↔ M.Basis I X ∧ X ⊆ R
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
@[simp]
theorem apply_one [DecidableEq E] (x : E) : (1 : AddGroupSeminorm E) x = if x = 0 then 0 else 1
-- Mathlib/Order/Directed.lean
theorem directedOn_singleton (h : Reflexive r) (a : α) : DirectedOn r ({a} : Set α)
-- Mathlib/Analysis/Complex/RealDeriv.lean
/-- If a complex function is differentiable at a real point, then the induced real function is also
differentiable at this point, with a derivative equal to the real part of the complex derivative. -/
theorem HasStrictDerivAt.real_of_complex (h : HasStrictDerivAt e e' z) :
    HasStrictDerivAt (fun x : ℝ => (e x).re) e'.re z
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma d_pOpcycles [K.HasHomology j] : K.d i j ≫ K.pOpcycles j = 0
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
@[simp]
theorem mk_toOrderHom {a b : SimplexCategory} (f : SimplexCategory.Hom a b) : mk f.toOrderHom = f
-- Mathlib/GroupTheory/Coset.lean
/-- If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
of the quotient map `G → G/K`. The classical version is `Subgroup.quotientEquivProdOfLE`. -/
@[to_additive (attr := simps)
  "If `H ≤ K`, then `G/H ≃ G/K × K/H` constructively, using the provided right inverse
  of the quotient map `G → G/K`. The classical version is `AddSubgroup.quotientEquivSumOfLE`."]
def quotientEquivProdOfLE' (h_le : s ≤ t) (f : α ⧸ t → α)
    (hf : Function.RightInverse f QuotientGroup.mk) : α ⧸ s ≃ (α ⧸ t) × t ⧸ s.subgroupOf t
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem commute_add_nat (n : ℕ) : Function.Commute f (· + n)
-- Mathlib/ModelTheory/Substructures.lean
theorem map_sup_comap_of_surjective (S T : L.Substructure N) :
    (S.comap f ⊔ T.comap f).map f = S ⊔ T
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
theorem pow_fst (n : ℕ) (a : 𝓜(𝕜, A)) : (a ^ n).fst = a.fst ^ n
-- Mathlib/SetTheory/Game/PGame.lean
theorem _root_.LE.le.not_gf {x y : PGame} : x ≤ y → ¬y ⧏ x
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- The infimum edistance is invariant under isometries -/
theorem infEdist_image (hΦ : Isometry Φ) : infEdist (Φ x) (Φ '' t) = infEdist x t
-- Mathlib/SetTheory/Cardinal/Finite.lean
lemma card_image_le {f : α → β} (hs : s.Finite) : Nat.card (f '' s) ≤ Nat.card s
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem uniformity_eq_comap_nhds_one' : 𝓤 G = comap (fun p : G × G => p.2 / p.1) (𝓝 (1 : G))
-- Mathlib/Geometry/Manifold/ContMDiff/Product.lean
theorem contMDiffAt_snd {p : M × N} : ContMDiffAt (I.prod J) J n Prod.snd p
-- Mathlib/Order/Hom/Bounded.lean
/-- Reinterpret a bounded order homomorphism as a bounded order homomorphism between the dual
orders. -/
@[simps]
protected def dual :
    BoundedOrderHom α β ≃
      BoundedOrderHom αᵒᵈ
        βᵒᵈ
-- Mathlib/FieldTheory/Adjoin.lean
@[simp]
theorem botEquiv_symm (x : F) : (botEquiv F E).symm x = algebraMap F _ x
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
/-- `canonicalEquiv f f'` is the canonical equivalence between the fractional
ideals in `P` and in `P'`, which are both localizations of `R` at `S`. -/
noncomputable irreducible_def canonicalEquiv : FractionalIdeal S P ≃+* FractionalIdeal S P'
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem set_smul_subset_iff₀ (ha : a ≠ 0) {A B : Set β} : a • A ⊆ B ↔ A ⊆ a⁻¹ • B
-- Mathlib/Order/CompleteSublattice.lean
@[simp] theorem coe_sSup (S : Set L) : (↑(sSup S) : α) = sSup {(s : α) | s ∈ S}
-- Mathlib/CategoryTheory/Limits/Elements.lean
@[simp]
lemma π_liftedConeElement' (i : I) :
    limit.π ((F ⋙ π A) ⋙ A) i (liftedConeElement' F) = (F.obj i).2
-- Mathlib/Order/Interval/Multiset.lean
theorem card_Ioo_eq_card_Ico_sub_one (a b : α) : card (Ioo a b) = card (Ico a b) - 1
-- Mathlib/LinearAlgebra/Matrix/Basis.lean
theorem toMatrix_eq_toMatrix_constr [Fintype ι] [DecidableEq ι] (v : ι → M) :
    e.toMatrix v = LinearMap.toMatrix e e (e.constr ℕ v)
-- Mathlib/Algebra/Lie/Nilpotent.lean
@[simp]
lemma lcs_sup {N₁ N₂ : LieSubmodule R L M} {k : ℕ} :
    (N₁ ⊔ N₂).lcs k = N₁.lcs k ⊔ N₂.lcs k
-- Mathlib/Algebra/BigOperators/Finprod.lean
@[to_additive]
theorem finprod_cond_eq_prod_of_cond_iff (f : α → M) {p : α → Prop} {t : Finset α}
    (h : ∀ {x}, f x ≠ 1 → (p x ↔ x ∈ t)) : (∏ᶠ (i) (_ : p i), f i) = ∏ i ∈ t, f i
-- Mathlib/Data/List/Basic.lean
theorem modifyLast_append_one (f : α → α) (a : α) (l : List α) :
    modifyLast f (l ++ [a]) = l ++ [f a]
-- Mathlib/FieldTheory/PurelyInseparable.lean
/-- If `E / F` is an algebraic extension, `F` is separably closed,
then `E` is also separably closed. -/
theorem Algebra.IsAlgebraic.isSepClosed [Algebra.IsAlgebraic F E]
    [IsSepClosed F] : IsSepClosed E
-- Mathlib/Data/PNat/Defs.lean
theorem mod_coe (m k : ℕ+) :
    (mod m k : ℕ) = ite ((m : ℕ) % (k : ℕ) = 0) (k : ℕ) ((m : ℕ) % (k : ℕ))
-- Mathlib/Topology/EMetricSpace/Lipschitz.lean
/-- If `f` and `g` are Lipschitz functions, so is the induced map `f × g` to the product type. -/
protected theorem prod {f : α → β} {Kf : ℝ≥0} (hf : LipschitzWith Kf f) {g : α → γ} {Kg : ℝ≥0}
    (hg : LipschitzWith Kg g) : LipschitzWith (max Kf Kg) fun x => (f x, g x)
-- Mathlib/GroupTheory/SemidirectProduct.lean
@[simp]
theorem lift_inr (g : G) : lift f₁ f₂ h (inr g) = f₂ g
-- Mathlib/FieldTheory/SplittingField/Construction.lean
theorem irreducible_factor (f : K[X]) : Irreducible (factor f)
-- Mathlib/Data/Finset/MulAntidiagonal.lean
@[to_additive]
theorem isPWO_support_mulAntidiagonal : { a | (mulAntidiagonal hs ht a).Nonempty }.IsPWO
-- Mathlib/Init/Logic.lean
theorem if_ctx_congr {α : Sort u} {b c : Prop} [dec_b : Decidable b] [dec_c : Decidable c]
    {x y u v : α} (h_c : b ↔ c) (h_t : c → x = u) (h_e : ¬c → y = v) : ite b x y = ite c u v
-- Mathlib/Data/Set/Basic.lean
theorem antitone_setOf [Preorder α] {p : α → β → Prop} (hp : ∀ b, Antitone fun a => p a b) :
    Antitone fun a => { b | p a b }
-- Mathlib/RingTheory/LocalRing/ResidueField/Basic.lean
theorem map_comp_residue (f : R →+* S) [IsLocalRingHom f] :
    (ResidueField.map f).comp (residue R) = (residue S).comp f
-- Mathlib/Data/Finset/Basic.lean
theorem mem_of_subset {s₁ s₂ : Finset α} {a : α} : s₁ ⊆ s₂ → a ∈ s₁ → a ∈ s₂
-- Mathlib/Dynamics/Ergodic/MeasurePreserving.lean
theorem measurePreserving_symm (μ : Measure α) (e : α ≃ᵐ β) :
    MeasurePreserving e.symm (map e μ) μ
-- Mathlib/Data/Num/Lemmas.lean
theorem one_sub' (a : PosNum) : sub' 1 a = (pred' a).toZNumNeg
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem floor_nat_add (n : ℕ) (a : α) : ⌊↑n + a⌋ = n + ⌊a⌋
-- Mathlib/Order/SuccPred/CompleteLinearOrder.lean
lemma IsLUB.mem_of_nonempty_of_not_isSuccLimit
    (hs : IsLUB s x) (hne : s.Nonempty) (hx : ¬ IsSuccLimit x) : x ∈ s
-- Mathlib/RingTheory/Polynomial/Basic.lean
theorem _root_.Polynomial.ker_mapRingHom (f : R →+* S) :
    LinearMap.ker (Polynomial.mapRingHom f).toSemilinearMap = f.ker.map (C : R →+* R[X])
-- Mathlib/LinearAlgebra/Matrix/Adjugate.lean
theorem adjugate_transpose (A : Matrix n n α) : (adjugate A)ᵀ = adjugate Aᵀ
-- Mathlib/Algebra/Homology/Homotopy.lean
@[simp]
theorem nullHomotopicMap_f_eq_zero {k₀ : ι} (hk₀ : ∀ l : ι, ¬c.Rel k₀ l)
    (hk₀' : ∀ l : ι, ¬c.Rel l k₀) (hom : ∀ i j, C.X i ⟶ D.X j) :
    (nullHomotopicMap hom).f k₀ = 0
-- Mathlib/Order/UpperLower/Basic.lean
lemma lowerClosure_sup_sdiff (hts : t ⊆ s) (hst : ∀ b ∈ s, ∀ c ∈ t, c ≤ b → b ∈ t) :
    lowerClosure t ⊔ s.sdiff t = s
-- Mathlib/Topology/Basic.lean
@[simp]
theorem closure_empty_iff (s : Set X) : closure s = ∅ ↔ s = ∅
-- Mathlib/Topology/ContinuousFunction/ContinuousMapZero.lean
/-- The functor `C(·, R)₀` from topological spaces with zero (and `ContinuousMapZero` maps) to
non-unital star algebras. -/
@[simps]
def nonUnitalStarAlgHom_precomp (f : C(X, Y)₀) : C(Y, R)₀ →⋆ₙₐ[R] C(X, R)₀
-- Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean
@[ext 1100]
theorem prod.hom_ext {W X Y : C} [HasBinaryProduct X Y] {f g : W ⟶ X ⨯ Y}
    (h₁ : f ≫ prod.fst = g ≫ prod.fst) (h₂ : f ≫ prod.snd = g ≫ prod.snd) : f = g
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
theorem vsub_midpoint (p₁ p₂ p : P) :
    p -ᵥ midpoint R p₁ p₂ = (⅟ 2 : R) • (p -ᵥ p₁) + (⅟ 2 : R) • (p -ᵥ p₂)
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive] lemma prod_range_succ (f : ℕ → M) (n : ℕ) :
    ((range n.succ).map f).prod = ((range n).map f).prod * f n
-- Mathlib/AlgebraicGeometry/Morphisms/QuasiSeparated.lean
theorem exists_eq_pow_mul_of_isAffineOpen (X : Scheme) (U : X.Opens) (hU : IsAffineOpen U)
    (f : Γ(X, U)) (x : Γ(X, X.basicOpen f)) :
    ∃ (n : ℕ) (y : Γ(X, U)), y |_ X.basicOpen f = (f |_ X.basicOpen f) ^ n * x
-- Mathlib/Data/Finset/NoncommProd.lean
@[to_additive]
theorem _root_.MonoidHom.pi_ext [Finite ι] [DecidableEq ι] {f g : (∀ i, M i) →* γ}
    (h : ∀ i x, f (Pi.mulSingle i x) = g (Pi.mulSingle i x)) : f = g
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
/-- The graph of a measurable function is a measurable set. -/
theorem measurableSet_graph (hf : Measurable f) :
    MeasurableSet { p : α × ℝ | p.snd = f p.fst }
-- Mathlib/FieldTheory/SplittingField/Construction.lean
theorem natDegree_removeFactor (f : K[X]) : f.removeFactor.natDegree = f.natDegree - 1
-- Mathlib/Topology/MetricSpace/Bounded.lean
/-- An unbounded set has zero diameter. If you would prefer to get the value ∞, use `EMetric.diam`.
This lemma makes it possible to avoid side conditions in some situations -/
theorem diam_eq_zero_of_unbounded (h : ¬IsBounded s) : diam s = 0
-- Mathlib/CategoryTheory/Monoidal/Category.lean
@[simp]
theorem prodMonoidal_rightUnitor_hom_snd (X : C₁ × C₂) :
    ((ρ_ X).hom : X ⊗ 𝟙_ _ ⟶ X).2 = (ρ_ X.2).hom
-- Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean
@[simp]
theorem mem_disjUnion (h : Disjoint π₁.iUnion π₂.iUnion) :
    J ∈ π₁.disjUnion π₂ h ↔ J ∈ π₁ ∨ J ∈ π₂
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp/Kernels.lean
@[simp]
theorem explicitCokernelDesc_zero {X Y Z : SemiNormedGrp.{u}} {f : X ⟶ Y} :
    explicitCokernelDesc (show f ≫ (0 : Y ⟶ Z) = 0 from CategoryTheory.Limits.comp_zero) = 0
-- Mathlib/Topology/Basic.lean
/-- `x` is an accumulation point of a set `C` iff it is a cluster point of `C ∖ {x}`. -/
theorem acc_principal_iff_cluster (x : X) (C : Set X) :
    AccPt x (𝓟 C) ↔ ClusterPt x (𝓟 (C \ {x}))
-- Mathlib/Data/Set/Countable.lean
protected theorem Countable.prod {s : Set α} {t : Set β} (hs : s.Countable) (ht : t.Countable) :
    Set.Countable (s ×ˢ t)
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
/-- The generic case of the first simplicial identity -/
theorem δ_comp_δ {n} {i j : Fin (n + 2)} (H : i ≤ j) :
    δ i ≫ δ j.succ = δ j ≫ δ (Fin.castSucc i)
-- Mathlib/Data/Multiset/FinsetOps.lean
theorem ndinter_le_left (s t : Multiset α) : ndinter s t ≤ s
-- Mathlib/Data/Finset/PiInduction.lean
/-- General theorem for `Finset.induction_on_pi`-style induction principles. -/
theorem induction_on_pi_of_choice (r : ∀ i, α i → Finset (α i) → Prop)
    (H_ex : ∀ (i) (s : Finset (α i)), s.Nonempty → ∃ x ∈ s, r i x (s.erase x))
    {p : (∀ i, Finset (α i)) → Prop} (f : ∀ i, Finset (α i)) (h0 : p fun _ ↦ ∅)
    (step :
      ∀ (g : ∀ i, Finset (α i)) (i : ι) (x : α i),
        r i x (g i) → p g → p (update g i (insert x (g i)))) :
    p f
-- Mathlib/Tactic/Zify.lean
@[zify_simps] lemma natCast_dvd (a b : Nat) : a ∣ b ↔ (a : Int) ∣ (b : Int)
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
@[to_additive]
theorem mem_sup {s t : Submonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x
-- Mathlib/Algebra/Lie/Basic.lean
/-- A Lie module may be pulled back along a morphism of Lie algebras. -/
theorem LieModule.compLieHom [Module R M] [LieModule R L₂ M] :
    @LieModule R L₁ M _ _ _ _ _ (LieRingModule.compLieHom M f)
-- Mathlib/Analysis/Calculus/BumpFunction/FiniteDimension.lean
theorem w_integral {D : ℝ} (Dpos : 0 < D) : ∫ x : E, w D x ∂μ = 1
-- Mathlib/Combinatorics/SetFamily/Compression/UV.lean
/-- UV-compression reduces the size of the shadow of `𝒜` if, for all `x ∈ u` there is `y ∈ v`
such that `𝒜` is `(u.erase x, v.erase y)`-compressed. This is the key UV-compression fact needed for
Kruskal-Katona. -/
theorem card_shadow_compression_le (u v : Finset α)
    (huv : ∀ x ∈ u, ∃ y ∈ v, IsCompressed (u.erase x) (v.erase y) 𝒜) :
    (∂ (𝓒 u v 𝒜)).card ≤ (∂ 𝒜).card
-- Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
theorem const_smul {f : X → Y} {x : X} {c : ℝ} (hc : c ≠ 0) (hf : ConformalAt f x) :
    ConformalAt (c • f) x
-- Mathlib/Topology/Homotopy/Basic.lean
theorem symm_bijective {f₀ f₁ : C(X, Y)} :
    Function.Bijective (Homotopy.symm : Homotopy f₀ f₁ → Homotopy f₁ f₀)
-- Mathlib/Geometry/RingedSpace/Stalks.lean
@[simp]
theorem comp {X Y Z : PresheafedSpace.{_, _, v} C} (α : X ⟶ Y) (β : Y ⟶ Z) (x : X) :
    (α ≫ β).stalkMap x =
      (β.stalkMap (α.base x) : Z.presheaf.stalk (β.base (α.base x)) ⟶ Y.presheaf.stalk (α.base x)) ≫
        (α.stalkMap x : Y.presheaf.stalk (α.base x) ⟶ X.presheaf.stalk x)
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem LinearMap.toMatrix₂_symm :
    (LinearMap.toMatrix₂ b₁ b₂).symm = Matrix.toLinearMap₂ (N₂ := N₂) b₁ b₂
-- Mathlib/NumberTheory/FLT/Three.lean
private lemma lambda_sq_div_u₅_mul : λ ^ 2 ∣ S.u₅ * (λ ^ (S.multiplicity - 1) * S.X) ^ 3
-- Mathlib/Order/Bounded.lean
theorem unbounded_gt_inter_gt [LinearOrder α] [NoMinOrder α] (a : α) :
    Unbounded (· > ·) (s ∩ { b | b < a }) ↔ Unbounded (· > ·) s
-- Mathlib/Logic/Equiv/Basic.lean
@[simp]
theorem sumAssoc_apply_inl_inr (b) : sumAssoc α β γ (inl (inr b)) = inr (inl b)
-- Mathlib/Algebra/Polynomial/BigOperators.lean
theorem natDegree_multiset_sum_le (l : Multiset S[X]) :
    natDegree l.sum ≤ (l.map natDegree).foldr max max_left_comm 0
-- Mathlib/Algebra/Polynomial/Smeval.lean
theorem smeval_at_zero : p.smeval (0 : S) = (p.coeff 0) • (1 : S)
-- Mathlib/Algebra/PUnitInstances/Module.lean
@[to_additive (attr := simp)]
theorem smul_eq {R : Type*} (y : PUnit) (r : R) : r • y = unit
-- Mathlib/Topology/Order/LocalExtr.lean
nonrec theorem IsLocalMax.sub (hf : IsLocalMax f a) (hg : IsLocalMin g a) :
    IsLocalMax (fun x => f x - g x) a
-- Mathlib/Algebra/Group/Submonoid/Units.lean
@[to_additive]
lemma mem_units_of_val_mem_inv_val_mem (S : Submonoid M) {x : Mˣ} (h₁ : (x : M) ∈ S)
    (h₂ : ((x⁻¹ : Mˣ) : M) ∈ S) : x ∈ S.units
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
/-- `rpow` version of `Multiset.prod_map_pow`. -/
theorem _root_.Real.multiset_prod_map_rpow {ι} (s : Multiset ι) (f : ι → ℝ)
    (hs : ∀ i ∈ s, (0 : ℝ) ≤ f i) (r : ℝ) :
    (s.map (f · ^ r)).prod = (s.map f).prod ^ r
-- Mathlib/Data/List/DropRight.lean
@[simp]
theorem rdropWhile_concat_pos (x : α) (h : p x) : rdropWhile p (l ++ [x]) = rdropWhile p l
-- Mathlib/Topology/Category/CompHausLike/Basic.lean
/-- Any continuous bijection of compact Hausdorff spaces is an isomorphism. -/
theorem isIso_of_bijective {X Y : CompHausLike.{u} P} (f : X ⟶ Y) (bij : Function.Bijective f) :
    IsIso f
-- Mathlib/NumberTheory/Dioph.lean
theorem mul_dioph : DiophFn fun v => f v * g v