ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/UniformSpace/UniformConvergence.lean
theorem TendstoUniformlyOn.seq_tendstoUniformlyOn {l : Filter ι} (h : TendstoUniformlyOn F f l s)
    (u : ℕ → ι) (hu : Tendsto u atTop l) : TendstoUniformlyOn (fun n => F (u n)) f atTop s
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem support_monomial (n) {a : R} (H : a ≠ 0) : (monomial n a).support = singleton n
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
@[simp] lemma fst_map_swap : (ρ.map Prod.swap).fst = ρ.snd
-- Mathlib/SetTheory/Game/PGame.lean
theorem equiv_congr_right {x₁ x₂ : PGame} : (x₁ ≈ x₂) ↔ ∀ y₁, (x₁ ≈ y₁) ↔ (x₂ ≈ y₁)
-- Mathlib/LinearAlgebra/TensorProduct/Pi.lean
@[simp]
private lemma piScalarRightInv_single (x : N) (i : ι) :
    piScalarRightInv R S N ι (Pi.single i x) = x ⊗ₜ Pi.single i 1
-- Mathlib/Data/NNReal/Basic.lean
nonrec theorem exists_pow_lt_of_lt_one {a b : ℝ≥0} (ha : 0 < a) (hb : b < 1) :
    ∃ n : ℕ, b ^ n < a
-- Mathlib/Algebra/MonoidAlgebra/Support.lean
theorem support_mul [Mul G] [DecidableEq G] (a b : MonoidAlgebra k G) :
    (a * b).support ⊆ a.support * b.support
-- Mathlib/RingTheory/Localization/Basic.lean
@[simp]
theorem lift_of_comp (j : S →+* P) : lift (isUnit_comp M j) = j
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem AntitoneOn.antivaryOn (hf : AntitoneOn f s) (hg : MonotoneOn g s) :
    AntivaryOn f g s
-- Mathlib/RingTheory/Trace/Defs.lean
theorem trace_eq_matrix_trace [DecidableEq ι] (b : Basis ι R S) (s : S) :
    trace R S s = Matrix.trace (Algebra.leftMulMatrix b s)
-- Mathlib/Order/BoundedOrder.lean
@[simp] theorem up_bot [Bot α] : up (⊥ : α) = ⊥
-- Mathlib/Analysis/Normed/Operator/WeakOperatorTopology.lean
lemma continuous_dual_apply (x : E) (y : F⋆) : Continuous fun (A : E →WOT[𝕜] F) => y (A x)
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem smul {𝕜' : Type*} [NontriviallyNormedField 𝕜'] [NormedAlgebra 𝕜 𝕜'] [NormedSpace 𝕜' F]
    [IsScalarTower 𝕜 𝕜' F] {c : E → 𝕜'} {f : E → F} {s : Set E} (hc : DiffContOnCl 𝕜 c s)
    (hf : DiffContOnCl 𝕜 f s) : DiffContOnCl 𝕜 (fun x => c x • f x) s
-- Mathlib/LinearAlgebra/TensorProduct/Vanishing.lean
/-- **Equational criterion for vanishing**
[A. Altman and S. Kleiman, *A term of commutative algebra* (Lemma 8.16)][altman2021term],
backward direction.

If the expression $\sum_i m_i \otimes n_i$ vanishes trivially, then it vanishes.
That is, $\sum_i m_i \otimes n_i = 0$. -/
theorem sum_tmul_eq_zero_of_vanishesTrivially (hmn : VanishesTrivially R m n) :
    ∑ i, m i ⊗ₜ n i = (0 : M ⊗[R] N)
-- Mathlib/RingTheory/Valuation/ValuationSubring.lean
theorem ofPrime_le_of_le (P Q : Ideal A) [P.IsPrime] [Q.IsPrime] (h : P ≤ Q) :
    ofPrime A Q ≤ ofPrime A P
