ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Topology/Sheaves/PUnit.lean
theorem isSheaf_on_punit_iff_isTerminal (F : Presheaf C (TopCat.of PUnit)) :
    F.IsSheaf ↔ Nonempty (IsTerminal <| F.obj <| op ⊥)
-- Mathlib/MeasureTheory/Measure/Regular.lean
theorem rfl {p : Set α → Prop} : InnerRegularWRT μ p p
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
@[simp]
protected theorem mapL_pow (f : Π i, E i →L[𝕜] E i) (n : ℕ) :
    mapL (f ^ n) = mapL f ^ n
-- Mathlib/Data/Set/Pairwise/Basic.lean
theorem PairwiseDisjoint.elim (hs : s.PairwiseDisjoint f) {i j : ι} (hi : i ∈ s) (hj : j ∈ s)
    (h : ¬Disjoint (f i) (f j)) : i = j
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma Φ_ofNat (n : ℕ) : W.Φ (n + 1) =
    X * W.preΨ' (n + 1) ^ 2 * (if Even n then 1 else W.Ψ₂Sq) -
      W.preΨ' (n + 2) * W.preΨ' n * (if Even n then W.Ψ₂Sq else 1)
-- Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean
/-- Our function tends to zero at zero faster than any $P(x^{-1})$, $P∈ℝ[X]$, tends to infinity. -/
theorem tendsto_polynomial_inv_mul_zero (p : ℝ[X]) :
    Tendsto (fun x ↦ p.eval x⁻¹ * expNegInvGlue x) (𝓝 0) (𝓝 0)
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
lemma mem_iff (hnm : n + 1 = m) (z : Cochain F G n) :
    z ∈ cocycle F G n ↔ δ n m z = 0
-- Mathlib/Topology/Algebra/InfiniteSum/Module.lean
/-- Infinite sums commute with scalar multiplication. Version for scalars living in a
  `DivisionRing`; no summability hypothesis. This could be made to work for a
  `[GroupWithZero γ]` if there was such a thing as `DistribMulActionWithZero`. -/
lemma tsum_const_smul'' {γ : Type*} [DivisionRing γ] [Module γ α] [ContinuousConstSMul γ α]
    [T2Space α] (g : γ) : ∑' (i : β), g • f i = g • ∑' (i : β), f i
