ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
@[trans]
theorem IsBigO.trans_isEquivalent {f : α → β₂} {g₁ g₂ : α → β} (h : f =O[l] g₁) (h₂ : g₁ ~[l] g₂) :
    f =O[l] g₂
-- Mathlib/Analysis/Normed/Module/Ray.lean
theorem norm_sub (h : SameRay ℝ x y) : ‖x - y‖ = |‖x‖ - ‖y‖|
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem transnumAuxSeq_def : f.transnumAuxSeq = fun n : ℕ => (f ^ (2 ^ n : ℕ)) 0 / 2 ^ n
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem mul_apply_right (f g : MonoidAlgebra k G) (x : G) :
    (f * g) x = g.sum fun a b => f (x * a⁻¹) * b
-- Mathlib/Algebra/Polynomial/RingDivision.lean
theorem degree_eq_one_of_irreducible_of_root (hi : Irreducible p) {x : R} (hx : IsRoot p x) :
    degree p = 1
-- Mathlib/CategoryTheory/Triangulated/Subcategory.lean
lemma ext₁' (h₂ : S.P T.obj₂) (h₃ : S.P T.obj₃) :
    CategoryTheory.isoClosure S.P T.obj₁
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem Monic.mul_right_ne_zero (hp : Monic p) {q : R[X]} (hq : q ≠ 0) : p * q ≠ 0
-- Mathlib/CategoryTheory/Adhesive.lean
theorem Adhesive.isPullback_of_isPushout_of_mono_left [Adhesive C] (H : IsPushout f g h i)
    [Mono f] : IsPullback f g h i
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Ioo_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ioo a b = Ioo (b / c) (a / c)
-- Mathlib/MeasureTheory/Measure/Typeclasses.lean
theorem restrict_Ioi_eq_restrict_Ici : μ.restrict (Ioi a) = μ.restrict (Ici a)
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem neighborSet_snd_subgraphOfAdj {v w : V} (hvw : G.Adj v w) :
    (G.subgraphOfAdj hvw).neighborSet w = {v}
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem top_add : ⊤ + μ = ⊤
-- Mathlib/Algebra/Order/Floor.lean
theorem map_fract (f : F) (hf : StrictMono f) (a : α) : fract (f a) = f (fract a)
-- Mathlib/Algebra/Algebra/NonUnitalSubalgebra.lean
@[simp]
theorem coeSubtype : (subtype s : s → A) = ((↑) : s → A)
-- Mathlib/MeasureTheory/Measure/AEDisjoint.lean
theorem measure_diff_left (h : AEDisjoint μ s t) : μ (s \ t) = μ s
-- Mathlib/Data/Stream/Init.lean
theorem append_stream_head_tail (s : Stream' α) : [head s] ++ₛ tail s = s
-- Mathlib/Init/Algebra/Classes.lean
theorem lt_of_lt_of_incomp {α : Sort u} {lt : α → α → Prop} [IsStrictWeakOrder α lt]
    [DecidableRel lt] : ∀ {a b c}, lt a b → ¬lt b c ∧ ¬lt c b → lt a c
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma epi₂ (h : T.mor₃ = 0) : Epi T.mor₂
-- Mathlib/NumberTheory/Pell.lean
/-- A fundamental solution has positive `x`. -/
theorem x_pos {a : Solution₁ d} (h : IsFundamental a) : 0 < a.x
-- Mathlib/Topology/Order/UpperLowerSetTopology.lean
lemma toLowerSet_le_iff {a b : α} : toLowerSet a ≤ toLowerSet b ↔ a ≤ b
-- Mathlib/RingTheory/DiscreteValuationRing/Basic.lean
/-- An integral domain in which there is an irreducible element `p`
such that every nonzero element is associated to a power of `p` is a unique factorization domain.
See `DiscreteValuationRing.ofHasUnitMulPowIrreducibleFactorization`. -/
theorem toUniqueFactorizationMonoid : UniqueFactorizationMonoid R
-- Mathlib/Algebra/Order/Floor.lean
@[simp]
theorem ceil_sub_one (a : α) : ⌈a - 1⌉ = ⌈a⌉ - 1
-- Mathlib/Algebra/Group/Subsemigroup/Operations.lean
@[to_additive]
theorem map_iSup {ι : Sort*} (f : M →ₙ* N) (s : ι → Subsemigroup M) :
    (iSup s).map f = ⨆ i, (s i).map f
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem symm_refl : (RingEquiv.refl R).symm = RingEquiv.refl R
-- Mathlib/Algebra/Associated/Basic.lean
theorem quot_mk_eq_mk [Monoid α] (a : α) : Quot.mk Setoid.r a = Associates.mk a
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem map_refl : map (OrderIso.refl α) = OrderIso.refl _
-- Mathlib/Data/Vector/MapLemmas.lean
theorem map₂_comm (f : α → α → β) (comm : ∀ a₁ a₂, f a₁ a₂ = f a₂ a₁) :
    map₂ f xs ys = map₂ f ys xs
-- Mathlib/Order/SuccPred/Basic.lean
/-- Induction principle on a type with a `PredOrder` for all elements below a given element `m`. -/
@[elab_as_elim]
theorem Pred.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, n ≤ m → P n → P (pred n)) ⦃n : α⦄
    (hmn : n ≤ m) : P n