-- Mathlib/GroupTheory/Perm/Cycle/Type.lean
@[simp]
theorem inv_iff {f : Perm α} : IsThreeCycle f⁻¹ ↔ IsThreeCycle f
-- Mathlib/Analysis/Distribution/SchwartzSpace.lean
@[simp] lemma compCLMOfContinuousLinearEquiv_apply (g : D ≃L[ℝ] E) (f : 𝓢(E, F)) :
    compCLMOfContinuousLinearEquiv 𝕜 g f = f ∘ g
-- Mathlib/LinearAlgebra/Multilinear/Basic.lean
/-- If one multiplies by `c i` the coordinates in a finset `s`, then the image under a multilinear
map is multiplied by `∏ i ∈ s, c i`. This is mainly an auxiliary statement to prove the result when
`s = univ`, given in `map_smul_univ`, although it can be useful in its own right as it does not
require the index set `ι` to be finite. -/
theorem map_piecewise_smul [DecidableEq ι] (c : ι → R) (m : ∀ i, M₁ i) (s : Finset ι) :
    f (s.piecewise (fun i => c i • m i) m) = (∏ i ∈ s, c i) • f m
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem _root_.CauchySeq.isBounded_range {f : ℕ → α} (hf : CauchySeq f) : IsBounded (range f)
-- Mathlib/LinearAlgebra/AffineSpace/Matrix.lean
/-- A change of basis formula for barycentric coordinates.

See also `AffineBasis.toMatrix_inv_vecMul_toMatrix`. -/
@[simp]
theorem toMatrix_vecMul_coords (x : P) : b₂.coords x ᵥ* b.toMatrix b₂ = b.coords x
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem WfDvdMonoid.iff_wellFounded_associates [CancelCommMonoidWithZero α] :
    WfDvdMonoid α ↔ WellFounded ((· < ·) : Associates α → Associates α → Prop)
