ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
@[simp] theorem count_append (a : α) : ∀ l₁ l₂, count a (l₁ ++ l₂) = count a l₁ + count a l₂
-- Mathlib/MeasureTheory/Group/Integral.lean
/-- Translating a function by right-multiplication does not change its integral with respect to a
right-invariant measure. -/
@[to_additive
      "Translating a function by right-addition does not change its integral with respect to a
      right-invariant measure."] -- Porting note: was `@[simp]`
theorem integral_mul_right_eq_self [IsMulRightInvariant μ] (f : G → E) (g : G) :
    (∫ x, f (x * g) ∂μ) = ∫ x, f x ∂μ
-- Mathlib/CategoryTheory/GlueData.lean
theorem hasColimit_multispan_comp : HasColimit (D.diagram.multispan ⋙ F)
-- Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean
lemma lintegral_nnnorm_le (f : X →ᵇ E) :
    ∫⁻ x, ‖f x‖₊ ∂μ ≤ ‖f‖₊ * (μ Set.univ)
-- Mathlib/CategoryTheory/Sums/Basic.lean
@[simp]
theorem swap_obj_inl (X : C) : (swap C D).obj (inl X) = inr X
-- Mathlib/MeasureTheory/Measure/FiniteMeasure.lean
theorem restrict_mass (μ : FiniteMeasure Ω) (A : Set Ω) : (μ.restrict A).mass = μ A
-- Mathlib/NumberTheory/Dioph.lean
@[simp]
theorem map_apply {α β} (f : α → β) (g : Poly α) (v) : map f g v = g (v ∘ f)
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
/-- The automorphism of the polynomial algebra given by `p(X) ↦ p(X+t)`,
  with inverse `p(X) ↦ p(X-t)`. -/
@[simps!]
def algEquivAevalXAddC {R} [CommRing R] (t : R) : R[X] ≃ₐ[R] R[X]
-- Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean
lemma exists_ne_zero {x : V} (hx : x ≠ 0) :
    ∃ f : V →L[R] R, f x ≠ 0
-- Mathlib/CategoryTheory/Limits/Shapes/SingleObj.lean
/-- The colimit of `J : SingleObj G ⥤ Type u` is equivalent to the quotient of
`J.obj (SingleObj.star G)` by the induced action. -/
@[simps!]
noncomputable def Types.colimitEquivQuotient :
    colimit J ≃ MulAction.orbitRel.Quotient G (J.obj (SingleObj.star G))
-- Mathlib/Analysis/LocallyConvex/WithSeminorms.lean
theorem filter_eq_iInf (p : SeminormFamily 𝕜 E ι) :
    p.moduleFilterBasis.toFilterBasis.filter = ⨅ i, (𝓝 0).comap (p i)
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
protected theorem norm_sub_norm_compl_sub_single (hp : 0 < p.toReal) (f : lp E p) (s : Finset α) :
    ‖f‖ ^ p.toReal - ‖f - ∑ i ∈ s, lp.single p i (f i)‖ ^ p.toReal =
      ∑ i ∈ s, ‖f i‖ ^ p.toReal
-- Mathlib/Algebra/Homology/HomologicalBicomplex.lean
@[reassoc (attr := simp)]
lemma comm_f {K L : HomologicalComplex₂ C c₁ c₂} (f : K ⟶ L) (i₁ i₁' : I₁) (i₂ : I₂) :
    (f.f i₁).f i₂ ≫ (L.d i₁ i₁').f i₂ = (K.d i₁ i₁').f i₂ ≫ (f.f i₁').f i₂
-- Mathlib/Analysis/Calculus/InverseFunctionTheorem/ApproximatesLinearOn.lean
theorem image_mem_nhds (hf : ApproximatesLinearOn f f' s c) (f'symm : f'.NonlinearRightInverse)
    {x : E} (hs : s ∈ 𝓝 x) (hc : Subsingleton F ∨ c < f'symm.nnnorm⁻¹) : f '' s ∈ 𝓝 (f x)
-- Mathlib/LinearAlgebra/LinearPMap.lean
/-- The graph of the inverse generates a `LinearPMap`. -/
theorem mem_inverse_graph_snd_eq_zero (x : F × E)
    (hv : x ∈ (graph f).map (LinearEquiv.prodComm R E F))
    (hv' : x.fst = 0) : x.snd = 0
-- Mathlib/Data/Int/GCD.lean
theorem gcd_dvd_gcd_mul_left (i j k : ℤ) : gcd i j ∣ gcd (k * i) j
-- Mathlib/Topology/LocalAtTarget.lean
theorem IsClosedMap.restrictPreimage (H : IsClosedMap f) (s : Set β) :
    IsClosedMap (s.restrictPreimage f)
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem coe_toSubmodule (S : Subalgebra R A) : (toSubmodule S : Set A) = S
-- Mathlib/Topology/ContinuousFunction/ContinuousMapZero.lean
@[simp] lemma coe_mul [MulZeroClass R] [ContinuousMul R] (f g : C(X, R)₀) : ⇑(f * g) = f * g
-- Mathlib/LinearAlgebra/Semisimple.lean
protected theorem IsSemisimple.aeval (p : K[X]) : (aeval f p).IsSemisimple
-- Mathlib/Order/Heyting/Basic.lean
@[simp]
theorem top_sdiff' (a : α) : ⊤ \ a = ￢a
-- Mathlib/Analysis/MeanInequalitiesPow.lean
/-- Weighted generalized mean inequality, version for two elements of `ℝ≥0` and real exponents. -/
theorem rpow_arith_mean_le_arith_mean2_rpow (w₁ w₂ z₁ z₂ : ℝ≥0) (hw' : w₁ + w₂ = 1) {p : ℝ}
    (hp : 1 ≤ p) : (w₁ * z₁ + w₂ * z₂) ^ p ≤ w₁ * z₁ ^ p + w₂ * z₂ ^ p
-- Mathlib/AlgebraicTopology/SimplicialSet/Monoidal.lean
@[simp]
lemma tensorHom_app_apply {K K' L L' : SSet.{u}} (f : K ⟶ K') (g : L ⟶ L')
    {Δ : SimplexCategoryᵒᵖ} (x : (K ⊗ L).obj Δ) :
    (f ⊗ g).app Δ x = ⟨f.app Δ x.1, g.app Δ x.2⟩
-- Mathlib/RingTheory/HahnSeries/Addition.lean
theorem support_add_subset {x y : HahnSeries Γ R} : support (x + y) ⊆ support x ∪ support y
-- Mathlib/CategoryTheory/MorphismProperty/Composition.lean
theorem stableUnderInverse {F₁ F₂ : C ⥤ D} (app : ∀ X, F₁.obj X ⟶ F₂.obj X) :
    (naturalityProperty app).StableUnderInverse
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
/-- The length of the List returned by `List.leftpad n a l` is equal
  to the larger of `n` and `l.length` -/
@[simp]
theorem leftpad_length (n : Nat) (a : α) (l : List α) :
    (leftpad n a l).length = max n l.length
-- Mathlib/Algebra/Group/Aut.lean
@[simp]
theorem conj_symm_apply [AddGroup G] (g h : G) : (conj g).symm h = -g + h + g
-- Mathlib/LinearAlgebra/Dual.lean
@[simp]
theorem dualAnnihilator_dualCoannihilator_eq {W : Subspace K V} :
    W.dualAnnihilator.dualCoannihilator = W
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean
theorem of_iso_pullback (h : CommSq fst snd f g) [HasPullback f g] (i : P ≅ pullback f g)
    (w₁ : i.hom ≫ pullback.fst _ _ = fst) (w₂ : i.hom ≫ pullback.snd _ _ = snd) :
      IsPullback fst snd f g
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- A set is affinely independent if and only if the differences from
a base point in that set are linearly independent. -/
theorem affineIndependent_set_iff_linearIndependent_vsub {s : Set P} {p₁ : P} (hp₁ : p₁ ∈ s) :
    AffineIndependent k (fun p => p : s → P) ↔
      LinearIndependent k (fun v => v : (fun p => (p -ᵥ p₁ : V)) '' (s \ {p₁}) → V)
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem derivative_apply (p : R[X]) : derivative p = p.sum fun n a => C (a * n) * X ^ (n - 1)
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem CPolynomialAt.add (hf : CPolynomialAt 𝕜 f x) (hg : CPolynomialAt 𝕜 g x) :
    CPolynomialAt 𝕜 (f + g) x
-- Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean
@[simp]
theorem expMapCircle_arg (z : circle) : expMapCircle (arg z) = z
-- Mathlib/Tactic/CategoryTheory/Monoidal.lean
theorem evalComp_cons {f g h i j : C} (α : f ⟶ g) (η : g ⟶ h) {ηs : h ⟶ i} {θ : i ⟶ j} {ι : h ⟶ j}
    (pf_ι : ηs ≫ θ = ι)  :
    (α ≫ η ≫ ηs) ≫ θ = α ≫ η ≫ ι
-- Mathlib/Algebra/Order/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_lt_one' (h : ∀ i ∈ s, f i ≤ 1) (hs : ∃ i ∈ s, f i < 1) : ∏ i ∈ s, f i < 1
-- Mathlib/Combinatorics/SetFamily/LYM.lean
theorem sized_falling : (falling k 𝒜 : Set (Finset α)).Sized k
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem NF.snd' {e n a} : NF (oadd e n a) → NFBelow a (repr e)
-- Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean
lemma hurwitzZetaEven_residue_one (a : UnitAddCircle) :
    Tendsto (fun s ↦ (s - 1) * hurwitzZetaEven a s) (𝓝[≠] 1) (𝓝 1)
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
theorem isomorphisms.infer_property [hf : IsIso f] : (isomorphisms C) f
-- Mathlib/Topology/MetricSpace/Isometry.lean
/-- `α` and `β` are isometric if there is an isometric bijection between them. -/
-- Porting note(#5171): was @[nolint has_nonempty_instance]
structure IsometryEquiv (α : Type u) (β : Type v) [PseudoEMetricSpace α] [PseudoEMetricSpace β]
    extends α ≃ β where
  isometry_toFun : Isometry toFun
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
theorem map_dvd_iff {a b} : f a ∣ f b ↔ a ∣ b
-- Mathlib/Topology/MetricSpace/Ultra/Basic.lean
lemma closedBall_eq_of_mem {x y: X} {r : ℝ} (h : y ∈ closedBall x r) :
    closedBall x r = closedBall y r
-- Mathlib/Analysis/Asymptotics/Theta.lean
@[trans]
theorem IsTheta.trans {f : α → E} {g : α → F'} {k : α → G} (h₁ : f =Θ[l] g) (h₂ : g =Θ[l] k) :
    f =Θ[l] k
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem snd_sub [Sub R] [Sub M] (x₁ x₂ : tsze R M) : (x₁ - x₂).snd = x₁.snd - x₂.snd
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp]
theorem compl_not_mem_iff : sᶜ ∉ f ↔ s ∈ f
-- Mathlib/MeasureTheory/PiSystem.lean
theorem has_compl_iff {a} : d.Has aᶜ ↔ d.Has a
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
/-- The braiding isomorphism can be passed through a map by swapping the order. -/
@[reassoc]
theorem biprod.braid_natural {W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W) :
    biprod.map f g ≫ (biprod.braiding _ _).hom = (biprod.braiding _ _).hom ≫ biprod.map g f
-- Mathlib/RingTheory/Trace/Basic.lean
theorem Algebra.isIntegral_trace [FiniteDimensional L F] {x : F} (hx : IsIntegral R x) :
    IsIntegral R (Algebra.trace L F x)
-- Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean
theorem gramSchmidt_inv_triangular (v : ι → E) {i j : ι} (hij : i < j) :
    ⟪gramSchmidt 𝕜 v j, v i⟫ = 0
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem natDegree_pos_of_not_isUnit_of_dvd_monic (ha : ¬IsUnit a) (hap : a ∣ p) : 0 < natDegree a
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[simp]
theorem rightUnitor_hom (X : C) : (ρ_ X).hom = coprod.desc (𝟙 _) (initial.to X)
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Iic_subset_Iic_union_Ioc : Iic b ⊆ Iic a ∪ Ioc a b
-- Mathlib/CategoryTheory/Subobject/Limits.lean
@[reassoc (attr := simp), elementwise (attr := simp)]
theorem imageSubobject_arrow_comp : factorThruImageSubobject f ≫ (imageSubobject f).arrow = f
-- Mathlib/FieldTheory/Adjoin.lean
/-- Adjoining a finite subset is compact in the lattice of intermediate fields. -/
theorem adjoin_finite_isCompactElement {S : Set E} (h : S.Finite) : IsCompactElement (adjoin F S)
-- Mathlib/Data/Fintype/Basic.lean
theorem Fin.univ_def (n : ℕ) : (univ : Finset (Fin n)) = ⟨List.finRange n, List.nodup_finRange n⟩
-- Mathlib/MeasureTheory/Measure/VectorMeasure.lean
theorem neg_apply (v : VectorMeasure α M) (i : Set α) : (-v) i = -v i
-- .lake/packages/batteries/Batteries/Data/RBMap/Alter.lean
theorem Ordered.insertNew {path : Path α} (hp : path.Ordered cmp) (vp : path.RootOrdered cmp v) :
    (path.insertNew v).Ordered cmp
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
@[simp]
theorem single_zero_smul_eq_smul (Γ) [OrderedAddCommMonoid Γ] [AddAction Γ Γ']
    [IsOrderedCancelVAdd Γ Γ'] [MulZeroClass R] [SMulWithZero R V] {r : R}
    {x : HahnModule Γ' R V} :
    (HahnSeries.single (0 : Γ) r) • x = r • x
-- Mathlib/Topology/Connected/PathConnected.lean
theorem exists_path_through_family' {n : ℕ} (p : Fin (n + 1) → X) :
    ∃ (γ : Path (p 0) (p n)) (t : Fin (n + 1) → I), ∀ i, γ (t i) = p i
-- Mathlib/Order/Filter/NAry.lean
theorem map₂_map_left (m : γ → β → δ) (n : α → γ) :
    map₂ m (f.map n) g = map₂ (fun a b => m (n a) b) f g
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem dvd_gcd_mul_gcd_iff_dvd_mul : x ∣ gcd x n * gcd x m ↔ x ∣ n * m
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lift_type_eq {α : Type u} {β : Type v} {r s} [IsWellOrder α r] [IsWellOrder β s] :
    lift.{max v w} (type r) = lift.{max u w} (type s) ↔ Nonempty (r ≃r s)
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
theorem op_iInf (S : ι → Subring R) : (iInf S).op = ⨅ i, (S i).op
-- Mathlib/FieldTheory/Minpoly/Field.lean
/-- The minimal polynomial of `1` is `X - 1`. -/
@[simp]
theorem one : minpoly A (1 : B) = X - 1
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
theorem div_def (x y : ℤ[i]) :
    x / y = ⟨round ((x * star y).re / norm y : ℚ), round ((x * star y).im / norm y : ℚ)⟩
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem toReal_le_pi (θ : Angle) : θ.toReal ≤ π
-- Mathlib/MeasureTheory/Function/ContinuousMapDense.lean
/-- Any integrable function can be approximated by bounded continuous functions,
version in terms of `∫`. -/
theorem Integrable.exists_boundedContinuous_integral_sub_le [μ.WeaklyRegular] {f : α → E}
    (hf : Integrable f μ) {ε : ℝ} (hε : 0 < ε) :
    ∃ g : α →ᵇ E, (∫ x, ‖f x - g x‖ ∂μ) ≤ ε ∧ Integrable g μ
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_dist_eq_of_L2 (x y : WithLp 2 (α × β)) :
    dist x y = √(dist x.fst y.fst ^ 2 + dist x.snd y.snd ^ 2)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem setSeq_mono ⦃m n : ℕ⦄ (h : m ≤ n) : setSeq hf U_mem n ⊆ setSeq hf U_mem m
-- Mathlib/Data/Real/ENatENNReal.lean
@[simp, norm_cast]
theorem toENNReal_add (m n : ℕ∞) : ↑(m + n) = (m + n : ℝ≥0∞)
-- Mathlib/Data/Bool/Basic.lean
theorem and_eq_false_eq_eq_false_or_eq_false (a b : Bool) :
    ((a && b) = false) = (a = false ∨ b = false)
-- Mathlib/Data/DFinsupp/Basic.lean
/-- `DFinsupp.single a b` is injective in `a`. For the statement that it is injective in `b`, see
`DFinsupp.single_injective` -/
theorem single_left_injective {b : ∀ i : ι, β i} (h : ∀ i, b i ≠ 0) :
    Function.Injective (fun i => single i (b i) : ι → Π₀ i, β i)
-- Mathlib/Algebra/Order/Sub/Canonical.lean
/-- See `tsub_lt_tsub_iff_left_of_le` for a stronger statement in a linear order. -/
theorem tsub_lt_tsub_iff_left_of_le_of_le [ContravariantClass α α (· + ·) (· < ·)] (h₁ : b ≤ a)
    (h₂ : c ≤ a) : a - b < a - c ↔ c < b
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive]
lemma orbit_subgroup_subset (H : Subgroup G) (a : α) : orbit H a ⊆ orbit G a
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem foldl_data_eq_map (l : List α) (acc : Array β) (G : α → β) :
    (l.foldl (fun acc a => acc.push (G a)) acc).data = acc.data ++ l.map G
-- Mathlib/Algebra/Squarefree/Basic.lean
lemma _root_.exists_squarefree_dvd_pow_of_ne_zero {x : R} (hx : x ≠ 0) :
    ∃ (y : R) (n : ℕ), Squarefree y ∧ y ∣ x ∧ x ∣ y ^ n
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
@[simp]
theorem lift_symm_apply (F : MonoidAlgebra k G →ₐ[k] A) (x : G) :
    (lift k G A).symm F x = F (single x 1)
-- Mathlib/RingTheory/RootsOfUnity/Minpoly.lean
/-- If `p` is a prime that does not divide `n`,
then the minimal polynomials of a primitive `n`-th root of unity `μ`
and of `μ ^ p` are the same. -/
theorem minpoly_eq_pow {p : ℕ} [hprime : Fact p.Prime] (hdiv : ¬p ∣ n) :
    minpoly ℤ μ = minpoly ℤ (μ ^ p)
-- .lake/packages/lean4/src/lean/Init/Data/List/TakeDrop.lean
theorem drop_append_of_le_length {l₁ l₂ : List α} {n : Nat} (h : n ≤ l₁.length) :
    (l₁ ++ l₂).drop n = l₁.drop n ++ l₂
-- Mathlib/Algebra/Order/Group/Synonym.lean
@[to_additive (attr := simp, to_additive) (reorder := 1 2, 4 5) ofLex_smul']
theorem pow_ofLex [Pow α β] (a : α) (b : Lex β) : a ^ ofLex b = a ^ b
-- Mathlib/FieldTheory/KummerExtension.lean
lemma isSplittingField_AdjoinRoot_X_pow_sub_C :
    haveI := Fact.mk H
    letI : Algebra K K[n√a] := inferInstance
    IsSplittingField K K[n√a] (X ^ n - C a)
-- Mathlib/CategoryTheory/ComposableArrows.lean
@[simp]
lemma homMk₅_app_five :
    (homMk₅ app₀ app₁ app₂ app₃ app₄ app₅ w₀ w₁ w₂ w₃ w₄).app ⟨5, by valid⟩ = app₅
-- Mathlib/Order/Interval/Set/WithBotTop.lean
@[simp]
theorem preimage_coe_Iio_top : (some : α → WithTop α) ⁻¹' Iio ⊤ = univ
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
@[simp high]
theorem inner_orthogonalProjection_eq_of_mem_left [HasOrthogonalProjection K] (u : K) (v : E) :
    ⟪u, orthogonalProjection K v⟫ = ⟪(u : E), v⟫
-- Mathlib/MeasureTheory/Measure/AddContent.lean
lemma le_addContent_diff (m : AddContent C) (hC : IsSetRing C) (hs : s ∈ C) (ht : t ∈ C) :
    m s - m t ≤ m (s \ t)
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- Closure of a `NonUnitalSubring` `S` equals `S`. -/
theorem closure_eq (s : NonUnitalSubring R) : closure (s : Set R) = s
-- Mathlib/CategoryTheory/EffectiveEpi/Enough.lean
/--
`D` has *effectively enough objects with respect to the functor `F` if every object has an
effective presentation.
-/
class EffectivelyEnough : Prop where
  /-- For every `X : D`, there exists an object `p` of `C` with an effective epi `F.obj p ⟶ X`. -/
  presentation : ∀ (X : D), Nonempty (F.EffectivePresentation X)
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_bot [Bot β] : ⇑(⊥ : InfHom α β) = ⊥
-- Mathlib/Algebra/Ring/Prod.lean
@[simp]
theorem fst_comp_prod : (fst S T).comp (f.prod g) = f
-- Mathlib/LinearAlgebra/Isomorphisms.lean
@[simp, nolint simpNF]
theorem quotientInfEquivSupQuotient_apply_mk (p p' : Submodule R M) (x : p) :
    let map := inclusion (le_sup_left : p ≤ p ⊔ p')
    quotientInfEquivSupQuotient p p' (Submodule.Quotient.mk x) =
      @Submodule.Quotient.mk R (p ⊔ p' : Submodule R M) _ _ _ (comap (p ⊔ p').subtype p') (map x)
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
theorem Filter.HasBasis.uniformEquicontinuous_iff {κ₁ κ₂ : Type*} {p₁ : κ₁ → Prop}
    {s₁ : κ₁ → Set (β × β)} {p₂ : κ₂ → Prop} {s₂ : κ₂ → Set (α × α)} {F : ι → β → α}
    (hβ : (𝓤 β).HasBasis p₁ s₁) (hα : (𝓤 α).HasBasis p₂ s₂) :
    UniformEquicontinuous F ↔
      ∀ k₂, p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ x y, (x, y) ∈ s₁ k₁ → ∀ i, (F i x, F i y) ∈ s₂ k₂
-- Mathlib/CategoryTheory/Monoidal/Center.lean
@[simp]
theorem tensor_f {X₁ Y₁ X₂ Y₂ : Center C} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂) : (f ⊗ g).f = f.f ⊗ g.f
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive existing]
theorem norm_multiset_prod_le (m : Multiset E) : ‖m.prod‖ ≤ (m.map fun x => ‖x‖).sum
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem ContDiff.comp₃ {g : E₁ × E₂ × E₃ → G} {f₁ : F → E₁} {f₂ : F → E₂} {f₃ : F → E₃}
    (hg : ContDiff 𝕜 n g) (hf₁ : ContDiff 𝕜 n f₁) (hf₂ : ContDiff 𝕜 n f₂) (hf₃ : ContDiff 𝕜 n f₃) :
    ContDiff 𝕜 n fun x => g (f₁ x, f₂ x, f₃ x)
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem iterate_le_of_map_le_add_int {x : ℝ} {m : ℤ} (h : f x ≤ x + m) (n : ℕ) :
    f^[n] x ≤ x + n * m
-- Mathlib/Algebra/Order/Antidiag/Prod.lean
/-- See also `Finset.map_prodComm_antidiagonal`. -/
@[simp] theorem map_swap_antidiagonal [AddCommMonoid A] [HasAntidiagonal A] {n : A} :
    (antidiagonal n).map ⟨Prod.swap, Prod.swap_injective⟩ = antidiagonal n
-- Mathlib/CategoryTheory/Skeletal.lean
theorem comp_toThinSkeleton (F : C ⥤ D) : F ⋙ toThinSkeleton D = toThinSkeleton C ⋙ map F
-- Mathlib/Data/Complex/Basic.lean
@[simp, norm_cast]
theorem ofReal_add (r s : ℝ) : ((r + s : ℝ) : ℂ) = r + s
-- Mathlib/Topology/Algebra/UniformGroup.lean
@[to_additive]
theorem uniformity_eq_comap_nhds_one_swapped :
    𝓤 α = comap (fun x : α × α => x.1 / x.2) (𝓝 (1 : α))
-- Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean
theorem volume_regionBetween_eq_lintegral' (hf : Measurable f) (hg : Measurable g)
    (hs : MeasurableSet s) :
    μ.prod volume (regionBetween f g s) = ∫⁻ y in s, ENNReal.ofReal ((g - f) y) ∂μ
-- Mathlib/NumberTheory/Liouville/LiouvilleWith.lean
theorem nat_mul (h : LiouvilleWith p x) (hn : n ≠ 0) : LiouvilleWith p (n * x)
-- Mathlib/Topology/Homotopy/HomotopyGroup.lean
theorem isUnital_auxGroup (i : N) :
    EckmannHilton.IsUnital (auxGroup i).mul (⟦const⟧ : HomotopyGroup N X x)
-- Mathlib/RingTheory/Multiplicity.lean
theorem multiplicity_eq_multiplicity_iff {a b : α} {c d : β} :
    multiplicity a b = multiplicity c d ↔ ∀ n : ℕ, a ^ n ∣ b ↔ c ^ n ∣ d
-- Mathlib/Algebra/Category/Grp/EpiMono.lean
theorem agree : f.range = { x | h x = g x }
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem iInf_toSubmodule {ι : Sort*} (S : ι → Subalgebra R A) :
    toSubmodule (⨅ i, S i) = ⨅ i, toSubmodule (S i)
-- Mathlib/Topology/ContinuousFunction/Compact.lean
/-- The pointwise distance is controlled by the distance between functions, by definition. -/
theorem dist_apply_le_dist (x : α) : dist (f x) (g x) ≤ dist f g
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem map_id' (M : Matrix m n α) : M.map (·) = M
-- Mathlib/Order/Disjoint.lean
protected theorem codisjoint_iff [OrderTop α] [OrderTop β] {x y : α × β} :
    Codisjoint x y ↔ Codisjoint x.1 y.1 ∧ Codisjoint x.2 y.2
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma leftHomologyMap_op (φ : S₁ ⟶ S₂) [S₁.HasLeftHomology] [S₂.HasLeftHomology] :
    (leftHomologyMap φ).op = S₂.rightHomologyOpIso.inv ≫ rightHomologyMap (opMap φ) ≫
      S₁.rightHomologyOpIso.hom
-- Mathlib/Order/Antisymmetrization.lean
/-- The antisymmetrization relation as an equivalence relation. -/
@[simps]
def AntisymmRel.setoid : Setoid α
-- .lake/packages/batteries/Batteries/Logic.lean
theorem heq_iff_eq : HEq a b ↔ a = b
-- Mathlib/Topology/Bases.lean
protected theorem Embedding.separableSpace [TopologicalSpace α]
    [TopologicalSpace β] [SecondCountableTopology β] {f : α → β} (hf : Embedding f) :
    TopologicalSpace.SeparableSpace α
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- If the second of three points is strictly between the other two, the angle at that point
is π. -/
theorem _root_.Sbtw.angle₁₂₃_eq_pi {p₁ p₂ p₃ : P} (h : Sbtw ℝ p₁ p₂ p₃) : ∠ p₁ p₂ p₃ = π
-- Mathlib/Data/Nat/Bitwise.lean
theorem lor_comm (n m : ℕ) : n ||| m = m ||| n
-- Mathlib/Geometry/Manifold/MFDeriv/Basic.lean
theorem UniqueMDiffWithinAt.inter (hs : UniqueMDiffWithinAt I s x) (ht : t ∈ 𝓝 x) :
    UniqueMDiffWithinAt I (s ∩ t) x
-- Mathlib/Data/Int/Defs.lean
@[simp] lemma toNat_pred_coe_of_pos {i : ℤ} (h : 0 < i) : ((i.toNat - 1 : ℕ) : ℤ) = i - 1
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem sep_or : { x ∈ s | p x ∨ q x } = { x ∈ s | p x } ∪ { x ∈ s | q x }
-- Mathlib/Algebra/Category/ModuleCat/Differentials/Presheaf.lean
@[simp]
nonrec lemma d_app (d : M.Derivation' φ') {X : Dᵒᵖ} (a : S'.obj X) :
    d.d (φ'.app X a) = 0
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- The angle at a point is nonnegative. -/
nonrec theorem angle_nonneg (p1 p2 p3 : P) : 0 ≤ ∠ p1 p2 p3
-- Mathlib/Data/Finsupp/AList.lean
/-- Produce an association list for the finsupp over its support using choice. -/
@[simps]
noncomputable def toAList (f : α →₀ M) : AList fun _x : α => M
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
lemma LevyProkhorov.dist_def (μ ν : LevyProkhorov (ProbabilityMeasure Ω)) :
    dist μ ν = levyProkhorovDist μ.toMeasure ν.toMeasure
-- Mathlib/GroupTheory/GroupAction/FixedPoints.lean
@[to_additive (attr := simp)]
theorem fixedBy_one_eq_univ : fixedBy α (1 : M) = Set.univ
-- Mathlib/SetTheory/Cardinal/Basic.lean
/-- The lift of a supremum is the supremum of the lifts. -/
theorem lift_iSup {ι : Type v} {f : ι → Cardinal.{w}} (hf : BddAbove (range f)) :
    lift.{u} (iSup f) = ⨆ i, lift.{u} (f i)
-- Mathlib/Analysis/Calculus/FDeriv/Add.lean
@[fun_prop]
theorem DifferentiableOn.sub (hf : DifferentiableOn 𝕜 f s) (hg : DifferentiableOn 𝕜 g s) :
    DifferentiableOn 𝕜 (fun y => f y - g y) s
-- Mathlib/LinearAlgebra/CrossProduct.lean
theorem cross_apply (a b : Fin 3 → R) :
    a ×₃ b = ![a 1 * b 2 - a 2 * b 1, a 2 * b 0 - a 0 * b 2, a 0 * b 1 - a 1 * b 0]
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙHom_nonneg_iff {a : A} (ha : p a) {f : C(σₙ R a, R)₀} :
    0 ≤ cfcₙHom ha f ↔ 0 ≤ f
-- Mathlib/Analysis/InnerProductSpace/Symmetric.lean
theorem isSymmetric_id : (LinearMap.id : E →ₗ[𝕜] E).IsSymmetric
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
lemma toSpec_preimage_basicOpen {f}
    (t : NumDenSameDeg 𝒜 (.powers f)) :
    (Opens.map (toSpec 𝒜 f).1.base).obj (sbo (.mk t)) =
      Opens.comap ⟨_, continuous_subtype_val⟩ (pbo t.num.1)
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[simp]
lemma preimage_image_eq (U : X.Opens) : f ⁻¹ᵁ f ''ᵁ U = U
-- Mathlib/LinearAlgebra/Span.lean
theorem span_insert_eq_span (h : x ∈ span R s) : span R (insert x s) = span R s
-- Mathlib/LinearAlgebra/AffineSpace/Independent.lean
/-- The definition of `AffineIndependent`. -/
theorem affineIndependent_def (p : ι → P) :
    AffineIndependent k p ↔
      ∀ (s : Finset ι) (w : ι → k),
        ∑ i ∈ s, w i = 0 → s.weightedVSub p w = (0 : V) → ∀ i ∈ s, w i = 0
-- Mathlib/CategoryTheory/Limits/Cones.lean
/-- The opposite cone of the image of a cocone is the image of the opposite cone. -/
-- Porting note: removed @[simps (config := { rhsMd := semireducible })] and replaced with
@[simps!]
def mapCoconeOp {t : Cocone F} : (mapCocone G t).op ≅ mapCone G.op t.op
-- Mathlib/Data/Finset/Lattice.lean
theorem map_toDual_max (s : Finset α) : s.max.map toDual = (s.image toDual).min
-- Mathlib/Algebra/Ring/Ext.lean
theorem ext_iff {inst₁ inst₂ : Semiring R} :
    inst₁ = inst₂ ↔
      (local_hAdd[R, inst₁] = local_hAdd[R, inst₂]) ∧
      (local_hMul[R, inst₁] = local_hMul[R, inst₂])
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem union_mul : (s₁ ∪ s₂) * t = s₁ * t ∪ s₂ * t