-- Mathlib/Order/Interval/Set/OrdConnected.lean
theorem image_Ioc (e : α ↪o β) (he : OrdConnected (range e)) (x y : α) :
    e '' Ioc x y = Ioc (e x) (e y)
-- Mathlib/Logic/Nonempty.lean
@[simp]
theorem nonempty_prod : Nonempty (α × β) ↔ Nonempty α ∧ Nonempty β
-- Mathlib/CategoryTheory/Monoidal/OfHasFiniteProducts.lean
@[simp]
theorem whiskerLeft (X : C) {Y Z : C} (f : Y ⟶ Z) : X ◁ f = Limits.prod.map (𝟙 X) f
-- Mathlib/RingTheory/WittVector/Teichmuller.lean
private theorem map_teichmullerFun (f : R →+* S) (r : R) :
    map f (teichmullerFun p r) = teichmullerFun p (f r)
-- Mathlib/MeasureTheory/Measure/MutuallySingular.lean
@[simp]
lemma measure_compl_nullSet (h : μ ⟂ₘ ν) : ν h.nullSetᶜ = 0
-- Mathlib/MeasureTheory/Measure/OpenPos.lean
theorem measure_Ioo_eq_zero [DenselyOrdered X] {a b : X} : μ (Ioo a b) = 0 ↔ b ≤ a
-- Mathlib/Analysis/SpecialFunctions/Log/ENNRealLog.lean
@[simp] lemma log_lt_zero_iff {x : ℝ≥0∞} : log x < 0 ↔ x < 1
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean
theorem ContDiffWithinAt.cos {n} (hf : ContDiffWithinAt ℝ n f s x) :
    ContDiffWithinAt ℝ n (fun x => Real.cos (f x)) s x
-- Mathlib/CategoryTheory/Limits/IsLimit.lean
/-- Two morphisms into a limit are equal if their compositions with
  each cone morphism are equal. -/
