ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Mono.lean
theorem epi_inl_of_is_pushout_of_epi {t : PushoutCocone f g} (ht : IsColimit t) [Epi g] :
    Epi t.inl
-- Mathlib/Data/Matrix/Basic.lean
theorem sum_apply [AddCommMonoid α] (i : m) (j : n) (s : Finset β) (g : β → Matrix m n α) :
    (∑ c ∈ s, g c) i j = ∑ c ∈ s, g c i j
-- Mathlib/Data/Finset/NAry.lean
theorem image₂_subset (hs : s ⊆ s') (ht : t ⊆ t') : image₂ f s t ⊆ image₂ f s' t'
-- Mathlib/Data/Matrix/RowCol.lean
@[simp]
theorem updateColumn_eq_self [DecidableEq n] (A : Matrix m n α) (i : n) :
    (A.updateColumn i fun j => A j i) = A
-- Mathlib/Logic/Equiv/Set.lean
@[simp]
theorem image_eq_iff_eq {α β} (e : α ≃ β) (s t : Set α) : e '' s = e '' t ↔ s = t
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem isometryEquivMap.apply_symm_apply {E : AffineSubspace 𝕜 P₁'} [Nonempty E]
    {φ : P₁' →ᵃⁱ[𝕜] P₂} (x : E.map φ.toAffineMap) : φ ((E.isometryEquivMap φ).symm x) = x
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/HasPullback.lean
@[simp]
lemma pullback.map_id {X Y Z : C}
    {f : X ⟶ Z} {g : Y ⟶ Z} [HasPullback f g] :
    pullback.map f g f g (𝟙 _) (𝟙 _) (𝟙 _) (by simp) (by simp) = 𝟙 _
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[reassoc (attr := simp)]
theorem colimit.isoColimitCocone_ι_hom {F : J ⥤ C} [HasColimit F] (t : ColimitCocone F) (j : J) :
    colimit.ι F j ≫ (colimit.isoColimitCocone t).hom = t.cocone.ι.app j
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
@[simp]
lemma coeff_preΨ (n : ℤ) : (W.preΨ n).coeff ((n.natAbs ^ 2 - if Even n then 4 else 1) / 2) =
    if Even n then n / 2 else n
-- .lake/packages/lean4/src/lean/Init/Data/Bool.lean
@[simp]
theorem not_ite_eq_false_eq_true (p : Prop) [h : Decidable p] (b c : Bool) :
  ¬(ite p (b = false) (c = true)) ↔ (ite p (b = true) (c = false))
-- .lake/packages/batteries/Batteries/Data/AssocList.lean
@[simp] theorem beq_cons_nil [BEq α] [BEq β] : ((.cons a b t : AssocList α β) == .nil) = false
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem sub_neg_of_lt {a b : Int} (h : a < b) : a - b < 0
-- Mathlib/Topology/Algebra/Order/Group.lean
theorem tendsto_zero_iff_abs_tendsto_zero (f : α → G) :
    Tendsto f l (𝓝 0) ↔ Tendsto (abs ∘ f) l (𝓝 0)
-- Mathlib/Data/Quot.lean
@[simp]
theorem Quotient.liftOn₂_mk {α : Sort*} {β : Sort*} [Setoid α] (f : α → α → β)
    (h : ∀ a₁ a₂ b₁ b₂ : α, a₁ ≈ b₁ → a₂ ≈ b₂ → f a₁ a₂ = f b₁ b₂) (x y : α) :
    Quotient.liftOn₂ (Quotient.mk _ x) (Quotient.mk _ y) f h = f x y
-- Mathlib/Data/Nat/Prime/Basic.lean
theorem Prime.dvd_of_dvd_pow {p m n : ℕ} (pp : Prime p) (h : p ∣ m ^ n) : p ∣ m
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp, norm_cast]
theorem cast_one : ((1 : ℚ) : α) = 1
-- Mathlib/RingTheory/HopfAlgebra.lean
@[simp]
theorem antipode_eq_id : antipode (R := R) (A := R) = .id
-- Mathlib/Data/Real/EReal.lean
theorem coe_ne_zero {x : ℝ} : (x : EReal) ≠ 0 ↔ x ≠ 0
-- Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean
theorem pos_of_mul_neg_right [ExistsAddOfLE α] [MulPosMono α]
    [CovariantClass α α (swap (· + ·)) (· ≤ ·)] [ContravariantClass α α (swap (· + ·)) (· ≤ ·)]
    {a b : α} (h : a * b < 0) (ha : a ≤ 0) : 0 < b
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem Finite.infsep_exists_of_nontrivial (hsf : s.Finite) (hs : s.Nontrivial) :
    ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ s.infsep = dist x y
-- Mathlib/Data/ENNReal/Operations.lean
theorem toNNReal_add {r₁ r₂ : ℝ≥0∞} (h₁ : r₁ ≠ ∞) (h₂ : r₂ ≠ ∞) :
    (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal
-- Mathlib/Algebra/Group/TypeTags.lean
/-- Reinterpret `α →+ Additive β` as `Multiplicative α →* β`. -/
@[simps]
def AddMonoidHom.toMultiplicative'' [AddZeroClass α] [MulOneClass β] :
    (α →+ Additive β) ≃ (Multiplicative α →* β)
-- Mathlib/Analysis/Normed/Module/WeakDual.lean
/-- The polar `polar 𝕜 s` of a set `s : E` is a closed subset when the weak star topology
is used. -/
theorem isClosed_polar (s : Set E) : IsClosed (polar 𝕜 s)
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
@[simp]
theorem HomogeneousIdeal.toIdeal_homogeneousCore_eq_self (I : HomogeneousIdeal 𝒜) :
    I.toIdeal.homogeneousCore 𝒜 = I
-- Mathlib/Algebra/BigOperators/Group/List.lean
@[to_additive]
theorem alternatingProd_append :
    ∀ l₁ l₂ : List α,
      alternatingProd (l₁ ++ l₂) = alternatingProd l₁ * alternatingProd l₂ ^ (-1 : ℤ) ^ length l₁
-- Mathlib/CategoryTheory/Limits/Shapes/ConcreteCategory.lean
@[simp]
lemma productEquiv_symm_apply_π (x : ∀ j, F j) (j : J) :
    Pi.π F j ((productEquiv F).symm x) = x j
-- Mathlib/RingTheory/NonUnitalSubring/Basic.lean
theorem closure_iUnion {ι} (s : ι → Set R) : closure (⋃ i, s i) = ⨆ i, closure (s i)
-- Mathlib/Order/Interval/Set/UnorderedInterval.lean
lemma uIoc_eq_union : Ι a b = Ioc a b ∪ Ioc b a
-- Mathlib/CategoryTheory/Limits/FinallySmall.lean
theorem initiallySmall_of_small_weakly_initial_set [IsCofilteredOrEmpty J] (s : Set J) [Small.{v} s]
    (hs : ∀ i, ∃ j ∈ s, Nonempty (j ⟶ i)) : InitiallySmall.{v} J
-- Mathlib/Order/Filter/Archimedean.lean
/-- See also `Filter.Tendsto.atBot_mul_const_of_neg` for a version of this lemma for
`LinearOrderedField`s which does not require the `Archimedean` assumption. -/
theorem Tendsto.atBot_mul_const_of_neg' (hr : r < 0) (hf : Tendsto f l atBot) :
    Tendsto (fun x => f x * r) l atTop
-- Mathlib/Data/Set/Basic.lean
theorem mem_symmDiff : a ∈ s ∆ t ↔ a ∈ s ∧ a ∉ t ∨ a ∈ t ∧ a ∉ s
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
@[mono]
theorem eLpNormEssSup_mono_measure (f : α → F) (hμν : ν ≪ μ) :
    eLpNormEssSup f ν ≤ eLpNormEssSup f μ
-- Mathlib/LinearAlgebra/Matrix/Block.lean
theorem det_toSquareBlock_id (M : Matrix m m R) (i : m) : (M.toSquareBlock id i).det = M i i
-- Mathlib/Algebra/Algebra/Defs.lean
@[simp]
theorem map_eq_id : algebraMap R R = RingHom.id _
-- Mathlib/LinearAlgebra/CliffordAlgebra/Basic.lean
@[simp]
theorem comp_ι_sq_scalar (g : CliffordAlgebra Q →ₐ[R] A) (m : M) :
    g (ι Q m) * g (ι Q m) = algebraMap _ _ (Q m)
-- Mathlib/Algebra/Order/Field/Basic.lean
theorem div_le_one_of_ge (h : b ≤ a) (hb : b ≤ 0) : a / b ≤ 1
-- Mathlib/Data/Real/Irrational.lean
theorem div_cases (h : Irrational (x / y)) : Irrational x ∨ Irrational y
-- Mathlib/Topology/Category/CompHaus/Limits.lean
lemma pullback.hom_ext {Z : CompHaus.{u}} (a b : Z ⟶ pullback f g)
    (hfst : a ≫ pullback.fst f g = b ≫ pullback.fst f g)
    (hsnd : a ≫ pullback.snd f g = b ≫ pullback.snd f g) : a = b
-- Mathlib/Analysis/Normed/Ring/SeminormFromConst.lean
/-- `seminormFromConst_seq c f 0` is the constant sequence zero. -/
theorem seminormFromConst_seq_zero (hf : f 0 = 0) : seminormFromConst_seq c f 0 = 0
-- Mathlib/Probability/Process/Stopping.lean
theorem measurableSpace_min_const (hτ : IsStoppingTime f τ) {i : ι} :
    (hτ.min_const i).measurableSpace = hτ.measurableSpace ⊓ f i
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem preimage_mul_const_Iic_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Iic a = Ici (a / c)
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
@[simp]
theorem sum_of_isEmpty [IsEmpty ι] (μ : ι → Measure α) : sum μ = 0
-- Mathlib/Data/Set/Function.lean
theorem surjOn (h : LeftInvOn f' f s) (hf : MapsTo f s t) : SurjOn f' t s
-- Mathlib/Topology/Order/Hom/Basic.lean
@[simp]
theorem coe_comp (f : β →Co γ) (g : α →Co β) : (f.comp g : α → γ) = f ∘ g
-- Mathlib/NumberTheory/NumberField/House.lean
private theorem ξ_ne_0 : ξ K x ≠ 0
-- Mathlib/RingTheory/Ideal/Operations.lean
theorem mem_smul_span_singleton {I : Ideal R} {m : M} {x : M} :
    x ∈ I • span R ({m} : Set M) ↔ ∃ y ∈ I, y • m = x
-- Mathlib/RingTheory/Perfection.lean
theorem valAux_zero : valAux K v O hv p 0 = 0
-- Mathlib/Analysis/Analytic/Linear.lean
protected theorem hasFPowerSeriesOnBall_bilinear (f : E →L[𝕜] F →L[𝕜] G) (x : E × F) :
    HasFPowerSeriesOnBall (fun x : E × F => f x.1 x.2) (f.fpowerSeriesBilinear x) x ∞
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem IsNormal.le_iff {f} (H : IsNormal f) {a b} : f a ≤ f b ↔ a ≤ b
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem edist_le_ofReal {x y : α} {r : ℝ} (hr : 0 ≤ r) :
    edist x y ≤ ENNReal.ofReal r ↔ dist x y ≤ r
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem integrable_indicatorConstLp {E} [NormedAddCommGroup E] {p : ℝ≥0∞} {s : Set α}
    (hs : MeasurableSet s) (hμs : μ s ≠ ∞) (c : E) :
    Integrable (indicatorConstLp p hs hμs c) μ
-- Mathlib/Combinatorics/Quiver/Symmetric.lean
theorem eq_reverse_iff [h : HasInvolutiveReverse V] {a b : V} (f : a ⟶ b)
    (g : b ⟶ a) : f = reverse g ↔ reverse f = g
-- Mathlib/MeasureTheory/Measure/WithDensity.lean
theorem withDensity_mul (μ : Measure α) {f g : α → ℝ≥0∞} (hf : Measurable f) (hg : Measurable g) :
    μ.withDensity (f * g) = (μ.withDensity f).withDensity g
-- Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean
theorem infinite_iff_in_all_ranges {K : Finset V} (C : G.ComponentCompl K) :
    C.supp.Infinite ↔ ∀ (L) (h : K ⊆ L), ∃ D : G.ComponentCompl L, D.hom h = C
-- Mathlib/Algebra/DirectSum/Decomposition.lean
@[simp]
theorem decompose_smul (r : R) (x : M) : decompose ℳ (r • x) = r • decompose ℳ x
-- Mathlib/RingTheory/AdjoinRoot.lean
@[simp]
theorem liftHom_mk {g : R[X]} : liftHom f a hfx (mk f g) = aeval a g
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem apply_symm_apply {x : B × F} (hx : x ∈ e.target) : e (e.toPartialEquiv.symm x) = x
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem mem_normalizedFactors_iff [Unique αˣ] {p x : α} (hx : x ≠ 0) :
    p ∈ normalizedFactors x ↔ Prime p ∧ p ∣ x
-- Mathlib/LinearAlgebra/InvariantBasisNumber.lean
theorem nontrivial_of_invariantBasisNumber : Nontrivial R
-- Mathlib/CategoryTheory/Bicategory/LocallyDiscrete.lean
@[simp]
lemma comp_as {a b c : LocallyDiscrete C} (f : a ⟶ b) (g : b ⟶ c) : (f ≫ g).as = f.as ≫ g.as
-- Mathlib/NumberTheory/FLT/Basic.lean
lemma fermatLastTheoremFor_zero : FermatLastTheoremFor 0
-- Mathlib/Algebra/Group/Prod.lean
@[to_additive]
theorem one_mk_mul_one_mk [Monoid M] [Mul N] (b₁ b₂ : N) :
    ((1 : M), b₁) * (1, b₂) = (1, b₁ * b₂)
-- Mathlib/CategoryTheory/Sites/Sieves.lean
theorem singleton_self : singleton f f
-- Mathlib/Order/LiminfLimsup.lean
lemma limsup_comp (u : β → α) (v : γ → β) (f : Filter γ) :
    limsup (u ∘ v) f = limsup u (map v f)
-- Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean
theorem isEquivalent_of_tendsto_one' (hz : ∀ x, v x = 0 → u x = 0) (huv : Tendsto (u / v) l (𝓝 1)) :
    u ~[l] v
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem sum_cons : sum (x::xs : IntList) = x + sum xs
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_le_add_left {a b : Int} (h : a ≤ b) (c : Int) : c + a ≤ c + b
-- Mathlib/Data/List/Chain.lean
theorem Chain'.suffix (h : Chain' R l) (h' : l₁ <:+ l) : Chain' R l₁
-- Mathlib/Data/List/Join.lean
/-- Taking only the first `i+1` elements in a list, and then dropping the first `i` ones, one is
left with a list of length `1` made of the `i`-th element of the original list. -/
@[deprecated drop_take_succ_eq_cons_get (since := "2023-01-10")]
theorem drop_take_succ_eq_cons_nthLe (L : List α) {i : ℕ} (hi : i < L.length) :
    (L.take (i + 1)).drop i = [nthLe L i hi]
-- Mathlib/LinearAlgebra/Dimension/Finite.lean
/-- If a finset has cardinality larger than the rank of a module,
then there is a nontrivial linear relation amongst its elements. -/
theorem Module.exists_nontrivial_relation_of_finrank_lt_card {t : Finset M}
    (h : finrank R M < t.card) : ∃ f : M → R, ∑ e ∈ t, f e • e = 0 ∧ ∃ x ∈ t, f x ≠ 0
-- Mathlib/Logic/Equiv/Defs.lean
theorem sigmaCongrRight_refl {α} {β : α → Type*} :
    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem factors_eq_top_iff_zero {a : Associates α} : a.factors = ⊤ ↔ a = 0
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem diag_sub [Sub α] (A B : Matrix n n α) : diag (A - B) = diag A - diag B
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
@[simp] protected theorem min_self_assoc' {m n : Nat} : min n (min m n) = min n m
-- Mathlib/Analysis/Convolution.lean
theorem ConvolutionExistsAt.integrable_swap (h : ConvolutionExistsAt f g x L μ) :
    Integrable (fun t => L (f (x - t)) (g t)) μ
-- Mathlib/CategoryTheory/Opposites.lean
@[simp]
theorem rightOp_id : NatTrans.rightOp (𝟙 F : F ⟶ F) = 𝟙 F.rightOp
-- Mathlib/Algebra/Polynomial/RingDivision.lean
/-- *McCoy theorem*: a polynomial `P : R[X]` is a zerodivisor if and only if there is `a : R`
such that `a ≠ 0` and `a • P = 0`. -/
theorem nmem_nonZeroDivisors_iff {P : R[X]} : P ∉ R[X]⁰ ↔ ∃ a : R, a ≠ 0 ∧ a • P = 0
-- Mathlib/Order/Heyting/Hom.lean
@[simp]
theorem id_apply (a : α) : HeytingHom.id α a = a
-- .lake/packages/lean4/src/lean/Init/Data/Int/Lemmas.lean
protected theorem add_left_comm (a b c : Int) : a + (b + c) = b + (a + c)
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem norm_comp_le_of_le' {g : NormedAddGroupHom V₂ V₃} (C₁ C₂ C₃ : ℝ) (h : C₃ = C₂ * C₁)
    (hg : ‖g‖ ≤ C₂) (hf : ‖f‖ ≤ C₁) : ‖g.comp f‖ ≤ C₃
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem differentiableAt' (h : DiffContOnCl 𝕜 f s) (hx : s ∈ 𝓝 x) : DifferentiableAt 𝕜 f x
-- Mathlib/Order/Minimal.lean
theorem minimals_Icc (hab : a ≤ b) : minimals (· ≤ ·) (Icc a b) = {a}
-- Mathlib/Topology/Bornology/Absorbs.lean
lemma _root_.Set.Finite.absorbs_sInter (hS : S.Finite) :
    Absorbs G₀ (⋂₀ S) t ↔ ∀ s ∈ S, Absorbs G₀ s t
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isNat_add {α} [AddMonoidWithOne α] : ∀ {f : α → α → α} {a b : α} {a' b' c : ℕ},
    f = HAdd.hAdd → IsNat a a' → IsNat b b' → Nat.add a' b' = c → IsNat (f a b) c
-- Mathlib/Algebra/Periodic.lean
theorem Antiperiodic.smul [Add α] [Monoid γ] [AddGroup β] [DistribMulAction γ β]
    (h : Antiperiodic f c) (a : γ) : Antiperiodic (a • f) c
-- Mathlib/NumberTheory/MulChar/Basic.lean
/-- The inverse of a quadratic character is itself. →  -/
theorem IsQuadratic.inv {χ : MulChar R R'} (hχ : χ.IsQuadratic) : χ⁻¹ = χ
-- Mathlib/SetTheory/Game/PGame.lean
theorem add_congr_right {x y z : PGame} : (y ≈ z) → (x + y ≈ x + z)
-- Mathlib/CategoryTheory/Category/Basic.lean
/-- A morphism `f` is a monomorphism if it can be cancelled when postcomposed:
`g ≫ f = h ≫ f` implies `g = h`.

See <https://stacks.math.columbia.edu/tag/003B>.
-/
class Mono (f : X ⟶ Y) : Prop where
  /-- A morphism `f` is a monomorphism if it can be cancelled when postcomposed. -/
  right_cancellation : ∀ {Z : C} (g h : Z ⟶ X), g ≫ f = h ≫ f → g = h
-- Mathlib/Data/Real/Hyperreal.lean
theorem infinitePos_mul_infiniteNeg {x y : ℝ*} :
    InfinitePos x → InfiniteNeg y → InfiniteNeg (x * y)
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem max_eq_right {a b : Int} (h : a ≤ b) : max a b = b
-- Mathlib/Topology/MetricSpace/Bounded.lean
/-- The diameter of a closed ball of radius `r` is at most `2 r`. -/
theorem diam_closedBall {r : ℝ} (h : 0 ≤ r) : diam (closedBall x r) ≤ 2 * r
-- Mathlib/Data/Real/EReal.lean
@[simp]
lemma image_coe_Iio (x : ℝ) : Real.toEReal '' Iio x = Ioo ⊥ ↑x
-- Mathlib/SetTheory/Game/PGame.lean
@[simp] theorem Subsequent.moveRight_mk_right {xL : xl → PGame} {i : xr} (xR : xr → PGame) (j) :
    Subsequent ((xR i).moveRight j) (mk xl xr xL xR)
-- Mathlib/Algebra/Module/LocalizedModule.lean
lemma IsLocalizedModule.surj [IsLocalizedModule S f] (y : M') : ∃ x : M × S, x.2 • y = f x.1
-- Mathlib/Computability/Partrec.lean
theorem of_primrec {f : ℕ → ℕ} (hf : Nat.Primrec f) : Partrec f
-- Mathlib/Algebra/Ring/Invertible.lean
theorem invOf_add_invOf [Semiring α] (a b : α) [Invertible a] [Invertible b] :
    ⅟a + ⅟b = ⅟a * (a + b) * ⅟b
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[to_additive (attr := simp)]
theorem subtype_comp_inclusion {H K : S} (hH : H ≤ K) :
    (SubgroupClass.subtype K).comp (inclusion hH) = SubgroupClass.subtype H
-- Mathlib/Data/Finset/Sort.lean
theorem sorted_last_eq_max' {s : Finset α}
    {h : (s.sort (· ≤ ·)).length - 1 < (s.sort (· ≤ ·)).length} :
    (s.sort (· ≤ ·)).get ⟨(s.sort (· ≤ ·)).length - 1, h⟩ =
      s.max' (by rw [length_sort] at h; exact card_pos.1 (lt_of_le_of_lt bot_le h))
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Gcd.lean
theorem gcd_assoc (m n k : Nat) : gcd (gcd m n) k = gcd m (gcd n k)
-- Mathlib/Data/Multiset/Lattice.lean
theorem nodup_sup_iff {α : Type*} [DecidableEq α] {m : Multiset (Multiset α)} :
    m.sup.Nodup ↔ ∀ a : Multiset α, a ∈ m → a.Nodup
-- Mathlib/Topology/PartialHomeomorph.lean
/-- A partial homeomorphism is an open map on its source:
  the image of an open subset of the source is open. -/
lemma isOpen_image_of_subset_source {s : Set X} (hs : IsOpen s) (hse : s ⊆ e.source) :
    IsOpen (e '' s)
-- Mathlib/Combinatorics/SimpleGraph/Prod.lean
@[simp]
theorem boxProd_connected : (G □ H).Connected ↔ G.Connected ∧ H.Connected
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem inv_mul_eq_of_eq_mul (h : b = a * c) : a⁻¹ * b = c
-- Mathlib/Topology/Constructions.lean
@[continuity, fun_prop]
theorem continuous_quot_mk : Continuous (@Quot.mk X r)
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem hasStrictFDerivAt_fst : HasStrictFDerivAt (@Prod.fst E F) (fst 𝕜 E F) p
-- Mathlib/Data/Fintype/Card.lean
theorem not_surjective_finite_infinite {α β} [Finite α] [Infinite β] (f : α → β) : ¬Surjective f
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
protected theorem mul_assoc (x y z : BitVec w) : x * y * z = x * (y * z)
-- .lake/packages/batteries/Batteries/Logic.lean
theorem subsingleton_iff_forall_eq (x : α) : Subsingleton α ↔ ∀ y, y = x
-- Mathlib/SetTheory/Cardinal/ENat.lean
@[simp, norm_cast] lemma ofENat_ofNat (n : ℕ) [n.AtLeastTwo] :
    ((no_index (OfNat.ofNat n : ℕ∞)) : Cardinal) = OfNat.ofNat n
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- **Fundamental theorem of calculus-1**: if `f : ℝ → E` is integrable on `a..b` and `f x` has a
finite limit `c` almost surely at `a`, then `u ↦ ∫ x in u..b, f x` has derivative `-c` at `a`. -/
theorem integral_hasDerivAt_of_tendsto_ae_left (hf : IntervalIntegrable f volume a b)
    (hmeas : StronglyMeasurableAtFilter f (𝓝 a)) (ha : Tendsto f (𝓝 a ⊓ ae volume) (𝓝 c)) :
    HasDerivAt (fun u => ∫ x in u..b, f x) (-c) a
-- Mathlib/Topology/Semicontinuous.lean
theorem lowerSemicontinuousOn_ciSup {f : ι → α → δ'}
    (bdd : ∀ x ∈ s, BddAbove (range fun i => f i x)) (h : ∀ i, LowerSemicontinuousOn (f i) s) :
    LowerSemicontinuousOn (fun x' => ⨆ i, f i x') s
-- Mathlib/Algebra/Algebra/Subalgebra/Basic.lean
@[simp]
theorem coe_val : (val s : s → A) = ((↑) : s → A)
-- Mathlib/Data/ENat/Basic.lean
@[simp] lemma top_ne_one : (⊤ : ℕ∞) ≠ 1
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem singleton_nonempty (a : α) : ({a} : Set α).Nonempty
-- Mathlib/Algebra/Group/Pi/Basic.lean
@[to_additive (attr := simp)]
theorem elim_one_mulSingle [DecidableEq α] [DecidableEq β] [One γ] (i : β) (c : γ) :
    Sum.elim (1 : α → γ) (Pi.mulSingle i c) = Pi.mulSingle (Sum.inr i) c
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[simp, fun_prop]
protected theorem Differentiable.snd (h : Differentiable 𝕜 f₂) :
    Differentiable 𝕜 fun x => (f₂ x).2
-- Mathlib/Analysis/InnerProductSpace/Spectrum.lean
/-- The sequence of real eigenvalues associated to the standard orthonormal basis of eigenvectors
for a self-adjoint operator `T` on `E`.

TODO Postcompose with a permutation so that these eigenvalues are listed in increasing order. -/
noncomputable irreducible_def eigenvalues (i : Fin n) : ℝ
-- Mathlib/Algebra/Lie/CartanSubalgebra.lean
@[simp]
theorem ucs_eq_self_of_isCartanSubalgebra (H : LieSubalgebra R L) [H.IsCartanSubalgebra] (k : ℕ) :
    H.toLieSubmodule.ucs k = H.toLieSubmodule
-- Mathlib/Analysis/SpecificLimits/Normed.lean
theorem tendsto_norm_zero' {𝕜 : Type*} [NormedAddCommGroup 𝕜] :
    Tendsto (norm : 𝕜 → ℝ) (𝓝[≠] 0) (𝓝[>] 0)
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
theorem extract_loop_of_ge (as bs : Array α) (size start : Nat) (h : start ≥ as.size) :
    extract.loop as size start bs = bs
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
theorem addHaar_sphere_of_ne_zero (x : E) {r : ℝ} (hr : r ≠ 0) : μ (sphere x r) = 0
-- Mathlib/Analysis/Convex/Basic.lean
protected theorem Set.Subsingleton.convex {s : Set E} (h : s.Subsingleton) : Convex 𝕜 s
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
theorem measurableSet_pi {s : Set δ} {t : ∀ i, Set (π i)} (hs : s.Countable) :
    MeasurableSet (pi s t) ↔ (∀ i ∈ s, MeasurableSet (t i)) ∨ pi s t = ∅
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/ArctanDeriv.lean
theorem hasStrictDerivAt_arctan (x : ℝ) : HasStrictDerivAt arctan (1 / (1 + x ^ 2)) x
-- Mathlib/Order/ConditionallyCompleteLattice/Basic.lean
theorem l_csSup' (gc : GaloisConnection l u) {s : Set α} (hne : s.Nonempty) (hbdd : BddAbove s) :
    l (sSup s) = sSup (l '' s)
-- Mathlib/Data/Rat/Cast/Lemmas.lean
@[simp]
theorem cast_inv_nat (n : ℕ) : ((n⁻¹ : ℚ) : α) = (n : α)⁻¹
-- Mathlib/Algebra/Star/SelfAdjoint.lean
@[simp, norm_cast]
theorem val_smul [SMul R A] [StarModule R A] (r : R) (x : selfAdjoint A) : ↑(r • x) = r • (x : A)
-- Mathlib/Data/Set/Basic.lean
theorem subset_ite {t s s' u : Set α} : u ⊆ t.ite s s' ↔ u ∩ t ⊆ s ∧ u \ t ⊆ s'
-- Mathlib/MeasureTheory/Measure/Stieltjes.lean
theorem measurableSet_Ioi {c : ℝ} : MeasurableSet[f.outer.caratheodory] (Ioi c)
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
theorem cpow_neg_one (x : ℂ) : x ^ (-1 : ℂ) = x⁻¹
-- Mathlib/CategoryTheory/Sites/Types.lean
theorem generate_discretePresieve_mem (α : Type u) :
    Sieve.generate (discretePresieve α) ∈ typesGrothendieckTopology α
-- Mathlib/Algebra/Group/Conj.lean
theorem isConj_iff_conjugatesOf_eq {a b : α} : IsConj a b ↔ conjugatesOf a = conjugatesOf b
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem prod_le [Nontrivial α] {a b : FactorSet α} : a.prod ≤ b.prod ↔ a ≤ b
-- .lake/packages/batteries/Batteries/Data/Nat/Lemmas.lean
theorem recDiag_zero_succ {motive : Nat → Nat → Sort _} (zero_zero : motive 0 0)
    (zero_succ : ∀ n, motive 0 n → motive 0 (n+1)) (succ_zero : ∀ m, motive m 0 → motive (m+1) 0)
    (succ_succ : ∀ m n, motive m n → motive (m+1) (n+1)) (n) :
    Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 (n+1)
      = zero_succ n (Nat.recDiag zero_zero zero_succ succ_zero succ_succ 0 n)
-- Mathlib/RingTheory/MvPowerSeries/Trunc.lean
@[simp]
theorem trunc_one (n : σ →₀ ℕ) (hnn : n ≠ 0) : trunc R n 1 = 1
-- Mathlib/Analysis/SpecificLimits/Basic.lean
lemma tendsto_nat_ceil_atTop {α : Type*} [LinearOrderedSemiring α] [FloorSemiring α] :
    Tendsto (fun x : α ↦ ⌈x⌉₊) atTop atTop
-- Mathlib/Logic/Nontrivial/Defs.lean
theorem not_nontrivial (α) [Subsingleton α] : ¬Nontrivial α
-- Mathlib/Logic/Relation.lean
lemma map_apply : Relation.Map r f g c d ↔ ∃ a b, r a b ∧ f a = c ∧ g b = d
-- Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean
theorem coe_T : ↑ₘT = !![1, 1; 0, 1]
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
/-- Given a total orthonormal family `v : ι → E`, `E` is a Hilbert sum of `fun i : ι => 𝕜`
relative to the family of linear isometries `fun i k => k • v i`. -/
theorem Orthonormal.isHilbertSum {v : ι → E} (hv : Orthonormal 𝕜 v)
    (hsp : ⊤ ≤ (span 𝕜 (Set.range v)).topologicalClosure) :
    IsHilbertSum 𝕜 (fun _ : ι => 𝕜) fun i => LinearIsometry.toSpanSingleton 𝕜 E (hv.1 i)
-- Mathlib/Algebra/Module/Submodule/Range.lean
theorem ker_le_iff [RingHomSurjective τ₁₂] {p : Submodule R M} :
    ker f ≤ p ↔ ∃ y ∈ range f, f ⁻¹' {y} ⊆ p
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIocDiv_sub_eq_toIocDiv_add' (a b c : α) :
    toIocDiv hp (a - c) b = toIocDiv hp a (b + c)
-- Mathlib/Analysis/NormedSpace/Exponential.lean
/-- In a Banach-algebra `𝔸` over `𝕂 = ℝ` or `𝕂 = ℂ`, if a family of elements `f i` mutually
commute then `exp 𝕂 (∑ i, f i) = ∏ i, exp 𝕂 (f i)`. -/
theorem exp_sum_of_commute {ι} (s : Finset ι) (f : ι → 𝔸)
    (h : (s : Set ι).Pairwise fun i j => Commute (f i) (f j)) :
    exp 𝕂 (∑ i ∈ s, f i) =
      s.noncommProd (fun i => exp 𝕂 (f i)) fun i hi j hj _ => (h.of_refl hi hj).exp 𝕂
-- Mathlib/Data/Finsupp/AList.lean
@[simp]
theorem lookupFinsupp_apply [DecidableEq α] (l : AList fun _x : α => M) (a : α) :
    l.lookupFinsupp a = (l.lookup a).getD 0