-- Mathlib/Order/Interval/Set/Image.lean
lemma AntitoneOn.image_Iic_subset (h : AntitoneOn f (Iic b)) : f '' Iic b ⊆ Ici (f b)
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem dvd_index_map {f : G →* G'} (hf : f.ker ≤ H) :
    H.index ∣ (H.map f).index
-- Mathlib/Analysis/InnerProductSpace/LinearPMap.lean
@[simp]
theorem adjointDomainMkCLMExtend_apply (y : T.adjointDomain) (x : T.domain) :
    adjointDomainMkCLMExtend hT y (x : E) = ⟪(y : F), T x⟫
-- Mathlib/LinearAlgebra/TensorProduct/Basic.lean
theorem ext_threefold {g h : (M ⊗[R] N) ⊗[R] P →ₗ[R] Q}
    (H : ∀ x y z, g (x ⊗ₜ y ⊗ₜ z) = h (x ⊗ₜ y ⊗ₜ z)) : g = h
-- Mathlib/Data/Nat/Defs.lean
lemma leRecOn_succ_left {C : ℕ → Sort*} {n m}
    {next : ∀ {k}, C k → C (k + 1)} (x : C n) (h1 : n ≤ m) (h2 : n + 1 ≤ m) :
    (leRecOn h2 next (next x) : C m) = (leRecOn h1 next x : C m)
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
theorem integral_deriv_comp_mul_deriv {f f' g g' : ℝ → ℝ}
    (hf : ∀ x ∈ uIcc a b, HasDerivAt f (f' x) x)
    (hg : ∀ x ∈ uIcc a b, HasDerivAt g (g' (f x)) (f x)) (hf' : ContinuousOn f' (uIcc a b))
    (hg' : Continuous g') : (∫ x in a..b, (g' ∘ f) x * f' x) = (g ∘ f) b - (g ∘ f) a
-- Mathlib/Algebra/Group/Hom/Defs.lean
/-- Group homomorphisms preserve division. -/
@[to_additive (attr := simp) "Additive group homomorphisms preserve subtraction."]
theorem map_div [Group G] [DivisionMonoid H] [MonoidHomClass F G H] (f : F) :
    ∀ a b, f (a / b) = f a / f b
-- Mathlib/NumberTheory/LSeries/Basic.lean
lemma LSeriesHasSum.LSeriesSummable {f : ℕ → ℂ} {s a : ℂ}
    (h : LSeriesHasSum f s a) : LSeriesSummable f s
-- Mathlib/GroupTheory/FreeGroup/Basic.lean
/-- If `w₁ w₂` are words such that `w₁` reduces to `w₂`, then `w₂` is a sublist of `w₁`. -/
@[to_additive "If `w₁ w₂` are words such that `w₁` reduces to `w₂`, then `w₂` is a sublist of
  `w₁`."]
protected theorem sublist : Red L₁ L₂ → L₂ <+ L₁
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
@[simp]
theorem bmod_sub_cancel (x : Int) (n : Nat) : Int.bmod (x - n) n = Int.bmod x n
-- Mathlib/RingTheory/IntegralClosure/IsIntegralClosure/Basic.lean
@[simp]
theorem isIntegral_algEquiv {A B : Type*} [Ring A] [Ring B] [Algebra R A] [Algebra R B]
    (f : A ≃ₐ[R] B) {x : A} : IsIntegral R (f x) ↔ IsIntegral R x
-- Mathlib/Data/Real/Basic.lean
theorem cauchy_neg : ∀ a, (-a : ℝ).cauchy = -a.cauchy
-- Mathlib/Analysis/Convex/Star.lean
theorem starConvex_pi {ι : Type*} {E : ι → Type*} [∀ i, AddCommMonoid (E i)] [∀ i, SMul 𝕜 (E i)]
    {x : ∀ i, E i} {s : Set ι} {t : ∀ i, Set (E i)} (ht : ∀ ⦃i⦄, i ∈ s → StarConvex 𝕜 (x i) (t i)) :
    StarConvex 𝕜 x (s.pi t)
-- Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean
/-- `NonUnitalSubsemiringClass S R` states that `S` is a type of subsets `s ⊆ R` that
are both an additive submonoid and also a multiplicative subsemigroup. -/
class NonUnitalSubsemiringClass (S : Type*) (R : Type u) [NonUnitalNonAssocSemiring R]
  [SetLike S R] extends AddSubmonoidClass S R : Prop where
  mul_mem : ∀ {s : S} {a b : R}, a ∈ s → b ∈ s → a * b ∈ s
-- Mathlib/Data/Set/Function.lean
theorem mapsTo (h : LeftInvOn f' f s) (hf : SurjOn f s t) :
    MapsTo f' t s
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem id_comp (f : HeytingHom α β) : (HeytingHom.id β).comp f = f
-- Mathlib/Order/Filter/Pointwise.lean
@[to_additive (attr := simp)]
theorem coe_pureOneHom : (pureOneHom : α → Filter α) = pure
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
@[simp]
theorem Path.reverse_reverse [h : HasInvolutiveReverse V] {a b : V} (p : Path a b) :
    p.reverse.reverse = p
-- Mathlib/RingTheory/Noetherian.lean
lemma Submodule.finite_ne_bot_of_independent {ι : Type*} {N : ι → Submodule R M}
    (h : CompleteLattice.Independent N) :
    Set.Finite {i | N i ≠ ⊥}
-- Mathlib/Order/Heyting/Hom.lean
/-- This can't be an instance because of typeclass loops. -/
lemma BoundedLatticeHomClass.toBiheytingHomClass [BooleanAlgebra α] [BooleanAlgebra β]
    [BoundedLatticeHomClass F α β] : BiheytingHomClass F α β
-- Mathlib/Order/Filter/Germ/Basic.lean
@[simp]
theorem map₂_coe (op : β → γ → δ) (f : α → β) (g : α → γ) :
    map₂ op (f : Germ l β) g = fun x => op (f x) (g x)
-- .lake/packages/lean4/src/lean/Init/Data/Fin/Lemmas.lean
theorem natAdd_castAdd (p m : Nat) {n : Nat} (i : Fin n) :
    natAdd m (castAdd p i) = cast (Nat.add_assoc ..) (castAdd p (natAdd m i))
-- Mathlib/GroupTheory/Index.lean
@[to_additive (attr := simp)]
theorem index_top : (⊤ : Subgroup G).index = 1
-- Mathlib/Order/SuccPred/Relation.lean
/-- `(n, m)` is in the transitive closure of a reflexive relation `~` if `i ~ pred i` and
  `pred i ~ i` for all `i` between `n` and `m`. -/
theorem transGen_of_pred_of_reflexive (r : α → α → Prop) {n m : α} (hr : Reflexive r)
    (h1 : ∀ i ∈ Ioc m n, r i (pred i)) (h2 : ∀ i ∈ Ioc n m, r (pred i) i) : TransGen r n m
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
protected theorem nnnorm {_ : MeasurableSpace α} {β : Type*} [SeminormedAddCommGroup β] {f : α → β}
    (hf : StronglyMeasurable f) : StronglyMeasurable fun x => ‖f x‖₊
-- Mathlib/Topology/Order/Lattice.lean
@[fun_prop]
lemma ContinuousOn.sup (hf : ContinuousOn f s) (hg : ContinuousOn g s) :
    ContinuousOn (fun a ↦ f a ⊔ g a) s
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem map_filter_eq_foldr (f : α → β) (p : α → Bool) (as : List α) :
    map f (filter p as) = foldr (fun a bs => bif p a then f a :: bs else bs) [] as
-- Mathlib/Logic/Function/FromTypes.lean
theorem const_succ_apply {n} (p : Fin (n + 1) → Type u) {τ : Type u} (t : τ)
    (x : p 0) : const p t x = const (vecTail p) t
-- .lake/packages/lean4/src/lean/Init/Data/Int/DivModLemmas.lean
theorem bmod_natAbs_plus_one (x : Int) (w : 1 < x.natAbs) : bmod x (x.natAbs + 1) = - x.sign
-- Mathlib/Topology/MetricSpace/Bounded.lean
theorem cobounded_le_cocompact : cobounded α ≤ cocompact α
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
@[simp]
lemma toHomeomorph_symm (e : X ≃ᵈ Y) : e.toHomeomorph.symm = e.symm.toHomeomorph
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem irreducible_pow_sup_of_le (hJ : Irreducible J) (n : ℕ) (hn : ↑n ≤ multiplicity J I) :
    J ^ n ⊔ I = J ^ n
-- Mathlib/GroupTheory/Coxeter/Basic.lean
private theorem relations_liftable {G : Type*} [Group G] {f : B → G} (hf : IsLiftable M f)
    (r : FreeGroup B) (hr : r ∈ M.relationsSet) : (FreeGroup.lift f) r = 1
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- One subspace is less than or equal to another if and only if all its points are in the second
subspace. -/
theorem le_def' (s1 s2 : AffineSubspace k P) : s1 ≤ s2 ↔ ∀ p ∈ s1, p ∈ s2
-- Mathlib/Algebra/Group/AddChar.lean
lemma mulShift_mulShift (ψ : AddChar R M) (r s : R) :
    mulShift (mulShift ψ r) s = mulShift ψ (r * s)
-- Mathlib/Data/Finset/Pointwise.lean
@[to_additive]
theorem singleton_mul (a : α) : {a} * s = s.image (a * ·)
-- Mathlib/Order/GameAdd.lean
/-- The `Prod.GameAdd` relation on well-founded inputs is well-founded.

  In particular, the sum of two well-founded games is well-founded. -/
theorem WellFounded.prod_gameAdd (hα : WellFounded rα) (hβ : WellFounded rβ) :
    WellFounded (Prod.GameAdd rα rβ)
-- Mathlib/Data/ENNReal/Basic.lean
@[simp] theorem top_ne_coe : ∞ ≠ (r : ℝ≥0∞)
-- Mathlib/Data/Finsupp/Pointwise.lean
@[simp]
theorem single_mul (a : α) (b₁ b₂ : β) : single a (b₁ * b₂) = single a b₁ * single a b₂
-- Mathlib/Data/Option/Basic.lean
theorem coe_get {o : Option α} (h : o.isSome) : ((Option.get _ h : α) : Option α) = o
-- Mathlib/Order/Interval/Set/OrdConnected.lean
@[instance]
theorem ordConnected_Ico {a b : α} : OrdConnected (Ico a b)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem le.dest {a b : Int} (h : a ≤ b) : ∃ n : Nat, a + n = b
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem cos_antiperiodic : Function.Antiperiodic cos (π : Angle)
-- Mathlib/Combinatorics/Hall/Finite.lean
theorem hall_cond_of_erase {x : ι} (a : α)
    (ha : ∀ s : Finset ι, s.Nonempty → s ≠ univ → s.card < (s.biUnion t).card)
    (s' : Finset { x' : ι | x' ≠ x }) : s'.card ≤ (s'.biUnion fun x' => (t x').erase a).card
-- Mathlib/Order/Lattice.lean
theorem inf_sup_self : a ⊓ (a ⊔ b) = a
-- Mathlib/Analysis/SpecialFunctions/Pow/Real.lean
@[simp]
lemma rpow_ne_zero (hx : 0 ≤ x) (hy : y ≠ 0) : x ^ y ≠ 0 ↔ x ≠ 0
-- Mathlib/RingTheory/MvPolynomial/Symmetric.lean
lemma psum_def (n : ℕ) : psum σ R n = ∑ i, X i ^ n
-- Mathlib/Order/Heyting/Boundary.lean
/-- **Leibniz rule** for the co-Heyting boundary. -/
theorem boundary_inf (a b : α) : ∂ (a ⊓ b) = ∂ a ⊓ b ⊔ a ⊓ ∂ b
-- Mathlib/Topology/Connected/Basic.lean
theorem preconnectedSpace_iff_connectedComponent :
    PreconnectedSpace α ↔ ∀ x : α, connectedComponent x = univ
-- Mathlib/Combinatorics/Additive/Energy.lean
@[to_additive] lemma le_mulEnergy : s.card * t.card ≤ Eₘ[s, t]
-- Mathlib/GroupTheory/Index.lean
@[to_additive]
theorem index_iInf_le {ι : Type*} [Fintype ι] (f : ι → Subgroup G) :
    (⨅ i, f i).index ≤ ∏ i, (f i).index
-- Mathlib/Topology/UniformSpace/Basic.lean
nonrec theorem UniformContinuous.comp [UniformSpace β] [UniformSpace γ] {g : β → γ} {f : α → β}
    (hg : UniformContinuous g) (hf : UniformContinuous f) : UniformContinuous (g ∘ f)
-- Mathlib/Order/Filter/Basic.lean
theorem tendsto_def {f : α → β} {l₁ : Filter α} {l₂ : Filter β} :
    Tendsto f l₁ l₂ ↔ ∀ s ∈ l₂, f ⁻¹' s ∈ l₁
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
theorem dist_triangle (x y z : α) : dist x z ≤ dist x y + dist y z
-- Mathlib/AlgebraicGeometry/Scheme.lean
/-- The forgetful functor from `Scheme` to `LocallyRingedSpace`. -/
@[simps!]
def forgetToLocallyRingedSpace : Scheme ⥤ LocallyRingedSpace
-- Mathlib/LinearAlgebra/Alternating/Basic.lean
@[simp]
theorem domDomCongr_refl (f : M [⋀^ι]→ₗ[R] N) : f.domDomCongr (Equiv.refl ι) = f
-- Mathlib/Data/List/Zip.lean
theorem unzip_zip_right {l₁ : List α} {l₂ : List β} (h : length l₂ ≤ length l₁) :
    (unzip (zip l₁ l₂)).2 = l₂
-- Mathlib/Data/Finset/Finsupp.lean
@[simp]
theorem mem_pi {f : ι →₀ Finset α} {g : ι →₀ α} : g ∈ f.pi ↔ ∀ i, g i ∈ f i
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
/-- Negation of the condition `P : Prop` in a `ite` is the same as swapping the branches. -/
@[simp] theorem ite_not (p : Prop) [Decidable p] (x y : α) : ite (¬p) x y = ite p y x
-- Mathlib/MeasureTheory/Group/Arithmetic.lean
@[aesop safe 20 apply (rule_sets := [Measurable])]
theorem AEMeasurable.pow (hf : AEMeasurable f μ) (hg : AEMeasurable g μ) :
    AEMeasurable (fun x => f x ^ g x) μ
-- Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean
@[simp]
theorem fst_exp (x : tsze R M) : fst (exp 𝕜 x) = exp 𝕜 x.fst
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
/-- Product of a multiset of elements in a submonoid of a `CommMonoid` is in the submonoid. -/
@[to_additive
      "Sum of a multiset of elements in an `AddSubmonoid` of an `AddCommMonoid` is
      in the `AddSubmonoid`."]
theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
    (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
lemma image_symm (e : α ≃ᵐ β) (s : Set β) : e.symm '' s = e ⁻¹' s
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
theorem hasFDerivWithinAt_pi :
    HasFDerivWithinAt (fun x i => φ i x) (ContinuousLinearMap.pi φ') s x ↔
      ∀ i, HasFDerivWithinAt (φ i) (φ' i) s x
-- Mathlib/Topology/Compactness/Lindelof.lean
theorem IsLindelof.countable_of_discrete [DiscreteTopology X] (hs : IsLindelof s) :
    s.Countable
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem head_lt_ord_of_isGood [Inhabited I] {l : Products I} {o : Ordinal}
    (h : l.isGood (π C (ord I · < o))) (hn : l.val ≠ []) : ord I (l.val.head!) < o
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem prod_mono_left (t : NonUnitalSubring S) : Monotone fun s : NonUnitalSubring R => s.prod t
-- Mathlib/Topology/MetricSpace/Lipschitz.lean
protected theorem dist_right (x : α) : LipschitzWith 1 (dist x)
-- Mathlib/Order/Grade.lean
/-- An `𝕆`-graded order is an order `α` equipped with a strictly monotone function
`grade 𝕆 : α → 𝕆` which preserves order covering (`CovBy`). -/
class GradeOrder (𝕆 α : Type*) [Preorder 𝕆] [Preorder α] where
  /-- The grading function. -/
  protected grade : α → 𝕆
  /-- `grade` is strictly monotonic. -/
  grade_strictMono : StrictMono grade
  /-- `grade` preserves `CovBy`. -/
  covBy_grade ⦃a b : α⦄ : a ⋖ b → grade a ⋖ grade b
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- A compact set in an emetric space is separable, i.e., it is the closure of a countable set. -/
theorem countable_closure_of_compact {s : Set γ} (hs : IsCompact s) :
    ∃ t, t ⊆ s ∧ t.Countable ∧ s = closure t
-- Mathlib/Algebra/Category/ModuleCat/Monoidal/Closed.lean
theorem ihom_map_apply {M N P : ModuleCat.{u} R} (f : N ⟶ P) (g : ModuleCat.of R (M ⟶ N)) :
    (ihom M).map f g = g ≫ f
-- Mathlib/Data/Set/Function.lean
lemma BijOn.symm {g : β → α} (h : InvOn f g t s) (hf : BijOn f s t) : BijOn g t s
-- Mathlib/Analysis/SpecialFunctions/ContinuousFunctionalCalculus/ExpLog.lean
lemma log_exp (a : A) (ha : IsSelfAdjoint a := by cfc_tac) : log (NormedSpace.exp ℝ a) = a
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean
/-- Angles in a vector space are translation invariant -/
@[simp]
theorem angle_const_add (v : V) (v₁ v₂ v₃ : V) : ∠ (v + v₁) (v + v₂) (v + v₃) = ∠ v₁ v₂ v₃
-- Mathlib/Topology/Algebra/Order/Group.lean
@[fun_prop]
protected theorem ContinuousAt.abs (h : ContinuousAt f a) : ContinuousAt (fun x => |f x|) a
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- If a set is disjoint of its translates by infinitely many bounded vectors, then it has measure
zero. This auxiliary lemma proves this assuming additionally that the set is bounded. -/
theorem addHaar_eq_zero_of_disjoint_translates_aux {E : Type*} [NormedAddCommGroup E]
    [NormedSpace ℝ E] [MeasurableSpace E] [BorelSpace E] [FiniteDimensional ℝ E] (μ : Measure E)
    [IsAddHaarMeasure μ] {s : Set E} (u : ℕ → E) (sb : IsBounded s) (hu : IsBounded (range u))
    (hs : Pairwise (Disjoint on fun n => {u n} + s)) (h's : MeasurableSet s) : μ s = 0
-- Mathlib/Order/Interval/Set/Basic.lean
theorem Icc_subset_Ico_union_Icc : Icc a c ⊆ Ico a b ∪ Icc b c
-- Mathlib/Algebra/Group/Aut.lean
@[simp]
protected theorem smul_def {M} [Monoid M] (f : MulAut M) (a : M) : f • a = f a
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
/-- An induction principle for closure membership. If `p` holds for `0`, `1`, and all elements
of `s`, and is preserved under addition, negation, and multiplication, then `p` holds for all
elements of the closure of `s`. -/
@[elab_as_elim]
theorem closure_induction {s : Set R} {p : R → Prop} {x} (h : x ∈ closure s) (mem : ∀ x ∈ s, p x)
    (zero : p 0) (add : ∀ x y, p x → p y → p (x + y)) (neg : ∀ x : R, p x → p (-x))
    (mul : ∀ x y, p x → p y → p (x * y)) : p x
-- Mathlib/Data/Finset/Pointwise.lean
/-- Lift a `MulHom` to `Finset` via `image`. -/
@[to_additive (attr := simps) "Lift an `AddHom` to `Finset` via `image`"]
def imageMulHom : Finset α →ₙ* Finset β
-- Mathlib/Algebra/Polynomial/AlgebraMap.lean
@[simp]
theorem algHom_eval₂_algebraMap {R A B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
    [Algebra R A] [Algebra R B] (p : R[X]) (f : A →ₐ[R] B) (a : A) :
    f (eval₂ (algebraMap R A) a p) = eval₂ (algebraMap R B) (f a) p
-- Mathlib/FieldTheory/Normal.lean
theorem AlgEquiv.restrictNormal_trans [Normal F E] :
    (χ.trans ω).restrictNormal E = (χ.restrictNormal E).trans (ω.restrictNormal E)
-- Mathlib/Data/Real/Sqrt.lean
theorem sqrt_eq_iff_sq_eq (hx : 0 ≤ x) (hy : 0 ≤ y) : √x = y ↔ y ^ 2 = x
-- Mathlib/Topology/PartialHomeomorph.lean
theorem symm_image_target_eq_source : e.symm '' e.target = e.source
-- Mathlib/Data/Real/Hyperreal.lean
@[simp, norm_cast]
theorem coe_zero : ↑(0 : ℝ) = (0 : ℝ*)
-- Mathlib/Order/UpperLower/Basic.lean
@[simp, norm_cast]
theorem coe_bot : ((⊥ : UpperSet α) : Set α) = univ
-- Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean
theorem disconnect_isTotallyDisconnected : S.disconnect.IsTotallyDisconnected
-- Mathlib/Topology/Compactification/OnePoint.lean
theorem isOpen_iff_of_mem (h : ∞ ∈ s) :
    IsOpen s ↔ IsClosed ((↑) ⁻¹' s : Set X)ᶜ ∧ IsCompact ((↑) ⁻¹' s : Set X)ᶜ
-- Mathlib/Algebra/Order/AbsoluteValue.lean
protected theorem map_zero : abv 0 = 0
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean
@[simp, norm_cast]
theorem aemeasurable_coe_nnreal_ennreal_iff {f : α → ℝ≥0} {μ : Measure α} :
    AEMeasurable (fun x => (f x : ℝ≥0∞)) μ ↔ AEMeasurable f μ
-- Mathlib/CategoryTheory/Sites/Subsheaf.lean
theorem Subpresheaf.le_sheafify : G ≤ G.sheafify J
-- Mathlib/Data/Nat/GCD/Basic.lean
theorem Coprime.symmetric : Symmetric Coprime
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
theorem add_left (x y z : E) : inner_ 𝕜 (x + y) z = inner_ 𝕜 x z + inner_ 𝕜 y z
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem upperCrossingTime_lt_bddAbove (hab : a < b) :
    BddAbove {n | upperCrossingTime a b f N n ω < N}
-- Mathlib/RingTheory/AlgebraicIndependent.lean
theorem of_comp (f : A →ₐ[R] A') (hfv : AlgebraicIndependent R (f ∘ x)) :
    AlgebraicIndependent R x
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem erase_cons_head (a : α) (s : Multiset α) : (a ::ₘ s).erase a = s
-- Mathlib/Data/Nat/Factors.lean
theorem pos_of_mem_primeFactorsList {n p : ℕ} (h : p ∈ primeFactorsList n) : 0 < p
-- Mathlib/Order/UpperLower/Basic.lean
theorem prod_mono_right : t₁ ≤ t₂ → s ×ˢ t₁ ≤ s ×ˢ t₂
-- Mathlib/CategoryTheory/Pi/Basic.lean
/-- A product of categories indexed by `Option J` identifies to a binary product. -/
@[simps]
def Pi.optionEquivalence (C' : Option J → Type u₁) [∀ i, Category.{v₁} (C' i)] :
    (∀ i, C' i) ≌ C' none × (∀ (j : J), C' (some j))
-- Mathlib/Algebra/Quaternion.lean
theorem self_add_star' : a + star a = ↑(2 * a.re)
-- Mathlib/MeasureTheory/Decomposition/SignedHahn.lean
private theorem restrictNonposSeq_lt (n : ℕ) (hn : ¬s ≤[i \ ⋃ k ≤ n, restrictNonposSeq s i k] 0) :
    (1 / (findExistsOneDivLT s (i \ ⋃ k ≤ n, restrictNonposSeq s i k) + 1) : ℝ) <
      s (restrictNonposSeq s i n.succ)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem get_set (a : Array α) (i : Fin a.size) (j : Nat) (hj : j < a.size) (v : α) :
    (a.set i v)[j]'(by simp [*]) = if i = j then v else a[j]
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem map_monic_eq_zero_iff (hp : p.Monic) : p.map f = 0 ↔ ∀ x, f x = 0
-- Mathlib/Algebra/Group/Submonoid/Membership.lean
/-- Product of a multiset of elements in a submonoid of a `CommMonoid` is in the submonoid. -/
@[to_additive
      "Sum of a multiset of elements in an `AddSubmonoid` of an `AddCommMonoid` is
      in the `AddSubmonoid`."]
theorem multiset_prod_mem {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (m : Multiset M)
    (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S
-- Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean
theorem withDensityᵥ_toReal {f : α → ℝ≥0∞} (hfm : AEMeasurable f μ) (hf : (∫⁻ x, f x ∂μ) ≠ ∞) :
    (μ.withDensityᵥ fun x => (f x).toReal) =
      @toSignedMeasure α _ (μ.withDensity f) (isFiniteMeasure_withDensity hf)
-- Mathlib/CategoryTheory/Limits/Shapes/FiniteProducts.lean
/-- If a category has all products then in particular it has finite products.
-/
theorem hasFiniteProducts_of_hasProducts [HasProducts.{w} C] : HasFiniteProducts C
-- Mathlib/Algebra/Polynomial/Basic.lean
/-- Monomials generate the additive monoid of polynomials. -/
theorem addSubmonoid_closure_setOf_eq_monomial :
    AddSubmonoid.closure { p : R[X] | ∃ n a, p = monomial n a } = ⊤
-- Mathlib/Combinatorics/SimpleGraph/Matching.lean
theorem IsPerfectMatching.even_card [Fintype V] (h : M.IsPerfectMatching) :
    Even (Fintype.card V)
-- Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean
@[simp]
theorem toCone_proj (B : Bicone F) (j : J) : Fan.proj B.toCone j = B.π j
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
theorem prod_finset_product_right' (r : Finset (α × γ)) (s : Finset γ) (t : γ → Finset α)
    (h : ∀ p : α × γ, p ∈ r ↔ p.2 ∈ s ∧ p.1 ∈ t p.2) {f : α → γ → β} :
    ∏ p ∈ r, f p.1 p.2 = ∏ c ∈ s, ∏ a ∈ t c, f a c
-- Mathlib/Data/Set/Function.lean
theorem injOn_preimage (h : Semiconj f fa fb) {s : Set β} (hb : InjOn fb s)
    (hf : InjOn f (f ⁻¹' s)) : InjOn fa (f ⁻¹' s)
-- Mathlib/Data/List/Perm.lean
theorem Perm.product_left (l : List α) {t₁ t₂ : List β} (p : t₁ ~ t₂) :
    product l t₁ ~ product l t₂
-- Mathlib/Data/List/TFAE.lean
theorem tfae_of_forall (b : Prop) (l : List Prop) (h : ∀ a ∈ l, a ↔ b) : TFAE l
-- Mathlib/MeasureTheory/SetAlgebra.lean
/-- An algebra of sets is closed by intersection. -/
theorem inter_mem (h𝒜 : IsSetAlgebra 𝒜) (s_mem : s ∈ 𝒜) (t_mem : t ∈ 𝒜) :
    s ∩ t ∈ 𝒜
-- Mathlib/Algebra/Module/Submodule/Ker.lean
theorem disjoint_ker {f : F} {p : Submodule R M} :
    Disjoint p (ker f) ↔ ∀ x ∈ p, f x = 0 → x = 0
-- Mathlib/Data/Sum/Basic.lean
@[simp]
theorem map_bijective {f : α → γ} {g : β → δ} :
    Bijective (Sum.map f g) ↔ Bijective f ∧ Bijective g
-- Mathlib/Topology/UniformSpace/Cauchy.lean
/-- The image of a totally bounded set under a uniformly continuous map is totally bounded. -/
theorem TotallyBounded.image [UniformSpace β] {f : α → β} {s : Set α} (hs : TotallyBounded s)
    (hf : UniformContinuous f) : TotallyBounded (f '' s)
-- Mathlib/SetTheory/Ordinal/Notation.lean
theorem repr_add (a b) : repr (a + b) = repr a + repr b
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
/-- The `ShortComplex` in `C` associated to a short complex in `Cᵒᵖ`. -/
@[simps]
def unop (S : ShortComplex Cᵒᵖ) : ShortComplex C
-- Mathlib/Topology/Homeomorph.lean
theorem preimage_frontier (h : X ≃ₜ Y) (s : Set Y) : h ⁻¹' frontier s = frontier (h ⁻¹' s)
-- Mathlib/Algebra/BigOperators/Group/Multiset.lean
@[to_additive (attr := simp)]
theorem prod_replicate (n : ℕ) (a : α) : (replicate n a).prod = a ^ n
-- Mathlib/Topology/Instances/CantorSet.lean
lemma zero_mem_preCantorSet (n : ℕ) : 0 ∈ preCantorSet n
-- Mathlib/Topology/MetricSpace/Completion.lean
/-- The new distance is an extension of the original distance. -/
@[simp]
protected theorem dist_eq (x y : α) : dist (x : Completion α) y = dist x y
-- Mathlib/CategoryTheory/Preadditive/Basic.lean
/-- A category is called preadditive if `P ⟶ Q` is an abelian group such that composition is
    linear in both variables. -/
class Preadditive where
  homGroup : ∀ P Q : C, AddCommGroup (P ⟶ Q) := by infer_instance
  add_comp : ∀ (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R), (f + f') ≫ g = f ≫ g + f' ≫ g := by
    aesop_cat
  comp_add : ∀ (P Q R : C) (f : P ⟶ Q) (g g' : Q ⟶ R), f ≫ (g + g') = f ≫ g + f ≫ g' := by
    aesop_cat