theorem hom_ext (h : IsLimit t) {W : C} {f f' : W ⟶ t.pt}
    (w : ∀ j, f ≫ t.π.app j = f' ≫ t.π.app j) :
    f = f'
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem integral_inv (h : (0 : ℝ) ∉ [[a, b]]) : ∫ x in a..b, x⁻¹ = log (b / a)
-- Mathlib/CategoryTheory/EqToHom.lean
@[simp]
theorem eqToIso_refl {X : C} (p : X = X) : eqToIso p = Iso.refl X
-- Mathlib/SetTheory/Game/State.lean
/-- `SetTheory.PGame.State S` describes how to interpret `s : S` as a state of a combinatorial game.
Use `SetTheory.PGame.ofState s` or `SetTheory.Game.ofState s` to construct the game.

`SetTheory.PGame.State.l : S → Finset S` and `SetTheory.PGame.State.r : S → Finset S` describe
the states reachable by a move by Left or Right. `SetTheory.PGame.State.turnBound : S → ℕ`
gives an upper bound on the number of possible turns remaining from this state.
-/
class State (S : Type u) where
  turnBound : S → ℕ
  l : S → Finset S
  r : S → Finset S
  left_bound : ∀ {s t : S}, t ∈ l s → turnBound t < turnBound s
  right_bound : ∀ {s t : S}, t ∈ r s → turnBound t < turnBound s
-- Mathlib/Order/Category/BddLat.lean
@[simp]
theorem coe_of (α : Type*) [Lattice α] [BoundedOrder α] : ↥(of α) = α
-- Mathlib/Data/TypeVec.lean
theorem typevecCasesCons₂_appendFun (n : ℕ) (t t' : Type*) (v v' : TypeVec n)
    {β : (v ::: t) ⟹ (v' ::: t') → Sort*}
    (F : ∀ (f : t → t') (fs : v ⟹ v'), β (fs ::: f))
    (f fs) :
    typevecCasesCons₂ n t t' v v' F (fs ::: f) = F f fs
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem eqRec_heq {α : Sort u} {φ : α → Sort v} {a a' : α} : (h : a = a') → (p : φ a) → HEq (Eq.recOn (motive := fun x _ => φ x) h p) p
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[measurability]
theorem measurable_from_top [MeasurableSpace β] {f : α → β} : Measurable[⊤] f
-- Mathlib/Computability/Halting.lean
/-- **Rice's Theorem** -/
theorem rice (C : Set (ℕ →. ℕ)) (h : ComputablePred fun c => eval c ∈ C) {f g} (hf : Nat.Partrec f)
    (hg : Nat.Partrec g) (fC : f ∈ C) : g ∈ C
-- Mathlib/Combinatorics/Enumerative/Composition.lean
theorem eq_ones_iff_length {c : Composition n} : c = ones n ↔ c.length = n
-- Mathlib/Data/Complex/Basic.lean
theorem add_conj (z : ℂ) : z + conj z = (2 * z.re : ℝ)
-- Mathlib/Algebra/Ring/Semiconj.lean
@[simp]
theorem sub_right (h : SemiconjBy a x y) (h' : SemiconjBy a x' y') :
    SemiconjBy a (x - x') (y - y')
-- Mathlib/Topology/EMetricSpace/Basic.lean
theorem uniformity_basis_edist_inv_two_pow :
    (𝓤 α).HasBasis (fun _ => True) fun n : ℕ => { p : α × α | edist p.1 p.2 < 2⁻¹ ^ n }
-- Mathlib/Tactic/LinearCombination.lean
theorem mul_pf [Mul α] (p₁ : (a₁:α) = b₁) (p₂ : a₂ = b₂) : a₁ * a₂ = b₁ * b₂
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_ennreal_top : ((⊤ : ℝ≥0∞) : EReal) = ⊤
-- Mathlib/Data/Set/Finite.lean
theorem Finite.exists_finset_coe {s : Set α} (h : s.Finite) : ∃ s' : Finset α, ↑s' = s
-- Mathlib/Topology/Separation.lean
theorem IsCompact.preimage_continuous [CompactSpace X] [T2Space Y] {f : X → Y} {s : Set Y}
    (hs : IsCompact s) (hf : Continuous f) : IsCompact (f ⁻¹' s)
-- Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean
theorem eq_bot_of_rank_le_one (h : Module.rank F S ≤ 1) [Module.Free F S] : S = ⊥
-- Mathlib/Data/Matrix/Basic.lean
/-- Permuting a vector on the left of a dot product can be transferred to the right. -/
@[simp]
theorem comp_equiv_symm_dotProduct (e : m ≃ n) : u ∘ e.symm ⬝ᵥ x = u ⬝ᵥ x ∘ e
-- Mathlib/Dynamics/PeriodicPts.lean
theorem minimalPeriod_prod_map (f : α → α) (g : β → β) (x : α × β) :
    minimalPeriod (Prod.map f g) x = (minimalPeriod f x.1).lcm (minimalPeriod g x.2)
-- Mathlib/Order/Hom/CompleteLattice.lean
@[simp]
theorem coe_id : ⇑(sInfHom.id α) = id
-- Mathlib/Order/Filter/Bases.lean
protected theorem generate (B : FilterBasis α) : generate B.sets = B.filter
-- Mathlib/ModelTheory/Satisfiability.lean
theorem IsMaximal.mem_or_not_mem (h : T.IsMaximal) (φ : L.Sentence) : φ ∈ T ∨ φ.not ∈ T
-- Mathlib/Order/UpperLower/Basic.lean
@[norm_cast] -- Porting note: no longer a `simp`
theorem coe_iSup₂ (f : ∀ i, κ i → UpperSet α) :
    (↑(⨆ (i) (j), f i j) : Set α) = ⋂ (i) (j), f i j
-- .lake/packages/batteries/Batteries/Data/UInt.lean
theorem UInt8.toNat_mod (x y : UInt8) : (x % y).toNat = x.toNat % y.toNat
-- Mathlib/FieldTheory/Finite/Polynomial.lean
theorem finrank_R [Fintype σ] : FiniteDimensional.finrank K (R σ K) = Fintype.card (σ → K)
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem coeSubtype : ⇑S.subtype = ((↑) : S → M)
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem inf_equiv_inf {a₁ b₁ a₂ b₂ : CauSeq α abs} (ha : a₁ ≈ a₂) (hb : b₁ ≈ b₂) :
    a₁ ⊓ b₁ ≈ a₂ ⊓ b₂
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
/-- Two submonoids are equal if they have the same elements. -/
@[to_additive (attr := ext) "Two `AddSubmonoid`s are equal if they have the same elements."]
theorem ext {S T : Submonoid M} (h : ∀ x, x ∈ S ↔ x ∈ T) : S = T
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem toOpposite_symm_apply (r : Rᵐᵒᵖ) : (toOpposite R).symm r = unop r
-- Mathlib/Algebra/AddConstMap/Basic.lean
@[scoped simp]
theorem map_const [AddZeroClass G] [Add H] [AddConstMapClass F G H a b] (f : F) :
    f a = f 0 + b
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
@[simp]
protected theorem dense_span (b : HilbertBasis ι 𝕜 E) :
    (span 𝕜 (Set.range b)).topologicalClosure = ⊤
-- Mathlib/Algebra/Homology/Embedding/Basic.lean
/-- An embedding of complex shapes `e` satisfies `e.IsRelIff` if the implication
`e.rel` is an equivalence. -/
class IsRelIff : Prop where
  rel' (i₁ i₂ : ι) (h : c'.Rel (e.f i₁) (e.f i₂)) : c.Rel i₁ i₂
-- Mathlib/Analysis/Convex/Cone/Basic.lean
/-- A blunt cone (one not containing `0`) is always salient. -/
theorem Blunt.salient {S : ConvexCone 𝕜 E} : S.Blunt → S.Salient
-- Mathlib/Algebra/Polynomial/Monic.lean
theorem Monic.add_of_right (hq : Monic q) (hpq : degree p < degree q) : Monic (p + q)
-- Mathlib/Analysis/Convex/Side.lean
@[simp]
theorem _root_.AffineEquiv.sOppSide_map_iff {s : AffineSubspace R P} {x y : P} (f : P ≃ᵃ[R] P') :
    (s.map ↑f).SOppSide (f x) (f y) ↔ s.SOppSide x y
-- Mathlib/Data/Set/Basic.lean
theorem mem_def {a : α} {s : Set α} : a ∈ s ↔ s a
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem add_compLpL [Fact (1 ≤ p)] (L L' : E →L[𝕜] F) :
    (L + L').compLpL p μ = L.compLpL p μ + L'.compLpL p μ
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean
@[simp high]
lemma realContinuousMapZeroOfNNReal_apply_comp_toReal (φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A)
    (f : C(X, ℝ≥0)₀) :
    φ.realContinuousMapZeroOfNNReal ((ContinuousMapZero.mk ⟨toReal, continuous_coe⟩ rfl).comp f) =
      φ f
-- Mathlib/Topology/UniformSpace/Basic.lean
theorem comp_open_symm_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, IsOpen t ∧ SymmetricRel t ∧ t ○ t ⊆ s
-- Mathlib/Data/Set/Pointwise/SMul.lean
@[to_additive]
theorem union_smul : (s₁ ∪ s₂) • t = s₁ • t ∪ s₂ • t
-- Mathlib/Data/Multiset/Basic.lean
theorem forall_mem_cons {p : α → Prop} {a : α} {s : Multiset α} :
    (∀ x ∈ a ::ₘ s, p x) ↔ p a ∧ ∀ x ∈ s, p x
-- Mathlib/GroupTheory/MonoidLocalization/Basic.lean
/-- Given a MonoidHom `f : M →* N` and Submonoid `S ⊆ M` such that `f(S) ⊆ Nˣ`, for all
`y ∈ S`, `(f y)⁻¹` is unique. -/
@[to_additive
    "Given an AddMonoidHom `f : M →+ N` and Submonoid `S ⊆ M` such that
`f(S) ⊆ AddUnits N`, for all `y ∈ S`, `- (f y)` is unique."]
theorem inv_unique {f : M →* N} (h : ∀ y : S, IsUnit (f y)) {y : S} {z : N} (H : f y * z = 1) :
    (IsUnit.liftRight (f.restrict S) h y)⁻¹ = z
-- .lake/packages/batteries/Batteries/Data/List/Basic.lean
@[csimp] theorem replaceF_eq_replaceFTR : @replaceF = @replaceFTR
-- Mathlib/InformationTheory/Hamming.lean
@[simp, push_cast]
theorem nndist_eq_hammingDist (x y : Hamming β) :
    nndist x y = hammingDist (ofHamming x) (ofHamming y)
-- Mathlib/Order/Filter/SmallSets.lean
@[simp]
theorem smallSets_bot : (⊥ : Filter α).smallSets = pure ∅
-- Mathlib/Algebra/Order/Field/Rat.lean
@[simp, norm_cast] lemma coe_div (p q : ℚ≥0) : ((p / q : ℚ≥0) : ℚ) = p / q
-- Mathlib/Algebra/Quandle.lean
/-- A *rack* is an automorphic set (a set with an action on itself by
bijections) that is self-distributive.  It is a shelf such that each
element's action is invertible.

The notations `x ◃ y` and `x ◃⁻¹ y` denote the action and the
inverse action, respectively, and they are right associative.
-/
class Rack (α : Type u) extends Shelf α where
  /-- The inverse actions of the elements -/
  invAct : α → α → α
  /-- Proof of left inverse -/
  left_inv : ∀ x, Function.LeftInverse (invAct x) (act x)
  /-- Proof of right inverse -/
  right_inv : ∀ x, Function.RightInverse (invAct x) (act x)
-- Mathlib/Data/Sum/Basic.lean
theorem exists_of_isRight_left (h₁ : LiftRel r s x y) (h₂ : x.isRight) :
    ∃ b d, s b d ∧ x = inr b ∧ y = inr d
-- Mathlib/Data/Ordmap/Ordset.lean
theorem valid'_nil {o₁ o₂} (h : Bounded nil o₁ o₂) : Valid' o₁ (@nil α) o₂
-- Mathlib/Geometry/Manifold/Diffeomorph.lean
@[simp]
theorem contMDiff_transDiffeomorph_left {f : M → M'} :
    ContMDiff (I.transDiffeomorph e) I' n f ↔ ContMDiff I I' n f
-- Mathlib/Probability/Martingale/Upcrossing.lean
@[simp]
theorem lowerCrossingTime_zero : lowerCrossingTime a b f N 0 = hitting f (Set.Iic a) ⊥ N
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
@[simp]
theorem rpow_eq_top_iff {x : ℝ≥0∞} {y : ℝ} : x ^ y = ⊤ ↔ x = 0 ∧ y < 0 ∨ x = ⊤ ∧ 0 < y
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem insert_replicate_ne {a b : α} (h : !b == a) :
    (replicate n a).insert b = b :: replicate n a
-- Mathlib/LinearAlgebra/BilinearForm/Hom.lean
/-- Apply a linear map on the output of a bilinear form. -/
@[simps!]
def compBilinForm (f : R →ₗ[R'] R') (B : BilinForm R M) : BilinForm R' M
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem eq_zero_of_sign_eq_zero : ∀ {a : Int}, sign a = 0 → a = 0
-- Mathlib/LinearAlgebra/Basis.lean
/-- Apply the linear equivalence `f` to the basis vectors. -/
@[simps]
protected def map : Basis ι R M'
-- Mathlib/Algebra/Order/Group/Defs.lean
/-- An ordered commutative group is a commutative group
with a partial order in which multiplication is strictly monotone. -/
class OrderedCommGroup (α : Type u) extends CommGroup α, PartialOrder α where
  /-- Multiplication is monotone in an ordered commutative group. -/
  protected mul_le_mul_left : ∀ a b : α, a ≤ b → ∀ c : α, c * a ≤ c * b
-- Mathlib/Data/Matroid/Basic.lean
theorem Base.encard_diff_comm (hB₁ : M.Base B₁) (hB₂ : M.Base B₂) :
    (B₁ \ B₂).encard = (B₂ \ B₁).encard
-- Mathlib/Data/Matrix/Kronecker.lean
theorem ofNat_kronecker [Semiring α] [DecidableEq l] (a : ℕ) [a.AtLeastTwo] (B : Matrix m n α) :
    (no_index (OfNat.ofNat a) : Matrix l l α) ⊗ₖ B =
      Matrix.reindex (.prodComm _ _) (.prodComm _ _)
        (blockDiagonal fun _ => (OfNat.ofNat a : α) • B)
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fstHom_comp_map (f : M →ₗ[R'] N) :
    (fstHom R' R' N).comp (map f) = fstHom R' R' M
-- Mathlib/CategoryTheory/Galois/Basic.lean
/-- An object whose fiber is inhabited is not initial. -/
lemma not_initial_of_inhabited {X : C} (x : F.obj X) (h : IsInitial X) : False
-- Mathlib/Data/Nat/Pairing.lean
theorem iInf_unpair {α} [CompleteLattice α] (f : ℕ → ℕ → α) :
    ⨅ n : ℕ, f n.unpair.1 n.unpair.2 = ⨅ (i : ℕ) (j : ℕ), f i j
-- Mathlib/CategoryTheory/Monoidal/Opposite.lean
@[simp] lemma mop_inv_associator (X Y Z : C) :
    (α_ X Y Z).inv.mop = (α_ (mop Z) (mop Y) (mop X)).hom
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem cancel_right {f₁ f₂ : C(β, γ)} {g : C(α, β)} (hg : Surjective g) :
    f₁.comp g = f₂.comp g ↔ f₁ = f₂
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem _root_.ClosedEmbedding.setIntegral_map [TopologicalSpace X] [BorelSpace X] {Y}
    [MeasurableSpace Y] [TopologicalSpace Y] [BorelSpace Y] {g : X → Y} {f : Y → E} (s : Set Y)
    (hg : ClosedEmbedding g) : ∫ y in s, f y ∂Measure.map g μ = ∫ x in g ⁻¹' s, f (g x) ∂μ
-- Mathlib/MeasureTheory/Group/Prod.lean
@[to_additive]
theorem measure_mul_right_ne_zero (h2s : μ s ≠ 0) (y : G) : μ ((fun x => x * y) ⁻¹' s) ≠ 0
-- Mathlib/SetTheory/Ordinal/Basic.lean
theorem lt_ord_succ_card (o : Ordinal) : o < (succ o.card).ord
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- For a non-trivial space, the affine span of a set is `⊤` iff its vector span is `⊤`. -/
theorem affineSpan_eq_top_iff_vectorSpan_eq_top_of_nontrivial {s : Set P} [Nontrivial P] :
    affineSpan k s = ⊤ ↔ vectorSpan k s = ⊤
-- Mathlib/Algebra/MonoidAlgebra/Basic.lean
theorem single_mul_apply_of_not_exists_mul [Mul G] (r : k) {g g' : G} (x : MonoidAlgebra k G)
    (h : ¬∃ d, g' = g * d) : (single g r * x) g' = 0
-- Mathlib/Algebra/Polynomial/Expand.lean
theorem coeff_expand {p : ℕ} (hp : 0 < p) (f : R[X]) (n : ℕ) :
    (expand R p f).coeff n = if p ∣ n then f.coeff (n / p) else 0
-- Mathlib/NumberTheory/Padics/PadicNumbers.lean
theorem norm_zero_iff (f : PadicSeq p) : f.norm = 0 ↔ f ≈ 0
-- Mathlib/Data/Fin/Tuple/Finset.lean
lemma mem_piFinset_succ {x : ∀ i, α i} {s : ∀ i, Finset (α i)} :
    x ∈ piFinset s ↔ x 0 ∈ s 0 ∧ tail x ∈ piFinset (tail s)
-- Mathlib/Data/Finsupp/Order.lean
lemma coe_strictMono : Monotone (Finsupp.toFun : (ι →₀ α) → ι → α)
-- Mathlib/Order/Heyting/Regular.lean
protected theorem IsRegular.eq : IsRegular a → aᶜᶜ = a
-- Mathlib/Data/Sum/Order.lean
@[simp]
theorem not_inr_le_inl [LE α] [LE β] {a : α} {b : β} : ¬inr b ≤ inl a
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma Ψ_one : W.Ψ 1 = 1
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem subset_set_smul_iff₀ (ha : a ≠ 0) {A B : Set β} : A ⊆ a • B ↔ a⁻¹ • A ⊆ B
-- Mathlib/NumberTheory/Pell.lean
@[simp]
theorem x_neg (a : Solution₁ d) : (-a).x = -a.x
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
theorem isReal_conjugate_iff {φ : K →+* ℂ} : IsReal (conjugate φ) ↔ IsReal φ
-- Mathlib/Topology/Instances/EReal.lean
lemma limsup_add_le_add_limsup
    (h : limsup u f ≠ ⊥ ∨ limsup v f ≠ ⊤) (h' : limsup u f ≠ ⊤ ∨ limsup v f ≠ ⊥) :
    limsup (u + v) f ≤ (limsup u f) + (limsup v f)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
@[simp]
theorem coe_comap (s : NonUnitalSubsemiring S) (f : F) : (s.comap f : Set R) = f ⁻¹' s
-- Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean
theorem norm_cexp_neg_mul_sq (b : ℂ) (x : ℝ) :
    ‖Complex.exp (-b * (x : ℂ) ^ 2)‖ = exp (-b.re * x ^ 2)
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[refl]
protected theorem Reachable.refl (u : V) : G.Reachable u u
-- Mathlib/Topology/Algebra/Module/WeakDual.lean
/-- A set in `E` which is open in the weak topology is open. -/
theorem WeakSpace.isOpen_of_isOpen (V : Set E)
    (hV : IsOpen ((continuousLinearMapToWeakSpace 𝕜 E) '' V : Set (WeakSpace 𝕜 E))) : IsOpen V
-- Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean
@[simp]
lemma Hom.comp_eq_comp {X Y Z : WalkingMulticospan fst snd}
    (f : X ⟶ Y) (g : Y ⟶ Z) : Hom.comp f g = f ≫ g
-- Mathlib/Algebra/Ring/Hom/Defs.lean
@[simp]
theorem coe_monoidHom_id : (id α : α →* α) = MonoidHom.id α
-- Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean
/-- A measurable set `t ⊇ s` such that `μ t = μ s`. It even satisfies `μ (t ∩ u) = μ (s ∩ u)` for
any measurable set `u` if `μ s ≠ ∞`, see `measure_toMeasurable_inter`.
(This property holds without the assumption `μ s ≠ ∞` when the space is s-finite -- for example
σ-finite), see `measure_toMeasurable_inter_of_sFinite`).
If `s` is a null measurable set, then
we also have `t =ᵐ[μ] s`, see `NullMeasurableSet.toMeasurable_ae_eq`.
This notion is sometimes called a "measurable hull" in the literature. -/
irreducible_def toMeasurable (μ : Measure α) (s : Set α) : Set α
-- Mathlib/Order/Disjointed.lean
theorem disjointed_subset (f : ℕ → Set α) (n : ℕ) : disjointed f n ⊆ f n
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive (attr := simp)]
theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b
-- Mathlib/Topology/Homotopy/Equiv.lean
@[continuity]
theorem continuous (h : HomotopyEquiv X Y) : Continuous h
-- Mathlib/Data/List/Rotate.lean
theorem rotate'_eq_drop_append_take :
    ∀ {l : List α} {n : ℕ}, n ≤ l.length → l.rotate' n = l.drop n ++ l.take n
-- Mathlib/Analysis/Convex/Cone/Basic.lean
@[simp]
theorem coe_mk {s : Set E} {h₁ h₂} : ↑(@mk 𝕜 _ _ _ _ s h₁ h₂) = s
-- Mathlib/Analysis/Calculus/Deriv/Comp.lean
theorem HasFDerivAt.comp_hasDerivWithinAt (hl : HasFDerivAt l l' (f x))
    (hf : HasDerivWithinAt f f' s x) : HasDerivWithinAt (l ∘ f) (l' f') s x
-- Mathlib/Topology/Maps/Basic.lean
protected theorem isOpen_preimage (hf : QuotientMap f) {s : Set Y} : IsOpen (f ⁻¹' s) ↔ IsOpen s
-- Mathlib/Algebra/Opposites.lean
@[simp] lemma op_add [Add α] (x y : α) : op (x + y) = op x + op y
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_inter_left [DecidableEq α] (hf : Injective2 f) :
    image₂ f (s ∩ s') t = image₂ f s t ∩ image₂ f s' t
-- Mathlib/Topology/Separation.lean
theorem Set.Finite.isGδ {s : Set X} [T1Space X] (hs : s.Finite) : IsGδ s
-- Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean
@[simp] lemma negMulLog_zero : negMulLog (0 : ℝ) = 0
-- Mathlib/Algebra/Group/Submonoid/Basic.lean
@[to_additive]
theorem copy_eq {s : Set M} (hs : s = S) : S.copy s hs = S
-- Mathlib/Algebra/Module/Submodule/Pointwise.lean
@[simp]
theorem neg_sup (S T : Submodule R M) : -(S ⊔ T) = -S ⊔ -T
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_two (x : ℝ≥0∞) : x ^ (2 : ℝ) = x ^ 2
-- Mathlib/Algebra/GCDMonoid/Nat.lean
theorem exists_unit_of_abs (a : ℤ) : ∃ (u : ℤ) (_ : IsUnit u), (Int.natAbs a : ℤ) = u * a
-- Mathlib/AlgebraicGeometry/OpenImmersion.lean
@[simp, reassoc]
theorem lift_fac (H' : Set.range g.1.base ⊆ Set.range f.1.base) : lift f g H' ≫ f = g
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
@[simp]
theorem stalkToFiberRingHom_germ' (U : Opens (ProjectiveSpectrum.top 𝒜))
    (x : ProjectiveSpectrum.top 𝒜) (hx : x ∈ U) (s : (Proj.structureSheaf 𝒜).1.obj (op U)) :
    stalkToFiberRingHom 𝒜 x ((Proj.structureSheaf 𝒜).presheaf.germ ⟨x, hx⟩ s) = (s.1 ⟨x, hx⟩ : _)
-- Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean
lemma equation_add_iff (x₁ x₂ y₁ L : R) :
    W.Equation (W.addX x₁ x₂ L) (W.negAddY x₁ x₂ y₁ L) ↔
      (W.addPolynomial x₁ y₁ L).eval (W.addX x₁ x₂ L) = 0
-- Mathlib/Logic/Basic.lean
theorem not_iff : ¬(a ↔ b) ↔ (¬a ↔ b)
-- Mathlib/Data/List/Chain.lean
theorem Chain'.drop (h : Chain' R l) (n : ℕ) : Chain' R (drop n l)
-- Mathlib/Data/ZMod/Basic.lean
theorem val_le {n : ℕ} [NeZero n] (a : ZMod n) : a.val ≤ n
-- Mathlib/Topology/Category/LightProfinite/Limits.lean
theorem pullback_snd_eq :
    LightProfinite.pullback.snd f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.snd f g
-- Mathlib/Topology/Category/LightProfinite/EffectiveEpi.lean
theorem effectiveEpi_iff_surjective {X Y : LightProfinite.{u}} (f : X ⟶ Y) :
    EffectiveEpi f ↔ Function.Surjective f
-- Mathlib/Probability/CondCount.lean
theorem condCount_empty {s : Set Ω} : condCount s ∅ = 0