-- Mathlib/Algebra/Ring/CentroidHom.lean
@[simp, norm_cast]
theorem coe_add (f g : CentroidHom α) : ⇑(f + g) = f + g
-- Mathlib/Order/Heyting/Basic.lean
theorem compl_compl_himp_distrib (a b : α) : (a ⇨ b)ᶜᶜ = aᶜᶜ ⇨ bᶜᶜ
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
theorem log_mul_add {x y : ℝ≥0∞} : log (x * y) = log x + log y
-- Mathlib/Data/Set/Sups.lean
@[simp]
theorem sups_singleton : s ⊻ {b} = s.image fun a => a ⊔ b
-- Mathlib/Geometry/Manifold/ContMDiff/Defs.lean
theorem ContMDiff.continuous (hf : ContMDiff I I' n f) : Continuous f
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem gcd_cons_div_right : gcd (x::xs) ∣ gcd xs
-- Mathlib/RepresentationTheory/Action/Monoidal.lean
theorem tensorUnit_rho {g : G} : (𝟙_ (Action V G)).ρ g = 𝟙 (𝟙_ V)
-- Mathlib/Algebra/Lie/Weights/Basic.lean
lemma map_weightSpace_eq (e : M ≃ₗ⁅R,L⁆ M₂) :
    (weightSpace M χ).map e = weightSpace M₂ χ
-- Mathlib/Data/List/Sublists.lean
@[simp]
theorem mem_sublists {s t : List α} : s ∈ sublists t ↔ s <+ t
-- Mathlib/Data/Nat/Cast/Basic.lean
theorem ext_nat [FunLike F ℕ R] [RingHomClass F ℕ R] (f g : F) : f = g
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_int : #ℤ = ℵ₀
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
/-- The **Ahlswede-Zhang Identity**. -/
lemma infSum_compls_add_supSum (𝒜 : Finset (Finset α)) :
    infSum 𝒜ᶜˢ + supSum 𝒜 = card α * ∑ k ∈ range (card α), (k : ℚ)⁻¹ + 1
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@[simp]
theorem toClifford_ι (m : M) : toClifford (TensorAlgebra.ι R m) = CliffordAlgebra.ι Q m
-- Mathlib/Probability/Independence/Conditional.lean
lemma condIndepSet_iff_condIndep (s t : Set Ω) (μ : Measure Ω) [IsFiniteMeasure μ] :
    CondIndepSet m' hm' s t μ ↔ CondIndep m' (generateFrom {s}) (generateFrom {t}) hm' μ
-- Mathlib/RingTheory/Bialgebra/Hom.lean
@[simp]
theorem id_comp : (BialgHom.id R B).comp φ = φ
-- Mathlib/Analysis/Normed/Lp/ProdLp.lean
theorem prod_infty_equiv_isometry [PseudoEMetricSpace α] [PseudoEMetricSpace β] :
    Isometry (WithLp.equiv ∞ (α × β))
-- Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean
theorem arg_div_coe_angle {x y : ℂ} (hx : x ≠ 0) (hy : y ≠ 0) :
    (arg (x / y) : Real.Angle) = arg x - arg y
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_refl : ⇑(refl 𝕜 P) = id
-- Mathlib/Logic/Small/Group.lean
@[to_additive existing (attr := simp)]
lemma equivShrink_div [Div α] [Small α] (x y : α) :
    equivShrink α (x / y) = equivShrink α x / equivShrink α y
-- Mathlib/Algebra/AddConstMap/Equiv.lean
@[simp]
lemma self_trans_symm (e : G ≃+c[a, b] H) : e.trans e.symm = .refl a
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[simp]
theorem eval₂Hom_X' (f : R →+* S₁) (g : σ → S₁) (i : σ) : eval₂Hom f g (X i) = g i
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem mk_eq (x : PSet) : @Eq ZFSet ⟦x⟧ (mk x)
-- Mathlib/Algebra/Lie/Killing.lean
/-- We say a Lie algebra is Killing if its Killing form is non-singular.

NB: This is not standard terminology (the literature does not seem to name Lie algebras with this
property). -/
class IsKilling : Prop :=
  /-- We say a Lie algebra is Killing if its Killing form is non-singular. -/
  killingCompl_top_eq_bot : LieIdeal.killingCompl R L ⊤ = ⊥
-- Mathlib/Analysis/BoundedVariation.lean
protected theorem eq_left_iff {f : α → E} {s : Set α} (hf : LocallyBoundedVariationOn f s)
    {a b c : α} (ha : a ∈ s) (hb : b ∈ s) (hc : c ∈ s) :
    variationOnFromTo f s a b = variationOnFromTo f s a c ↔ variationOnFromTo f s b c = 0
-- Mathlib/Topology/Order/ScottTopology.lean
lemma isOpen_of_isLowerSet (h : IsLowerSet s) : IsOpen s
-- Mathlib/Data/Matrix/Notation.lean
@[simp]
theorem row_cons (x : α) (u : Fin m → α) : row ι (vecCons x u) = of fun _ => vecCons x u
-- Mathlib/Topology/Instances/EReal.lean
private lemma continuousAt_mul_coe_coe (a b : ℝ) :
    ContinuousAt (fun p : EReal × EReal ↦ p.1 * p.2) (a, b)
-- Mathlib/Algebra/Module/Submodule/Map.lean
theorem le_comap_pow_of_le_comap (p : Submodule R M) {f : M →ₗ[R] M} (h : p ≤ p.comap f) (k : ℕ) :
    p ≤ p.comap (f ^ k)
-- Mathlib/Algebra/Quandle.lean
/-- Associative racks are uninteresting.
-/
theorem assoc_iff_id {R : Type*} [Rack R] {x y z : R} : x ◃ y ◃ z = (x ◃ y) ◃ z ↔ x ◃ z = z
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem monomial_eq : monomial s a = C a * (s.prod fun n e => X n ^ e : MvPolynomial σ R)
-- Mathlib/SetTheory/ZFC/Basic.lean
theorem ext_iff {x y : Class.{u}} : x = y ↔ ∀ z, x z ↔ y z
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem memℓp_infty {f : ∀ i, E i} (hf : BddAbove (Set.range fun i => ‖f i‖)) : Memℓp f ∞
-- Mathlib/Order/BoundedOrder.lean
theorem fst_top [Top α] [Top β] : (⊤ : α × β).fst = ⊤
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
@[simp]
theorem integral_same : ∫ x in a..a, f x ∂μ = 0
-- Mathlib/Tactic/LinearCombination.lean
theorem add_pf [Add α] (p₁ : (a₁:α) = b₁) (p₂ : a₂ = b₂) : a₁ + a₂ = b₁ + b₂
-- Mathlib/Topology/Algebra/Module/Basic.lean
protected theorem ext_ring_iff [TopologicalSpace R₁] {f g : R₁ →L[R₁] M₁} : f = g ↔ f 1 = g 1
-- Mathlib/Data/Finset/Basic.lean
@[simp]
theorem mem_insert : a ∈ insert b s ↔ a = b ∨ a ∈ s
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- The affine span of a set is `⊥` if and only if that set is empty. -/
@[simp]
theorem affineSpan_eq_bot : affineSpan k s = ⊥ ↔ s = ∅
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
protected theorem symmetric : Symmetric (AEDisjoint μ)
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
lemma nndist_pi_le_iff {f g : ∀ b, π b} {r : ℝ≥0} :
    nndist f g ≤ r ↔ ∀ b, nndist (f b) (g b) ≤ r
-- Mathlib/Algebra/Ring/Subsemiring/Basic.lean
@[simp]
theorem center_toSubmonoid : (center R).toSubmonoid = Submonoid.center R
-- Mathlib/Algebra/Ring/Units.lean
@[field_simps]
theorem add_divp (a b : α) (u : αˣ) : a + b /ₚ u = (a * u + b) /ₚ u
-- Mathlib/RingTheory/HahnSeries/PowerSeries.lean
theorem coeff_toMvPowerSeries_symm {f : MvPowerSeries σ R} {n : σ →₀ ℕ} :
    (HahnSeries.toMvPowerSeries.symm f).coeff n = MvPowerSeries.coeff R n f
-- Mathlib/Analysis/Convex/Combination.lean
/-- The centroid can be regarded as a center of mass. -/
@[simp]
theorem Finset.centroid_eq_centerMass (s : Finset ι) (hs : s.Nonempty) (p : ι → E) :
    s.centroid R p = s.centerMass (s.centroidWeights R) p
-- Mathlib/LinearAlgebra/Basis.lean
/-- An element of a non-unital-non-associative algebra is in the center exactly when it commutes
with the basis elements. -/
lemma Basis.mem_center_iff {A}
    [Semiring R] [NonUnitalNonAssocSemiring A]
    [Module R A] [SMulCommClass R A A] [SMulCommClass R R A] [IsScalarTower R A A]
    (b : Basis ι R A) {z : A} :
    z ∈ Set.center A ↔
      (∀ i, Commute (b i) z) ∧ ∀ i j,
        z * (b i * b j) = (z * b i) * b j
          ∧ (b i * z) * b j = b i * (z * b j)
          ∧ (b i * b j) * z = b i * (b j * z)
-- Mathlib/RingTheory/Polynomial/RationalRoot.lean
/-- **Integral root theorem**:
if `r : f.codomain` is a root of a monic polynomial over the ufd `A`,
then `r` is an integer -/
theorem isInteger_of_is_root_of_monic {p : A[X]} (hp : Monic p) {r : K} (hr : aeval r p = 0) :
    IsInteger A r
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
theorem copy_eq (S : NonUnitalSubalgebra R A) (s : Set A) (hs : s = ↑S) : S.copy s hs = S
-- Mathlib/Data/Real/EReal.lean
theorem neg_lt_of_neg_lt {a b : EReal} (h : -a < b) : -b < a
-- Mathlib/Data/Rat/Lemmas.lean
@[norm_cast]
theorem intCast_div_self (n : ℤ) : ((n / n : ℤ) : ℚ) = n / n
-- Mathlib/Data/Set/Basic.lean
theorem inter_union_distrib_right (s t u : Set α) : s ∩ t ∪ u = (s ∪ u) ∩ (t ∪ u)
-- Mathlib/Data/Nat/Defs.lean
lemma le_of_pred_lt : ∀ {m}, pred m < n → m ≤ n
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- There exists `r` such that `p` has distance `r` from all the
points of a set of points in `s` if and only if there exists (possibly
different) `r` such that its `orthogonalProjection` has that distance
from all the points in that set. -/
theorem exists_dist_eq_iff_exists_dist_orthogonalProjection_eq {s : AffineSubspace ℝ P} [Nonempty s]
    [HasOrthogonalProjection s.direction] {ps : Set P} (hps : ps ⊆ s) (p : P) :
    (∃ r, ∀ p1 ∈ ps, dist p1 p = r) ↔ ∃ r, ∀ p1 ∈ ps, dist p1 ↑(orthogonalProjection s p) = r
-- Mathlib/Analysis/Calculus/Monotone.lean
/-- A Stieltjes function is almost everywhere differentiable, with derivative equal to the
Radon-Nikodym derivative of the associated Stieltjes measure with respect to Lebesgue. -/
theorem StieltjesFunction.ae_hasDerivAt (f : StieltjesFunction) :
    ∀ᵐ x, HasDerivAt f (rnDeriv f.measure volume x).toReal x
-- Mathlib/Geometry/Manifold/ContMDiff/Atlas.lean
/-- Let `M` and `M'` be smooth manifolds with the same model-with-corners, `I`.  Then `f : M → M'`
is a local structomorphism for `I`, if and only if it is manifold-smooth on the domain of definition
in both directions. -/
theorem isLocalStructomorphOn_contDiffGroupoid_iff (f : PartialHomeomorph M M') :
    LiftPropOn (contDiffGroupoid ⊤ I).IsLocalStructomorphWithinAt f f.source ↔
      SmoothOn I I f f.source ∧ SmoothOn I I f.symm f.target
-- Mathlib/Data/Finset/Sym.lean
theorem diag_mem_sym2_iff : Sym2.diag a ∈ s.sym2 ↔ a ∈ s
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem natDegree_iterate_derivative (p : R[X]) (k : ℕ) :
    (derivative^[k] p).natDegree ≤ p.natDegree - k
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
/-- The measure of a disjoint union (even uncountable) of measurable sets is at least the sum of
the measures of the sets. -/
theorem tsum_meas_le_meas_iUnion_of_disjoint {ι : Type*} [MeasurableSpace α] (μ : Measure α)
    {As : ι → Set α} (As_mble : ∀ i : ι, MeasurableSet (As i))
    (As_disj : Pairwise (Disjoint on As)) : (∑' i, μ (As i)) ≤ μ (⋃ i, As i)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
@[simp]
theorem setToFun_zero_left {hT : DominatedFinMeasAdditive μ (0 : Set α → E →L[ℝ] F) C} :
    setToFun μ 0 hT f = 0
-- Mathlib/GroupTheory/GroupAction/FixingSubgroup.lean
theorem fixedPoints_subgroup_antitone : Antitone fun P : Subgroup M => fixedPoints P α
-- Mathlib/Topology/MetricSpace/Isometry.lean
theorem preimage_ball (hf : Isometry f) (x : α) (r : ℝ) :
    f ⁻¹' Metric.ball (f x) r = Metric.ball x r
-- Mathlib/RingTheory/FractionalIdeal/Basic.lean
@[simp, norm_cast]
theorem coe_mul (I J : FractionalIdeal S P) : (↑(I * J) : Submodule R P) = I * J
-- Mathlib/Algebra/FreeMonoid/Count.lean
theorem count_of [DecidableEq α] (x y : α) : count x (of y) = (Pi.single x 1 : α → ℕ) y
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem aemeasurable_derivWithin_Ioi [MeasurableSpace F] [BorelSpace F] (μ : Measure ℝ) :
    AEMeasurable (fun x => derivWithin f (Ioi x) x) μ
-- Mathlib/LinearAlgebra/Lagrange.lean
theorem degree_interpolate_erase_lt (hvs : Set.InjOn v s) (hi : i ∈ s) :
    (interpolate (s.erase i) v r).degree < ↑(s.card - 1)
-- Mathlib/Algebra/RingQuot.lean
@[ext 1100]
theorem ringQuot_ext [Semiring T] {r : R → R → Prop} (f g : RingQuot r →+* T)
    (w : f.comp (mkRingHom r) = g.comp (mkRingHom r)) : f = g
-- Mathlib/Data/Finset/Slice.lean
/-- Elements in distinct slices must be distinct. -/
theorem ne_of_mem_slice (h₁ : A₁ ∈ 𝒜 # r₁) (h₂ : A₂ ∈ 𝒜 # r₂) : r₁ ≠ r₂ → A₁ ≠ A₂
-- Mathlib/Order/Filter/Subsingleton.lean
theorem Subsingleton.anti {l'} (hl : l.Subsingleton) (hl' : l' ≤ l) : l'.Subsingleton
-- Mathlib/Order/Interval/Set/Disjoint.lean
@[simp]
theorem Ioc_disjoint_Ioc_same : Disjoint (Ioc a b) (Ioc b c)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem Monic.leadingCoeff {p : R[X]} (hp : p.Monic) : leadingCoeff p = 1
-- Mathlib/NumberTheory/PythagoreanTriples.lean
/-- **Formula for Pythagorean Triples** -/
theorem classification :
    PythagoreanTriple x y z ↔
      ∃ k m n,
        (x = k * (m ^ 2 - n ^ 2) ∧ y = k * (2 * m * n) ∨
            x = k * (2 * m * n) ∧ y = k * (m ^ 2 - n ^ 2)) ∧
          (z = k * (m ^ 2 + n ^ 2) ∨ z = -k * (m ^ 2 + n ^ 2))
-- Mathlib/Geometry/Euclidean/Circumcenter.lean
/-- If there exists a distance that a point has from all vertices of a
simplex, the orthogonal projection of that point onto the subspace
spanned by that simplex is its circumcenter.  -/
theorem orthogonalProjection_eq_circumcenter_of_exists_dist_eq {n : ℕ} (s : Simplex ℝ P n) {p : P}
    (hr : ∃ r, ∀ i, dist (s.points i) p = r) :
    ↑(s.orthogonalProjectionSpan p) = s.circumcenter
-- Mathlib/Data/Bool/Basic.lean
lemma not_ne_self : ∀ b : Bool, (!b) ≠ b
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem smul_dotProduct [IsScalarTower R α α] (x : R) (v w : m → α) :
    x • v ⬝ᵥ w = x • (v ⬝ᵥ w)
-- Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean
/-- The identity affine map acts as the identity. -/
theorem id_apply (p : P1) : id k P1 p = p
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
lemma coe_monoidHom_trans (e₁ : M ≃* N) (e₂ : N ≃* P) :
    (e₁.trans e₂ : M →* P) = (e₂ : N →* P).comp ↑e₁
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- See also the strictly more general `final_iff_final_comp` below. -/
theorem final_iff_equivalence_comp [IsEquivalence F] : Final G ↔ Final (F ⋙ G)
-- Mathlib/Topology/Spectral/Hom.lean
/-- A function between topological spaces is spectral if it is continuous and the preimage of every
compact open set is compact open. -/
structure IsSpectralMap (f : α → β) extends Continuous f : Prop where
  /-- A function between topological spaces is spectral if it is continuous and the preimage of
   every compact open set is compact open. -/
  isCompact_preimage_of_isOpen ⦃s : Set β⦄ : IsOpen s → IsCompact s → IsCompact (f ⁻¹' s)
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
@[simp]
theorem card_box : (box n d).card = d ^ n
-- Mathlib/Combinatorics/Young/YoungDiagram.lean
@[simp]
theorem cells_ssubset_iff {μ ν : YoungDiagram} : μ.cells ⊂ ν.cells ↔ μ < ν
-- Mathlib/FieldTheory/IntermediateField.lean
theorem inclusion_injective {E F : IntermediateField K L} (hEF : E ≤ F) :
    Function.Injective (inclusion hEF)
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem natDegree_map_of_leadingCoeff_ne_zero (f : R →+* S) (hf : f (leadingCoeff p) ≠ 0) :
    natDegree (p.map f) = natDegree p
-- Mathlib/Topology/ContinuousFunction/Compact.lean
theorem uniformInducing_equivBoundedOfCompact : UniformInducing (equivBoundedOfCompact α β)
-- Mathlib/Data/List/Basic.lean
theorem bind_pure_eq_map (f : α → β) (l : List α) : l.bind (pure ∘ f) = map f l
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem lt_of_not_le : ∀{a b : Nat}, ¬(a ≤ b) → b < a
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem range_finsuppTotal :
    LinearMap.range (finsuppTotal ι M I v) = I • Submodule.span R (Set.range v)
-- Mathlib/Data/Nat/Choose/Basic.lean
theorem choose_eq_zero_of_lt : ∀ {n k}, n < k → choose n k = 0
-- Mathlib/RingTheory/Coalgebra/Basic.lean
@[simp]
theorem rTensor_counit_comul (a : A) : counit.rTensor A (comul a) = 1 ⊗ₜ[R] a
-- Mathlib/Data/PFunctor/Multivariate/Basic.lean
@[simp]
theorem comp.mk_get (x : comp P Q α) : comp.mk (comp.get x) = x
-- Mathlib/Topology/Sheaves/SheafCondition/Sites.lean
@[simp]
theorem coveringOfPresieve_apply (U : Opens X) (R : Presieve U) (f : ΣV, { f : V ⟶ U // R f }) :
    coveringOfPresieve U R f = f.1
-- Mathlib/Analysis/Normed/Group/Uniform.lean
@[to_additive]
theorem Isometry.nnnorm_map_of_map_one {f : E → F} (hi : Isometry f) (h₁ : f 1 = 1) (x : E) :
    ‖f x‖₊ = ‖x‖₊
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_add_const_Ioi : (fun x => x + a) ⁻¹' Ioi b = Ioi (b - a)
-- Mathlib/Topology/Instances/ENNReal.lean
protected theorem coe_tsum {f : α → ℝ≥0} : Summable f → ↑(tsum f) = ∑' a, (f a : ℝ≥0∞)
-- Mathlib/Topology/Algebra/Group/Basic.lean
/-- A topological group which is weakly locally compact is automatically locally compact. -/
@[to_additive
  (attr := deprecated WeaklyLocallyCompactSpace.locallyCompactSpace (since := "2024-01-28"))]
theorem instLocallyCompactSpaceOfWeaklyOfGroup [WeaklyLocallyCompactSpace G] :
    LocallyCompactSpace G
-- Mathlib/Data/List/Rotate.lean
theorem cyclicPermutations_of_ne_nil (l : List α) (h : l ≠ []) :
    cyclicPermutations l = dropLast (zipWith (· ++ ·) (tails l) (inits l))
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem ContinuousOn.intervalIntegrable_of_Icc {u : ℝ → E} {a b : ℝ} (h : a ≤ b)
    (hu : ContinuousOn u (Icc a b)) : IntervalIntegrable u μ a b
-- .lake/packages/lean4/src/lean/Init/Data/String/Extra.lean
theorem Iterator.sizeOf_next_lt_of_atEnd (i : String.Iterator) (h : ¬ i.atEnd = true) : sizeOf i.next < sizeOf i
-- Mathlib/Order/CompactlyGenerated/Basic.lean
protected theorem Directed.inf_iSup_eq (h : Directed (· ≤ ·) f) :
    (a ⊓ ⨆ i, f i) = ⨆ i, a ⊓ f i
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem functorPullback_union (S R : Sieve (F.obj X)) :
    (S ⊔ R).functorPullback F = S.functorPullback F ⊔ R.functorPullback F
-- Mathlib/Algebra/Quaternion.lean
theorem eq_re_iff_mem_range_coe {a : ℍ[R]} : a = a.re ↔ a ∈ Set.range (coe : R → ℍ[R])
-- Mathlib/Data/Complex/Basic.lean
@[simp]
theorem conj_im (z : ℂ) : (conj z).im = -z.im
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem coe_id : ⇑(BoundedOrderHom.id α) = id
-- Mathlib/Analysis/InnerProductSpace/Orthogonal.lean
theorem IsOrtho.mono {U₁ V₁ U₂ V₂ : Submodule 𝕜 E} (hU : U₂ ≤ U₁) (hV : V₂ ≤ V₁) (h : U₁ ⟂ V₁) :
    U₂ ⟂ V₂
-- Mathlib/Data/Nat/Choose/Cast.lean
theorem cast_choose_eq_ascPochhammer_div (a b : ℕ) :
    (a.choose b : K) = (ascPochhammer K b).eval ↑(a - (b - 1)) / b !
-- Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean
lemma addX_of_Z_eq_zero_left {P Q : Fin 3 → R} (hPz : P z = 0) :
    W'.addX P Q = (P x * Q z) ^ 2 * Q x
-- Mathlib/Topology/Sets/Compacts.lean
@[simp, norm_cast] lemma coe_bot : ↑(⊥ : CompactOpens α) = (∅ : Set α)
-- Mathlib/Analysis/Convex/Integral.lean
/-- **Jensen's inequality**: if a function `g : E → ℝ` is concave and continuous on a convex closed
set `s`, `μ` is a probability measure on `α`, and `f : α → E` is a function sending `μ`-a.e.  points
to `s`, then the expected value of `g ∘ f` is less than or equal to the value of `g` at the expected
value of `f` provided that both `f` and `g ∘ f` are integrable. -/
theorem ConcaveOn.le_map_integral [IsProbabilityMeasure μ] (hg : ConcaveOn ℝ s g)
    (hgc : ContinuousOn g s) (hsc : IsClosed s) (hfs : ∀ᵐ x ∂μ, f x ∈ s) (hfi : Integrable f μ)
    (hgi : Integrable (g ∘ f) μ) : (∫ x, g (f x) ∂μ) ≤ g (∫ x, f x ∂μ)
-- Mathlib/Topology/Order/LocalExtr.lean
theorem IsLocalMinOn.comp_continuousOn [TopologicalSpace δ] {t : Set α} {s : Set δ} {g : δ → α}
    {b : δ} (hf : IsLocalMinOn f t (g b)) (hst : s ⊆ g ⁻¹' t) (hg : ContinuousOn g s) (hb : b ∈ s) :
    IsLocalMinOn (f ∘ g) s b
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem comp_apply (f : CoheytingHom β γ) (g : CoheytingHom α β) (a : α) : f.comp g a = f (g a)
-- Mathlib/CategoryTheory/SmallObject/Iteration.lean
/-- The category of `j`th iterations of a functor `Φ` equipped with a natural
transformation `ε : 𝟭 C ⟶ Φ`. An object consists of the data of all iterations
of `Φ` for `i : J` such that `i ≤ j` (this is the field `F`). Such objects are
equipped with data and properties which characterizes the iterations up to a unique
isomorphism for the three types of elements: `⊥`, successors, limit elements. -/
structure Iteration (j : J) where
  /-- The data of all `i`th iterations for `i : J` such that `i ≤ j`. -/
  F : { i // i ≤ j } ⥤ C ⥤ C
  /-- The zeroth iteration is the identity functor. -/
  isoZero : F.obj ⟨⊥, bot_le⟩ ≅ 𝟭 C
  /-- The iteration on a successor element is obtained by composition of
  the previous iteration with `Φ`. -/
  isoSucc (i : J) (hi : i < j) :
    F.obj ⟨wellOrderSucc i, wellOrderSucc_le hi⟩ ≅ F.obj ⟨i, hi.le⟩ ⋙ Φ
  /-- The natural map from an iteration to its successor is induced by `ε`. -/
  mapSucc'_eq (i : J) (hi : i < j) :
    Iteration.mapSucc' F i hi = whiskerLeft _ ε ≫ (isoSucc i hi).inv
  /-- If `i` is a limit element, the `i`th iteration is the colimit
  of `k`th iterations for `k < i`. -/
  isColimit (i : J) [IsWellOrderLimitElement i] (hi : i ≤ j) :
    IsColimit (Iteration.coconeOfLE F hi)