ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/MetricSpace/HausdorffDistance.lean
/-- In a metric space, the minimal edistance to a nonempty set is finite. -/
theorem infEdist_ne_top (h : s.Nonempty) : infEdist x s ≠ ⊤
-- Mathlib/Topology/ContinuousFunction/Basic.lean
/-- Deprecated. Use `map_continuousAt` instead. -/
protected theorem continuousAt (f : C(α, β)) (x : α) : ContinuousAt f x
-- Mathlib/Algebra/Group/Semiconj/Defs.lean
@[to_additive (attr := simp)]
theorem conj_iff {a x y b : G} :
    SemiconjBy (b * a * b⁻¹) (b * x * b⁻¹) (b * y * b⁻¹) ↔ SemiconjBy a x y
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive (attr := simp)]
theorem prod_ite_mem [DecidableEq α] (s t : Finset α) (f : α → β) :
    ∏ i ∈ s, (if i ∈ t then f i else 1) = ∏ i ∈ s ∩ t, f i
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem isUnit_leadingCoeff_mul_right_eq_zero_iff (h : IsUnit p.leadingCoeff) {q : R[X]} :
    p * q = 0 ↔ q = 0
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
@[simp]
theorem isReal_of_mk_isReal {φ : K →+* ℂ} (h : IsReal (mk φ)) :
    ComplexEmbedding.IsReal φ
-- Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean
theorem HasMFDerivWithinAt.mul (hp : HasMFDerivWithinAt I 𝓘(𝕜, F') p s z p')
    (hq : HasMFDerivWithinAt I 𝓘(𝕜, F') q s z q') :
    HasMFDerivWithinAt I 𝓘(𝕜, F') (p * q) s z (p z • q' + q z • p' : E →L[𝕜] F')
-- Mathlib/LinearAlgebra/Projection.lean
theorem codRestrict_ker {f : M →ₗ[S] M} (h : IsProj m f) : ker h.codRestrict = ker f
-- Mathlib/MeasureTheory/Group/LIntegral.lean
/-- Translating a function by right-multiplication does not change its Lebesgue integral
with respect to a right-invariant measure. -/
@[to_additive
      "Translating a function by right-addition does not change its Lebesgue integral with
      respect to a right-invariant measure."]
theorem lintegral_mul_right_eq_self [IsMulRightInvariant μ] (f : G → ℝ≥0∞) (g : G) :
    (∫⁻ x, f (x * g) ∂μ) = ∫⁻ x, f x ∂μ
-- Mathlib/Analysis/BoxIntegral/Partition/Basic.lean
@[simp]
theorem mem_top : J ∈ (⊤ : Prepartition I) ↔ J = I
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem Trivialization.contMDiffAt_iff {f : M → TotalSpace F E} {x₀ : M} (he : f x₀ ∈ e.source) :
    ContMDiffAt IM (IB.prod 𝓘(𝕜, F)) n f x₀ ↔
      ContMDiffAt IM IB n (fun x => (f x).proj) x₀ ∧
      ContMDiffAt IM 𝓘(𝕜, F) n (fun x ↦ (e (f x)).2) x₀
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem Integrable.re (hf : Integrable f μ) : Integrable (fun x => RCLike.re (f x)) μ
-- Mathlib/Algebra/Lie/Submodule.lean
@[simp]
theorem LieSubalgebra.topEquiv_apply (x : (⊤ : LieSubalgebra R L)) : LieSubalgebra.topEquiv x = x
-- Mathlib/Data/Finsupp/Weight.lean
theorem degree_eq_weight_one :
    degree (σ := σ) = weight 1
-- Mathlib/Data/Finset/Sort.lean
theorem orderEmbOfCardLe_mem (s : Finset α) {k : ℕ} (h : k ≤ s.card) (a) :
    orderEmbOfCardLe s h a ∈ s
-- Mathlib/AlgebraicTopology/SimplicialObject.lean
/-- The fourth cosimplicial identity -/
@[reassoc]
theorem δ_comp_σ_of_gt {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : Fin.castSucc j < i) :
    X.δ i.succ ≫ X.σ (Fin.castSucc j) = X.σ j ≫ X.δ i
-- Mathlib/Order/Monotone/Basic.lean
theorem Antitone.strictAnti_of_injective (h₁ : Antitone f) (h₂ : Injective f) : StrictAnti f
-- Mathlib/Geometry/Euclidean/Inversion/ImageHyperplane.lean
/-- The inversion with center `c` and radius `R` maps a sphere passing through the center to a
hyperplane. -/
theorem inversion_mem_perpBisector_inversion_iff' (hR : R ≠ 0) (hy : y ≠ c) :
    inversion c R x ∈ perpBisector c (inversion c R y) ↔ dist x y = dist y c ∧ x ≠ c
-- Mathlib/Data/Real/Hyperreal.lean
@[simp] theorem infinitesimal_neg {x : ℝ*} : Infinitesimal (-x) ↔ Infinitesimal x
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
@[reassoc (attr := simp)]
theorem coconePointUniqueUpToIso_hom_desc {r s t : Cocone F} (P : IsColimit s) (Q : IsColimit t) :
    (coconePointUniqueUpToIso P Q).hom ≫ Q.desc r = P.desc r
-- Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean
nonrec theorem exists_pos_lt_subset_ball {R : ℝ} {s : Set E} {x : E} (hR : 0 < R) (hs : IsClosed s)
    (h : s ⊆ ball x R) : ∃ r ∈ Ioo 0 R, s ⊆ ball x r
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
private theorem tmulSymm_apply (a : ι ⊕ ι₂ → M) :
    tmulSymm (⨂ₜ[R] i, a i) = (⨂ₜ[R] i, a (Sum.inl i)) ⊗ₜ[R] ⨂ₜ[R] i, a (Sum.inr i)
-- Mathlib/LinearAlgebra/Basis.lean
/-- Given a basis, the `i`th element of the dual basis evaluates to 1 on the `i`th element of the
basis. -/
theorem mk_coord_apply_eq (i : ι) : (Basis.mk hli hsp).coord i (v i) = 1
-- Mathlib/Combinatorics/Enumerative/Catalan.lean
private theorem gosper_catalan_sub_eq_central_binom_div (n : ℕ) : gosperCatalan (n + 1) (n + 1) -
    gosperCatalan (n + 1) 0 = Nat.centralBinom (n + 1) / (n + 2)
-- Mathlib/CategoryTheory/FiberedCategory/HomLift.lean
lemma codomain_eq (f : R ⟶ S) (φ : a ⟶ b) [p.IsHomLift f φ] : p.obj b = S
-- Mathlib/Algebra/MvPolynomial/Equiv.lean
theorem degreeOf_coeff_finSuccEquiv (p : MvPolynomial (Fin (n + 1)) R) (j : Fin n) (i : ℕ) :
    degreeOf j (Polynomial.coeff (finSuccEquiv R n p) i) ≤ degreeOf j.succ p
-- Mathlib/Data/Fin/Tuple/Basic.lean
theorem append_right_nil {α : Type*} (u : Fin m → α) (v : Fin n → α) (hv : n = 0) :
    append u v = u ∘ Fin.cast (by rw [hv, Nat.add_zero])
-- Mathlib/Topology/Connected/Clopen.lean
/-- The connected component of a point is always a subset of the intersection of all its clopen
neighbourhoods. -/
theorem connectedComponent_subset_iInter_isClopen {x : α} :
    connectedComponent x ⊆ ⋂ Z : { Z : Set α // IsClopen Z ∧ x ∈ Z }, Z
-- Mathlib/Topology/Homeomorph.lean
@[simp]
theorem symm_comp_self (h : X ≃ₜ Y) : h.symm ∘ h = id
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive (attr := simp)]
theorem div_div_cancel_left (a b : G) : a / b / a = b⁻¹
-- Mathlib/Topology/Order/Lattice.lean
lemma ContinuousOn.finset_sup_apply (hs : ∀ i ∈ s, ContinuousOn (f i) t) :
    ContinuousOn (fun a ↦ s.sup (f · a)) t
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
@[reassoc (attr := simp)]
lemma rightHomologyι_naturality' :
    rightHomologyMap' φ h₁ h₂ ≫ h₂.ι = h₁.ι ≫ opcyclesMap' φ h₁ h₂
-- Mathlib/Analysis/Fourier/AddCircle.lean
theorem fourierCoeffOn.const_mul {a b : ℝ} (f : ℝ → ℂ) (c : ℂ) (n : ℤ) (hab : a < b) :
    fourierCoeffOn hab (fun x => c * f x) n = c * fourierCoeffOn hab f n
-- Mathlib/Analysis/Complex/Basic.lean
@[simp]
theorem imCLM_coe : (imCLM : ℂ →ₗ[ℝ] ℝ) = imLm
-- Mathlib/LinearAlgebra/BilinearMap.lean
theorem map_sub₂ (f : M' →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P') (x y z) : f (x - y) z = f x z - f y z
-- Mathlib/SetTheory/Game/Nim.lean
@[simp]
theorem toLeftMovesNim_symm_lt {o : Ordinal} (i : (nim o).LeftMoves) :
    ↑(toLeftMovesNim.symm i) < o
-- Mathlib/Computability/Primrec.lean
theorem mem_range_encode : PrimrecPred (fun n => n ∈ Set.range (encode : α → ℕ))
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
@[to_additive (attr := refl)]
theorem Red.refl : Red L L
-- Mathlib/MeasureTheory/Measure/Regular.lean
/-- If a measure is inner regular (using closed or compact sets) for open sets, then every
measurable set of finite measure can be approximated by a (closed or compact) subset. -/
theorem measurableSet_of_isOpen [OuterRegular μ] (H : InnerRegularWRT μ p IsOpen)
    (hd : ∀ ⦃s U⦄, p s → IsOpen U → p (s \ U)) :
    InnerRegularWRT μ p fun s => MeasurableSet s ∧ μ s ≠ ∞
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- Let `u₁`, `u₂` be two uniform structures on `γ` and `𝔖₁ 𝔖₂ : Set (Set α)`. If `u₁ ≤ u₂` and
`𝔖₂ ⊆ 𝔖₁` then `𝒱(α, γ, 𝔖₁, u₁) ≤ 𝒱(α, γ, 𝔖₂, u₂)`. -/
protected theorem mono ⦃u₁ u₂ : UniformSpace γ⦄ (hu : u₁ ≤ u₂) ⦃𝔖₁ 𝔖₂ : Set (Set α)⦄
    (h𝔖 : 𝔖₂ ⊆ 𝔖₁) : 𝒱(α, γ, 𝔖₁, u₁) ≤ 𝒱(α, γ, 𝔖₂, u₂)
-- Mathlib/CategoryTheory/Limits/Final.lean
/-- Final functors preserve filteredness.

This can be seen as a generalization of `IsFiltered.of_right_adjoint` (which states that right
adjoints preserve filteredness), as right adjoints are always final, see `final_of_adjunction`.
-/
theorem IsFilteredOrEmpty.of_final (F : C ⥤ D) [Final F] [IsFilteredOrEmpty C] :
    IsFilteredOrEmpty D
-- Mathlib/NumberTheory/Zsqrtd/Basic.lean
theorem Nonneg.add {a b : ℤ√d} (ha : Nonneg a) (hb : Nonneg b) : Nonneg (a + b)
-- Mathlib/Algebra/Algebra/Bilinear.lean
@[simp]
theorem pow_mulLeft (a : A) (n : ℕ) : mulLeft R a ^ n = mulLeft R (a ^ n)
-- Mathlib/Data/Finset/Basic.lean
theorem union_subset_left (h : s ∪ t ⊆ u) : s ⊆ u
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem factors_pow_count_prod [DecidableEq α] {x : α} (hx : x ≠ 0) :
    (∏ p ∈ (factors x).toFinset, p ^ (factors x).count p) ~ᵤ x
-- Mathlib/Topology/Connected/PathConnected.lean
@[continuity]
theorem continuous_symm : Continuous (symm : Path x y → Path y x)
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
lemma toNNReal_mul_add_neg_mul_add_mul_neg_eq (f g : C(X, ℝ)) :
    (f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal =
      (-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal
-- Mathlib/Data/Nat/Lattice.lean
theorem iInf_lt_succ (u : ℕ → α) (n : ℕ) : ⨅ k < n + 1, u k = (⨅ k < n, u k) ⊓ u n
-- Mathlib/Probability/ProbabilityMassFunction/Monad.lean
@[simp]
theorem support_bindOnSupport :
    (p.bindOnSupport f).support = ⋃ (a : α) (h : a ∈ p.support), (f a h).support
-- Mathlib/Order/BoundedOrder.lean
theorem not_isBot_iff_ne_bot : ¬IsBot a ↔ a ≠ ⊥
-- Mathlib/Logic/Equiv/Basic.lean
protected theorem isEmpty (e : α ≃ β) [IsEmpty β] : IsEmpty α
-- Mathlib/Algebra/Divisibility/Basic.lean
theorem dvd_of_mul_left_dvd (h : a * b ∣ c) : b ∣ c
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
private theorem one_sub_le_m_div_m_add_one_sq [Nonempty α]
    (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α) (hPε : ↑100 ≤ ↑4 ^ P.parts.card * ε ^ 5) :
    ↑1 - ε ^ 5 / ↑50 ≤ (m / (m + 1 : ℝ)) ^ 2
-- Mathlib/Algebra/Order/Kleene.lean
theorem nsmul_eq_self : ∀ {n : ℕ} (_ : n ≠ 0) (a : α), n • a = a
-- Mathlib/GroupTheory/Commutator.lean
/-- The commutator of a finite direct product is contained in the direct product of the commutators.
-/
theorem commutator_pi_pi_of_finite {η : Type*} [Finite η] {Gs : η → Type*} [∀ i, Group (Gs i)]
    (H K : ∀ i, Subgroup (Gs i)) : ⁅Subgroup.pi Set.univ H, Subgroup.pi Set.univ K⁆ =
    Subgroup.pi Set.univ fun i => ⁅H i, K i⁆
-- Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean
/-- Predicate on the triangle indices for the explicit triangles to be edge-disjoint. -/
class ExplicitDisjoint (t : Finset (α × β × γ)) : Prop where
  inj₀ : ∀ ⦃a b c a'⦄, (a, b, c) ∈ t → (a', b, c) ∈ t → a = a'
  inj₁ : ∀ ⦃a b c b'⦄, (a, b, c) ∈ t → (a, b', c) ∈ t → b = b'
  inj₂ : ∀ ⦃a b c c'⦄, (a, b, c) ∈ t → (a, b, c') ∈ t → c = c'
-- Mathlib/Topology/Irreducible.lean
theorem IsPreirreducible.preimage (ht : IsPreirreducible t) {f : Y → X}
    (hf : OpenEmbedding f) : IsPreirreducible (f ⁻¹' t)
-- Mathlib/Topology/ContinuousFunction/CompactlySupported.lean
@[simp]
theorem comp_id (f : C_c(γ, δ)) : f.comp (CocompactMap.id γ) = f
-- Mathlib/Data/Rel.lean
@[simp]
theorem inv_top : (⊤ : Rel α β).inv = (⊤ : Rel β α)
-- Mathlib/Data/Rat/Sqrt.lean
@[simp, norm_cast]
theorem sqrt_natCast (n : ℕ) : Rat.sqrt (n : ℚ) = Nat.sqrt n
-- Mathlib/Analysis/CstarAlgebra/Spectrum.lean
/-- In a C⋆-algebra, the spectral radius of a self-adjoint element is equal to its norm.
See `IsSelfAdjoint.toReal_spectralRadius_eq_norm` for a version involving
`spectralRadius ℝ a`. -/
lemma IsSelfAdjoint.toReal_spectralRadius_complex_eq_norm {a : A} (ha : IsSelfAdjoint a) :
    (spectralRadius ℂ a).toReal = ‖a‖
-- Mathlib/Analysis/NormedSpace/OperatorNorm/Mul.lean
/-- This is a mixin class for non-unital normed algebras which states that the left-regular
representation of the algebra on itself is isometric. Every unital normed algebra with `‖1‖ = 1` is
a regular normed algebra (see `NormedAlgebra.instRegularNormedAlgebra`). In addition, so is every
C⋆-algebra, non-unital included (see `CstarRing.instRegularNormedAlgebra`), but there are yet other
examples. Any algebra with an approximate identity (e.g., $$L^1$$) is also regular.

This is a useful class because it gives rise to a nice norm on the unitization; in particular it is
a C⋆-norm when the norm on `A` is a C⋆-norm. -/
class _root_.RegularNormedAlgebra : Prop :=
  /-- The left regular representation of the algebra on itself is an isometry. -/
  isometry_mul' : Isometry (mul 𝕜 𝕜')
-- Mathlib/Algebra/Ring/Divisibility/Basic.lean
/-- The negation of an element `a` of a semigroup with a distributive negation divides another
element `b` iff `a` divides `b`. -/
@[simp]
theorem neg_dvd : -a ∣ b ↔ a ∣ b
-- Mathlib/CategoryTheory/Functor/Derived/RightDerived.lean
/-- The natural isomorphism `RF ≅ RF'` on right derived functors that is
induced by a natural isomorphism `F ≅ F'`.  -/
@[simps]
noncomputable def rightDerivedNatIso (τ : F ≅ F') :
    RF ≅ RF'
-- .lake/packages/lean4/src/lean/Init/Data/Option/Lemmas.lean
@[simp] theorem not_isSome : isSome a = false ↔ a.isNone = true
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Basic.lean
theorem val_lt_of_le (i : Fin b) (h : b ≤ n) : i.val < n
-- Mathlib/Combinatorics/SimpleGraph/Basic.lean
theorem not_mem_commonNeighbors_right (v w : V) : w ∉ G.commonNeighbors v w
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_succ (a) : lift.{v, u} (succ a) = succ (lift.{v, u} a)
-- Mathlib/Topology/Algebra/GroupCompletion.lean
theorem AddMonoidHom.extension_coe [CompleteSpace β] [T0Space β] (f : α →+ β)
    (hf : Continuous f) (a : α) : f.extension hf a = f a
-- Mathlib/Algebra/Category/FGModuleCat/Basic.lean
@[simp] theorem LinearMap.comp_id_fgModuleCat
    {R} [Ring R] {G : FGModuleCat.{u} R} {H : Type u} [AddCommGroup H] [Module R H]
    (f : G →ₗ[R] H) : f.comp (𝟙 G) = f
-- Mathlib/Logic/Nonempty.lean
@[simp]
theorem nonempty_Prop {p : Prop} : Nonempty p ↔ p
-- Mathlib/Tactic/CategoryTheory/BicategoricalComp.lean
@[simps]
instance right (f g : a ⟶ b) [BicategoricalCoherence f g] :
    BicategoricalCoherence (f ≫ 𝟙 b) g
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma natDegree_ΨSq_le (n : ℤ) : (W.ΨSq n).natDegree ≤ n.natAbs ^ 2 - 1
-- Mathlib/Data/Nat/Cast/Defs.lean
theorem cast_add_one (n : ℕ) : ((n + 1 : ℕ) : R) = n + 1
-- Mathlib/Data/Real/EReal.lean
lemma antitone_div_right_of_nonpos {b : EReal} (h : b ≤ 0) : Antitone fun a ↦ a / b
-- Mathlib/Order/CompleteBooleanAlgebra.lean
lemma iSup_iInf_le [CompleteLattice α] {f : ∀ a, κ a → α} :
    ⨆ a, ⨅ b, f a b ≤ ⨅ g : ∀ a, κ a, ⨆ a, f a (g a)
-- Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean
lemma congr_φK {γ₁ γ₂ : LeftHomologyMapData φ h₁ h₂} (eq : γ₁ = γ₂) : γ₁.φK = γ₂.φK
-- Mathlib/Algebra/Ring/Defs.lean
theorem right_distrib [Mul R] [Add R] [RightDistribClass R] (a b c : R) :
    (a + b) * c = a * c + b * c
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
@[simp]
theorem mapEquiv_apply (g : P ≃ₐ[R] P') (I : FractionalIdeal S P) : mapEquiv g I = map (↑g) I
-- Mathlib/Algebra/BigOperators/Finprod.lean
/-- See also `Finset.prod_bij`. -/
@[to_additive "See also `Finset.sum_bij`."]
theorem finprod_mem_eq_of_bijOn {s : Set α} {t : Set β} {f : α → M} {g : β → M} (e : α → β)
    (he₀ : s.BijOn e t) (he₁ : ∀ x ∈ s, f x = g (e x)) : ∏ᶠ i ∈ s, f i = ∏ᶠ j ∈ t, g j
-- Mathlib/CategoryTheory/Yoneda.lean
theorem representable_of_natIso (F : Cᵒᵖ ⥤ Type v₁) {G} (i : F ≅ G) [F.Representable] :
    G.Representable
-- Mathlib/Data/Set/Image.lean
theorem range_nonempty [h : Nonempty ι] (f : ι → α) : (range f).Nonempty
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
theorem infinite_iff_in_eventualRange {K : (Finset V)ᵒᵖ} (C : G.componentComplFunctor.obj K) :
    C.supp.Infinite ↔ C ∈ G.componentComplFunctor.eventualRange K
-- Mathlib/CategoryTheory/Limits/Shapes/Types.lean
/-- Given `I : MulticospanIndex (Type u)`, this is a type which identifies
to the sections of the functor `I.multicospan`. -/
@[ext]
structure MulticospanIndex.sections where
  /-- The data of an element in `I.left i` for each `i : I.L`. -/
  val (i : I.L) : I.left i
  property (r : I.R) : I.fst r (val _) = I.snd r (val _)
-- Mathlib/Logic/Function/Conjugate.lean
/-- If `f` commutes with `g` and `g'`, then it commutes with `g ∘ g'`. -/
theorem comp_right (h : Commute f g) (h' : Commute f g') : Commute f (g ∘ g')
-- Mathlib/Order/Disjoint.lean
theorem eq_bot_of_top_isCompl (h : IsCompl ⊤ x) : x = ⊥
-- Mathlib/GroupTheory/Perm/Cycle/Basic.lean
theorem SameCycle.equivalence : Equivalence (SameCycle f)
-- Mathlib/Order/Hom/Lattice.lean
@[simp]
theorem coe_comp (f : InfTopHom β γ) (g : InfTopHom α β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem comp_id (f : sSupHom α β) : f.comp (sSupHom.id α) = f
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[gcongr] theorem rpow_lt_rpow {x y : ℝ≥0∞} {z : ℝ} (h₁ : x < y) (h₂ : 0 < z) : x ^ z < y ^ z
-- Mathlib/Algebra/Order/Field/Power.lean
theorem zpow_strictMono (hx : 1 < a) : StrictMono (a ^ · : ℤ → α)
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem degree_pos_of_aeval_root [Algebra R S] {p : R[X]} (hp : p ≠ 0) {z : S} (hz : aeval z p = 0)
    (inj : ∀ x : R, algebraMap R S x = 0 → x = 0) : 0 < p.degree
-- Mathlib/Data/DFinsupp/NeLocus.lean
@[simp]
theorem nonempty_neLocus_iff {f g : Π₀ a, N a} : (f.neLocus g).Nonempty ↔ f ≠ g
-- .lake/packages/lean4/src/lean/Init/Data/Int/Pow.lean
protected theorem pow_succ (b : Int) (e : Nat) : b ^ (e+1) = (b ^ e) * b
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
theorem inner_re_zero_right (x : E) : re ⟪x, 0⟫ = 0
-- Mathlib/Logic/Equiv/Basic.lean
@[simp] theorem piCurry_symm_apply {β : α → Type*} (γ : ∀ a, β a → Type*) (f : ∀ a b, γ a b) :
    (piCurry γ).symm f = Sigma.uncurry f
-- Mathlib/GroupTheory/CoprodI.lean
/-- The type of reduced words. A reduced word cannot contain a letter `1`, and no two adjacent
letters can come from the same summand. -/
@[ext]
structure Word where
  /-- A `Word` is a `List (Σ i, M i)`, such that `1` is not in the list, and no
  two adjacent letters are from the same summand -/
  toList : List (Σi, M i)
  /-- A reduced word does not contain `1` -/
  ne_one : ∀ l ∈ toList, Sigma.snd l ≠ 1
  /-- Adjacent letters are not from the same summand. -/
  chain_ne : toList.Chain' fun l l' => Sigma.fst l ≠ Sigma.fst l'
-- Mathlib/MeasureTheory/Constructions/Projective.lean
lemma measure_cylinder (h : IsProjectiveLimit μ P)
    (I : Finset ι) {s : Set (∀ i : I, α i)} (hs : MeasurableSet s) :
    μ (cylinder I s) = P I s
-- Mathlib/Order/SuccPred/Basic.lean
theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
    succ a < succ b ↔ a < b
-- Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean
@[simp]
theorem isAdjointPair_toLinearMap₂' :
    LinearMap.IsAdjointPair (Matrix.toLinearMap₂' R J) (Matrix.toLinearMap₂' R J')
        (Matrix.toLin' A) (Matrix.toLin' A') ↔
      Matrix.IsAdjointPair J J' A A'
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_zpow (f : α → β) (s : Finset α) (n : ℤ) : ∏ a ∈ s, f a ^ n = (∏ a ∈ s, f a) ^ n
-- Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean
lemma whiskerRightIso_mapId (f : a ⟶ b) : whiskerRightIso (F.mapId a) (F.map f) =
    (F.mapComp (𝟙 a) f).symm ≪≫ F.map₂Iso (λ_ f) ≪≫ (λ_ (F.map f)).symm
-- Mathlib/Data/List/Basic.lean
@[simp]
theorem forall_cons (p : α → Prop) (x : α) : ∀ l : List α, Forall p (x :: l) ↔ p x ∧ Forall p l
-- Mathlib/Order/UpperLower/Basic.lean
theorem isLowerSet_iInter₂ {f : ∀ i, κ i → Set α} (hf : ∀ i j, IsLowerSet (f i j)) :
    IsLowerSet (⋂ (i) (j), f i j)
-- Mathlib/Data/Sign.lean
@[simp]
theorem self_mul_sign (x : α) : x * sign x = |x|
-- Mathlib/Algebra/Polynomial/FieldDivision.lean
theorem rootMultiplicity_sub_one_le_derivative_rootMultiplicity [CharZero R] (p : R[X]) (t : R) :
    p.rootMultiplicity t - 1 ≤ p.derivative.rootMultiplicity t
-- Mathlib/Topology/Connected/PathConnected.lean
theorem isPathConnected_singleton (x : X) : IsPathConnected ({x} : Set X)
-- Mathlib/Data/Set/Lattice.lean
theorem biUnion_empty (s : α → Set β) : ⋃ x ∈ (∅ : Set α), s x = ∅
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem getElem?_set_ne {l : List α} {i j : Nat} (h : i ≠ j) {a : α}  :
    (l.set i a)[j]? = l[j]?
-- Mathlib/CategoryTheory/Monoidal/Comon_.lean
@[reassoc (attr := simp)]
theorem counit_comul_hom {Z : C} (f : M.X ⟶ Z) : M.comul ≫ (M.counit ⊗ f) = f ≫ (λ_ Z).inv
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
protected lemma IsCycle.isCircuit {p : Walk G u u} (h : IsCycle p) : IsCircuit p
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem map_zero (f : M →ₗ⁅R,L⁆ N) : f 0 = 0
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/NonUnital.lean
lemma cfcₙ_apply_of_not_predicate {f : R → R} (a : A) (ha : ¬ p a) :
    cfcₙ f a = 0
-- Mathlib/Order/Filter/FilterProduct.lean
@[simp]
theorem const_min [LinearOrder β] (x y : β) : (↑(min x y : β) : β*) = min ↑x ↑y
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean
theorem lpMeasSubgroupToLpTrim_add (hm : m ≤ m0) (f g : lpMeasSubgroup F m p μ) :
    lpMeasSubgroupToLpTrim F p μ hm (f + g) =
      lpMeasSubgroupToLpTrim F p μ hm f + lpMeasSubgroupToLpTrim F p μ hm g
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mul_ne_zero {a b : Ordinal} : a ≠ 0 → b ≠ 0 → a * b ≠ 0
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem count_nsmul (a : α) (n s) : count a (n • s) = n * count a s
-- Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean
theorem norm_compContinuousLinearMapLRight_le (g : ContinuousMultilinearMap 𝕜 E₁ G) :
    ‖compContinuousLinearMapLRight (E := E) g‖ ≤ ‖g‖
-- Mathlib/Analysis/Complex/UpperHalfPlane/Basic.lean
theorem subgroup_on_SL_apply (s : Γ) (g : SL(2, ℤ)) (z : ℍ) :
    (s • g) • z = ((s : SL(2, ℤ)) * g) • z
-- Mathlib/Topology/FiberBundle/Basic.lean
@[simp, mfld_simps]
theorem localTrivAt_apply_mk (b : B) (a : F) : (Z.localTrivAt b) ⟨b, a⟩ = ⟨b, a⟩
-- Mathlib/GroupTheory/Perm/Cycle/Concrete.lean
theorem nodup_toList (p : Perm α) (x : α) : Nodup (toList p x)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
@[simp]
theorem zeroLocus_singleton_zero : zeroLocus 𝒜 ({0} : Set A) = Set.univ
-- Mathlib/Topology/Homotopy/Basic.lean
theorem hcomp {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Y, Z)} (h₀ : Homotopic f₀ f₁) (h₁ : Homotopic g₀ g₁) :
    Homotopic (g₀.comp f₀) (g₁.comp f₁)
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
theorem singularPart_smul_right (μ ν : Measure α) (r : ℝ≥0) (hr : r ≠ 0) :
    μ.singularPart (r • ν) = μ.singularPart ν
-- Mathlib/Topology/ContinuousFunction/Algebra.lean
@[to_additive (attr := simp)]
theorem smul_comp [SMul R M] [ContinuousConstSMul R M] (r : R) (f : C(β, M)) (g : C(α, β)) :
    (r • f).comp g = r • f.comp g
-- Mathlib/Data/Finset/NAry.lean
@[simp]
theorem image₂_left [DecidableEq α] (h : t.Nonempty) : image₂ (fun x _ => x) s t = s
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem addHaar_closedBall (x : E) {r : ℝ} (hr : 0 ≤ r) :
    μ (closedBall x r) = ENNReal.ofReal (r ^ finrank ℝ E) * μ (ball 0 1)
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[to_additive (attr := measurability)]
theorem _root_.Finset.aestronglyMeasurable_prod' {ι : Type*} {f : ι → α → M} (s : Finset ι)
    (hf : ∀ i ∈ s, AEStronglyMeasurable (f i) μ) : AEStronglyMeasurable (∏ i ∈ s, f i) μ
-- .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean
theorem coprime_one_right : ∀ n, Coprime n 1
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
/-- If `0 : X ⟶ Y` is a monomorphism, then `X ≅ 0`. -/
@[simps]
def isoZeroOfMonoZero {X Y : C} (h : Mono (0 : X ⟶ Y)) : X ≅ 0
-- Mathlib/Algebra/Group/Equiv/Basic.lean
@[to_additive]
theorem map_ne_one_iff (h : M ≃* N) {x : M} : h x ≠ 1 ↔ x ≠ 1
-- Mathlib/Algebra/Lie/Abelian.lean
@[simp]
theorem mem_maxTrivSubmodule (m : M) : m ∈ maxTrivSubmodule R L M ↔ ∀ x : L, ⁅x, m⁆ = 0
-- Mathlib/Data/Finsupp/Defs.lean
theorem erase_apply [DecidableEq α] {a a' : α} {f : α →₀ M} :
    f.erase a a' = if a' = a then 0 else f a'
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upperCrossingTime_eq_of_upcrossingsBefore_lt (hab : a < b)
    (hn : upcrossingsBefore a b f N ω < n) : upperCrossingTime a b f N n ω = N
-- Mathlib/MeasureTheory/Integral/Lebesgue.lean
theorem setLIntegral_mono {s : Set α} {f g : α → ℝ≥0∞} (hg : Measurable g)
    (hfg : ∀ x ∈ s, f x ≤ g x) : ∫⁻ x in s, f x ∂μ ≤ ∫⁻ x in s, g x ∂μ