ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/ModelTheory/ElementarySubstructures.lean
@[simp]
theorem isElementary (S : L.ElementarySubstructure M) : (S : L.Substructure M).IsElementary
-- Mathlib/RingTheory/Ideal/Basic.lean
theorem mul_sub_mul_mem {R : Type*} [CommRing R] (I : Ideal R) {a b c d : R} (h1 : a - b ∈ I)
    (h2 : c - d ∈ I) : a * c - b * d ∈ I
-- Mathlib/Analysis/NormedSpace/Pointwise.lean
/-- Any ball `Metric.ball x r`, `0 < r` is the image of the unit ball under `fun y ↦ x + r • y`. -/
theorem affinity_unitBall {r : ℝ} (hr : 0 < r) (x : E) : x +ᵥ r • ball (0 : E) 1 = ball x r
-- Mathlib/Topology/Connected/Basic.lean
theorem DenseRange.preconnectedSpace [TopologicalSpace β] [PreconnectedSpace α] {f : α → β}
    (hf : DenseRange f) (hc : Continuous f) : PreconnectedSpace β
-- Mathlib/Order/Monotone/Monovary.lean
protected theorem Subsingleton.antivary [Subsingleton ι] (f : ι → α) (g : ι → β) : Antivary f g
-- Mathlib/Topology/Inseparable.lean
@[simp]
theorem specializes_prod {x₁ x₂ : X} {y₁ y₂ : Y} : (x₁, y₁) ⤳ (x₂, y₂) ↔ x₁ ⤳ x₂ ∧ y₁ ⤳ y₂
-- Mathlib/Computability/RegularExpressions.lean
@[simp]
theorem matches'_epsilon : (1 : RegularExpression α).matches' = 1
-- Mathlib/Data/Sym/Sym2.lean
@[simp]
theorem map_id : map (@id α) = id
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem mem_localTriv_source (p : Z.TotalSpace) : p ∈ (Z.localTriv i).source ↔ p.1 ∈ Z.baseSet i
-- Mathlib/Topology/Irreducible.lean
/-- A set is irreducible if and only if for every cover by a finite collection of closed sets, it is
contained in one of the members of the collection. -/
theorem isIrreducible_iff_sUnion_closed :
    IsIrreducible s ↔
      ∀ t : Finset (Set X), (∀ z ∈ t, IsClosed z) → (s ⊆ ⋃₀ ↑t) → ∃ z ∈ t, s ⊆ z
-- Mathlib/Order/WellFoundedSet.lean
theorem subsetProdLex [PartialOrder α] [Preorder β] {s : Set (α ×ₗ β)}
    (hα : ((fun (x : α ×ₗ β) => (ofLex x).1)'' s).IsPWO)
    (hβ : ∀ a, {y | toLex (a, y) ∈ s}.IsPWO) : s.IsPWO
-- Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean
theorem Ideal.isHomogeneous_iff_subset_iInter :
    I.IsHomogeneous 𝒜 ↔ (I : Set A) ⊆ ⋂ i, GradedRing.proj 𝒜 i ⁻¹' ↑I
-- Mathlib/Algebra/Homology/ShortComplex/Basic.lean
/-- The third projection functor `ShortComplex C ⥤ C`. -/
@[simps]
def π₃ : ShortComplex C ⥤ C
-- Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean
theorem HasFDerivWithinAt.const_rpow (hf : HasFDerivWithinAt f f' s x) (hc : 0 < c) :
    HasFDerivWithinAt (fun x => c ^ f x) ((c ^ f x * Real.log c) • f') s x
-- Mathlib/Algebra/Algebra/Spectrum.lean
theorem mem_resolventSet_of_left_right_inverse {r : R} {a b c : A} (h₁ : (↑ₐ r - a) * b = 1)
    (h₂ : c * (↑ₐ r - a) = 1) : r ∈ resolventSet R a
-- Mathlib/Algebra/Ring/Subring/Basic.lean
@[simp]
theorem coe_top : ((⊤ : Subring R) : Set R) = Set.univ
-- Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL1.lean
theorem condexpIndL1Fin_disjoint_union (hs : MeasurableSet s) (ht : MeasurableSet t) (hμs : μ s ≠ ∞)
    (hμt : μ t ≠ ∞) (hst : s ∩ t = ∅) (x : G) :
    condexpIndL1Fin hm (hs.union ht) ((measure_union_le s t).trans_lt
      (lt_top_iff_ne_top.mpr (ENNReal.add_ne_top.mpr ⟨hμs, hμt⟩))).ne x =
    condexpIndL1Fin hm hs hμs x + condexpIndL1Fin hm ht hμt x
-- Mathlib/Algebra/Polynomial/Eval.lean
theorem root_mul_right_of_isRoot {p : R[X]} (q : R[X]) : IsRoot p a → IsRoot (p * q) a
-- Mathlib/Data/PFunctor/Univariate/Basic.lean
/-- We prefer `PFunctor.map` to `Functor.map` because it is universe-polymorphic. -/
@[simp]
theorem map_eq_map {α β : Type v} (f : α → β) (x : P α) : f <$> x = P.map f x
-- Mathlib/Algebra/Algebra/Unitization.lean
theorem inl_fst_add_inr_snd_eq [AddZeroClass R] [AddZeroClass A] (x : Unitization R A) :
    inl x.fst + (x.snd : Unitization R A) = x
-- Mathlib/Data/PNat/Basic.lean
@[simp]
theorem recOn_one {p} (p1 hp) : @PNat.recOn 1 p p1 hp = p1
-- Mathlib/Order/Heyting/Basic.lean
theorem sup_compl_le_himp : b ⊔ aᶜ ≤ a ⇨ b
-- Mathlib/Data/Set/Subsingleton.lean
lemma Subsingleton.inter_singleton : (s ∩ {a}).Subsingleton
-- Mathlib/Data/Semiquot.lean
@[simp]
theorem pure_inj {a b : α} : (pure a : Semiquot α) = pure b ↔ a = b
-- Mathlib/Topology/Order/IntermediateValue.lean
/-- In a dense conditionally complete linear order, the set of preconnected sets is exactly
the set of the intervals `Icc`, `Ico`, `Ioc`, `Ioo`, `Ici`, `Ioi`, `Iic`, `Iio`, `(-∞, +∞)`,
or `∅`. Though one can represent `∅` as `(sInf s, sInf s)`, we include it into the list of
possible cases to improve readability. -/
theorem setOf_isPreconnected_eq_of_ordered :
    { s : Set α | IsPreconnected s } =
      -- bounded intervals
      range (uncurry Icc) ∪ range (uncurry Ico) ∪ range (uncurry Ioc) ∪ range (uncurry Ioo) ∪
      -- unbounded intervals and `univ`
      (range Ici ∪ range Ioi ∪ range Iic ∪ range Iio ∪ {univ, ∅})
-- Mathlib/Topology/Algebra/Module/FiniteDimension.lean
/-- In finite dimensions over a non-discrete complete normed field, the canonical identification
(in terms of a basis) with `𝕜^n` (endowed with the product topology) is continuous.
This is the key fact which makes all linear maps from a T2 finite dimensional TVS over such a field
continuous (see `LinearMap.continuous_of_finiteDimensional`), which in turn implies that all
norms are equivalent in finite dimensions. -/
theorem continuous_equivFun_basis [T2Space E] {ι : Type*} [Finite ι] (ξ : Basis ι 𝕜 E) :
    Continuous ξ.equivFun
-- Mathlib/LinearAlgebra/QuadraticForm/Basic.lean
theorem not_anisotropic_iff_exists (Q : QuadraticMap R M N) :
    ¬Anisotropic Q ↔ ∃ x, x ≠ 0 ∧ Q x = 0
-- Mathlib/MeasureTheory/Integral/SetIntegral.lean
theorem integral_empty : ∫ x in ∅, f x ∂μ = 0
-- Mathlib/Algebra/Lie/Nilpotent.lean
theorem lcs_le_self : N.lcs k ≤ N
-- Mathlib/MeasureTheory/Measure/MeasureSpace.lean
theorem ae_eq (h : QuasiMeasurePreserving f μa μb) {g₁ g₂ : β → δ} (hg : g₁ =ᵐ[μb] g₂) :
    g₁ ∘ f =ᵐ[μa] g₂ ∘ f
-- Mathlib/Probability/Martingale/Upcrossing.lean
theorem lowerCrossingTime_mono (hnm : n ≤ m) :
    lowerCrossingTime a b f N n ω ≤ lowerCrossingTime a b f N m ω
-- Mathlib/Data/Finset/Basic.lean
theorem inter_eq_inter_iff_right : s ∩ u = t ∩ u ↔ t ∩ u ⊆ s ∧ s ∩ u ⊆ t
-- Mathlib/Analysis/Asymptotics/SuperpolynomialDecay.lean
theorem SuperpolynomialDecay.inv_param_mul (hk : Tendsto k l atTop)
    (hf : SuperpolynomialDecay l k f) : SuperpolynomialDecay l k (k⁻¹ * f)
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem succAbove_cycleRange {n : ℕ} (i j : Fin n) :
    i.succ.succAbove (i.cycleRange j) = swap 0 i.succ j.succ
-- Mathlib/Order/Disjoint.lean
theorem le_sup_right_iff_inf_left_le {a b} (h : IsCompl x y) : a ≤ b ⊔ y ↔ a ⊓ x ≤ b
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem map_cons {n : ℕ} (f : α → β) (a : α) (s : Sym α n) : (a ::ₛ s).map f = f a ::ₛ s.map f
-- Mathlib/Order/Filter/Ultrafilter.lean
@[simp, norm_cast]
theorem coe_comap {m : α → β} (u : Ultrafilter β) (inj : Injective m) (large : Set.range m ∈ u) :
    (u.comap inj large : Filter α) = Filter.comap m u
-- Mathlib/Data/Set/Basic.lean
@[simp]
theorem ite_empty (s s' : Set α) : Set.ite ∅ s s' = s'
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean
theorem sin_pos_of_pos_of_lt_pi {x : ℝ} (h0x : 0 < x) (hxp : x < π) : 0 < sin x
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Metric.lean
@[measurability, fun_prop]
theorem Measurable.ennnorm {f : β → α} (hf : Measurable f) : Measurable fun a => (‖f a‖₊ : ℝ≥0∞)
-- Mathlib/Analysis/Convex/Basic.lean
theorem Convex.smul_preimage (hs : Convex 𝕜 s) (c : 𝕜) : Convex 𝕜 ((fun z => c • z) ⁻¹' s)
-- Mathlib/Algebra/Polynomial/Derivative.lean
@[simp]
theorem derivative_map [Semiring S] (p : R[X]) (f : R →+* S) :
    derivative (p.map f) = p.derivative.map f
-- Mathlib/RingTheory/WittVector/WittPolynomial.lean
@[simp]
theorem map_wittPolynomial (f : R →+* S) (n : ℕ) : map f (W n) = W n
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem natDegree_one : natDegree (1 : R[X]) = 0
-- Mathlib/Algebra/Module/LinearMap/Polynomial.lean
lemma polyCharpoly_coeff_eq_zero_iff_of_basis (b : Basis ι R L) (b' : Basis ι' R L) (k : ℕ) :
    (polyCharpoly φ b).coeff k = 0 ↔ (polyCharpoly φ b').coeff k = 0
-- Mathlib/Data/Semiquot.lean
theorem blur_eq_blur' (q : Semiquot α) (s : Set α) (h : q.s ⊆ s) : blur s q = blur' q h
-- Mathlib/Order/PiLex.lean
@[simp]
theorem toLex_update_lt_self_iff : toLex (update x i a) < toLex x ↔ a < x i
-- Mathlib/CategoryTheory/Conj.lean
@[simp]
theorem trans_conj {Z : C} (β : Y ≅ Z) (f : End X) : (α ≪≫ β).conj f = β.conj (α.conj f)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem Ideal.pow_lt_self (I : Ideal A) (hI0 : I ≠ ⊥) (hI1 : I ≠ ⊤) (e : ℕ) (he : 2 ≤ e) :
    I ^ e < I
-- Mathlib/Analysis/Convex/Basic.lean
theorem Monotone.convex_gt (hf : Monotone f) (r : β) : Convex 𝕜 { x | f x ≤ r }
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem cthickening_eq_iInter_cthickening' {δ : ℝ} (s : Set ℝ) (hsδ : s ⊆ Ioi δ)
    (hs : ∀ ε, δ < ε → (s ∩ Ioc δ ε).Nonempty) (E : Set α) :
    cthickening δ E = ⋂ ε ∈ s, cthickening ε E
-- Mathlib/Topology/MetricSpace/PiNat.lean
@[simp]
theorem res_succ (x : ℕ → α) (n : ℕ) : res x n.succ = x n :: res x n
-- Mathlib/RingTheory/WittVector/Defs.lean
@[simp]
theorem wittZero_eq_zero (n : ℕ) : wittZero p n = 0
-- Mathlib/Data/List/Perm.lean
theorem Perm.bagInter_right {l₁ l₂ : List α} (t : List α) (h : l₁ ~ l₂) :
    l₁.bagInter t ~ l₂.bagInter t
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem mul_coeff [NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} :
    (x * y).coeff a =
      ∑ ij ∈ addAntidiagonal x.isPWO_support y.isPWO_support a, x.coeff ij.fst * y.coeff ij.snd
-- Mathlib/Combinatorics/Quiver/Cast.lean
@[simp]
theorem Path.cast_rfl_rfl {u v : U} (p : Path u v) : p.cast rfl rfl = p
-- Mathlib/SetTheory/Cardinal/Basic.lean
theorem mk_eq_two_iff' (x : α) : #α = 2 ↔ ∃! y, y ≠ x
-- Mathlib/Control/Basic.lean
@[simp]
theorem guard_false {h : Decidable False} : @guard F _ False h = failure
-- Mathlib/LinearAlgebra/AffineSpace/Pointwise.lean
theorem pointwise_vadd_span (v : V) (s : Set P) : v +ᵥ affineSpan k s = affineSpan k (v +ᵥ s)
-- Mathlib/CategoryTheory/Limits/Shapes/WideEqualizers.lean
@[simp]
theorem parallelFamily_map_left {j : J} : (parallelFamily f).map (line j) = f j
-- Mathlib/Data/Rat/Cast/Defs.lean
@[simp]
lemma eq_nnratCast [DivisionSemiring α] [FunLike F ℚ≥0 α] [RingHomClass F ℚ≥0 α] (f : F) (q : ℚ≥0) :
    f q = q
-- Mathlib/NumberTheory/LegendreSymbol/JacobiSymbol.lean
private theorem fastJacobiSymAux.eq_jacobiSym {a b : ℕ} {flip : Bool} {ha0 : a > 0}
    (hb2 : b % 2 = 1) (hb1 : b > 1) :
    fastJacobiSymAux a b flip ha0 = if flip then -J(a | b) else J(a | b)
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem norm_le_of_forall_le {f : lp E ∞} {C : ℝ} (hC : 0 ≤ C) (hCf : ∀ i, ‖f i‖ ≤ C) :
    ‖f‖ ≤ C
-- Mathlib/Logic/Equiv/Defs.lean
/-- This cannot be a `simp` lemmas as it incorrectly matches against `e : α ≃ synonym α`, when
`synonym α` is semireducible. This makes a mess of `Multiplicative.ofAdd` etc. -/
theorem Perm.coe_subsingleton {α : Type*} [Subsingleton α] (e : Perm α) : (e : α → α) = id
-- Mathlib/Order/Hom/Lattice.lean
@[ext]
theorem ext {f g : InfTopHom α β} (h : ∀ a, f a = g a) : f = g
-- Mathlib/Probability/Independence/ZeroOne.lean
theorem condIndep_limsup_self [StandardBorelSpace Ω] [Nonempty Ω]
    (hm : m ≤ m0) [IsFiniteMeasure μ]
    (h_le : ∀ n, s n ≤ m0) (h_indep : iCondIndep m hm s μ) (hf : ∀ t, p t → tᶜ ∈ f)
    (hns : Directed (· ≤ ·) ns) (hnsp : ∀ a, p (ns a)) (hns_univ : ∀ n, ∃ a, n ∈ ns a) :
    CondIndep m (limsup s f) (limsup s f) hm μ
-- Mathlib/ModelTheory/Basic.lean
@[simp]
theorem toHom_comp_inj (h : N ↪[L] P) (f g : M →[L] N) : h.toHom.comp f = h.toHom.comp g ↔ f = g
-- Mathlib/Topology/EMetricSpace/Basic.lean
/-- Reformulation of the uniform structure in terms of the extended distance -/
theorem uniformity_pseudoedist : 𝓤 α = ⨅ ε > 0, 𝓟 { p : α × α | edist p.1 p.2 < ε }
-- Mathlib/Topology/UniformSpace/Equicontinuity.lean
/-- If a set of functions is uniformly equicontinuous, its closure for the product topology is also
uniformly equicontinuous. -/
protected theorem Set.UniformEquicontinuous.closure {A : Set <| β → α}
    (hA : A.UniformEquicontinuous) : (closure A).UniformEquicontinuous
-- Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean
theorem le_trailingDegree_X_pow (n : ℕ) : (n : ℕ∞) ≤ trailingDegree (X ^ n : R[X])
-- Mathlib/Algebra/Order/Group/Defs.lean
@[to_additive (attr := simp)]
theorem inv_le_self_iff : a⁻¹ ≤ a ↔ 1 ≤ a
-- Mathlib/LinearAlgebra/Trace.lean
lemma trace_mul_cycle' (f g h : M →ₗ[R] M) :
    trace R M (f * (g * h)) = trace R M (h * (f * g))
-- Mathlib/Analysis/Complex/HalfPlane.lean
/-- An open right half-plane (with boundary real part given by an `EReal`) is an open set
in the complex plane. -/
lemma isOpen_re_gt_EReal (x : EReal) : IsOpen {z : ℂ | x < z.re}
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
theorem BilinForm.toMatrix'_mul (B : BilinForm R₂ (n → R₂)) (M : Matrix n n R₂) :
    BilinForm.toMatrix' B * M = BilinForm.toMatrix' (B.compRight (Matrix.toLin' M))
-- Mathlib/Algebra/ContinuedFractions/Computation/CorrectnessTerminating.lean
/-- If `GenContFract.of v` terminated at step `n`, then the `n`th convergent is exactly `v`. -/
theorem of_correctness_of_terminatedAt (terminatedAt_n : (of v).TerminatedAt n) :
    v = (of v).convs n
-- Mathlib/Topology/ContinuousOn.lean
theorem eventuallyEq_nhdsWithin_of_eqOn {f g : α → β} {s : Set α} {a : α} (h : EqOn f g s) :
    f =ᶠ[𝓝[s] a] g
-- Mathlib/Order/InitialSeg.lean
theorem collapse_apply [IsWellOrder β s] (f : r ↪r s) (a) : collapse f a = (collapseF f a).1
-- Mathlib/Order/Category/PartOrd.lean
theorem partOrd_dual_comp_forget_to_preord :
    PartOrd.dual ⋙ forget₂ PartOrd Preord =
      forget₂ PartOrd Preord ⋙ Preord.dual
-- Mathlib/Topology/NhdsSet.lean
theorem IsClosed.nhdsSet_le_sup (h : IsClosed t) : 𝓝ˢ s ≤ 𝓝ˢ (s ∩ t) ⊔ 𝓟 (tᶜ)
-- Mathlib/RingTheory/Localization/Basic.lean
/-- Given a localization map `f : R →+* S` for a submonoid `M ⊆ R` and a map of `CommSemiring`s
`g : R →* P` such that `g y` is invertible for all `y : M`, the homomorphism induced from
`S` to `P` maps `f x * (f y)⁻¹` to `g x * (g y)⁻¹` for all `x : R, y ∈ M`. -/
theorem lift_mk' (x y) :
    lift hg (mk' S x y) = g x * ↑(IsUnit.liftRight (g.toMonoidHom.restrict M) hg y)⁻¹
-- Mathlib/Analysis/Convolution.lean
/-- The convolution `f * g` is `C^n` when `f` is locally integrable and `g` is `C^n` and compactly
supported. Version where `g` depends on an additional parameter in an open subset `s` of a
parameter space `P` (and the compact support `k` is independent of the parameter in `s`). -/
theorem contDiffOn_convolution_right_with_param {f : G → E} {n : ℕ∞} (L : E →L[𝕜] E' →L[𝕜] F)
    {g : P → G → E'} {s : Set P} {k : Set G} (hs : IsOpen s) (hk : IsCompact k)
    (hgs : ∀ p, ∀ x, p ∈ s → x ∉ k → g p x = 0) (hf : LocallyIntegrable f μ)
    (hg : ContDiffOn 𝕜 n (↿g) (s ×ˢ univ)) :
    ContDiffOn 𝕜 n (fun q : P × G => (f ⋆[L, μ] g q.1) q.2) (s ×ˢ univ)
-- Mathlib/MeasureTheory/Covering/VitaliFamily.lean
theorem measure_le_tsum_of_absolutelyContinuous [SecondCountableTopology α] {ρ : Measure α}
    (hρ : ρ ≪ μ) : ρ s ≤ ∑' p : h.index, ρ (h.covering p)
-- Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean
/-- Shows how the entries of the sequence of the computed continued fraction can be obtained by the
fractional parts of the stream of integer and fractional parts.
-/
theorem get?_of_eq_some_of_get?_intFractPair_stream_fr_ne_zero {ifp_n : IntFractPair K}
    (stream_nth_eq : IntFractPair.stream v n = some ifp_n) (nth_fr_ne_zero : ifp_n.fr ≠ 0) :
    (of v).s.get? n = some ⟨1, (IntFractPair.of ifp_n.fr⁻¹).b⟩
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem aleph0_add_ofNat {n : ℕ} [Nat.AtLeastTwo n] : ℵ₀ + no_index (OfNat.ofNat n) = ℵ₀
-- Mathlib/Data/Real/EReal.lean
@[simp]
theorem neg_bot : -(⊥ : EReal) = ⊤
-- .lake/packages/aesop/Aesop/BuiltinRules.lean
@[aesop (rule_sets := [builtin]) norm destruct]
theorem empty_false (h : Empty) : False
-- Mathlib/Data/Set/Pairwise/Basic.lean
lemma exists_ne_mem_inter_of_not_pairwise_disjoint
    {f : ι → Set α} (h : ¬ Pairwise (Disjoint on f)) :
    ∃ i j : ι, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j
-- Mathlib/Data/List/AList.lean
theorem perm_lookup {a : α} {s₁ s₂ : AList β} (p : s₁.entries ~ s₂.entries) :
    s₁.lookup a = s₂.lookup a
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem ωb_mul_ω (q : ℕ+) : (ωb : X q) * ω = 1
-- Mathlib/Probability/Kernel/Disintegration/MeasurableStieltjes.lean
lemma stieltjesOfMeasurableRat_nonneg (hf : Measurable f) (a : α) (r : ℝ) :
    0 ≤ stieltjesOfMeasurableRat f hf a r
-- Mathlib/Combinatorics/Colex.lean
lemma isInitSeg_initSeg : IsInitSeg (initSeg s) s.card
-- Mathlib/Topology/Algebra/Algebra.lean
@[simp, norm_cast]
theorem coe_prodMap {D : Type*} [Semiring D] [TopologicalSpace D] [Algebra R D] (f₁ : A →A[R] B)
    (f₂ : C →A[R] D) :
    (f₁.prodMap f₂ : A × C →ₐ[R] B × D) = (f₁ : A →ₐ[R] B).prodMap (f₂ : C →ₐ[R] D)
-- Mathlib/Algebra/Order/ToIntervalMod.lean
theorem toIcoMod_neg (a b : α) : toIcoMod hp a (-b) = p - toIocMod hp (-a) b
-- Mathlib/Data/Part.lean
theorem mul_def [Mul α] (a b : Part α) : a * b = bind a fun y ↦ map (y * ·) b
-- Mathlib/Data/Set/Semiring.lean
@[simp]
theorem down_ssubset_down {s t : SetSemiring α} : SetSemiring.down s ⊂ SetSemiring.down t ↔ s < t
-- Mathlib/Data/ZMod/Basic.lean
@[simp]
theorem natCast_self' (n : ℕ) : (n + 1 : ZMod (n + 1)) = 0
-- Mathlib/Data/Ordmap/Ordset.lean
theorem node3R_size {l x m y r} : size (@node3R α l x m y r) = size l + size m + size r + 2
-- Mathlib/Analysis/Normed/Ring/Seminorm.lean
theorem eq_zero_iff {p : RingSeminorm R} : p = 0 ↔ ∀ x, p x = 0
-- Mathlib/Algebra/Polynomial/Basic.lean
theorem eq_zero_of_eq_zero (h : (0 : R) = (1 : R)) (p : R[X]) : p = 0
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem empty_toList {s : Multiset α} : s.toList.isEmpty ↔ s = 0
-- Mathlib/SetTheory/Ordinal/Arithmetic.lean
theorem mex_le_lsub {ι : Type u} (f : ι → Ordinal.{max u v}) : mex.{_, v} f ≤ lsub.{_, v} f
-- Mathlib/Order/Bounded.lean
theorem unbounded_lt_inter_le [LinearOrder α] (a : α) :
    Unbounded (· < ·) (s ∩ { b | a ≤ b }) ↔ Unbounded (· < ·) s
-- Mathlib/Data/Set/Basic.lean
theorem nonempty_of_ssubset' (ht : s ⊂ t) : t.Nonempty
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
theorem sum_add (xs ys : IntList) : (xs + ys).sum = xs.sum + ys.sum
-- Mathlib/Analysis/Convex/SpecificFunctions/Pow.lean
lemma strictConcaveOn_rpow {p : ℝ} (hp₀ : 0 < p) (hp₁ : p < 1) :
    StrictConcaveOn ℝ (Set.Ici 0) fun x : ℝ ↦ x ^ p
-- Mathlib/LinearAlgebra/Dimension/Constructions.lean
theorem finrank_span_finset_eq_card {s : Finset M} (hs : LinearIndependent R ((↑) : s → M)) :
    finrank R (span R (s : Set M)) = s.card
-- Mathlib/LinearAlgebra/Finsupp.lean
theorem total_comapDomain (f : α → α') (l : α' →₀ R) (hf : Set.InjOn f (f ⁻¹' ↑l.support)) :
    Finsupp.total α M R v (Finsupp.comapDomain f l hf) =
      (l.support.preimage f hf).sum fun i => l (f i) • v i
-- Mathlib/CategoryTheory/Category/Preorder.lean
@[simp]
theorem Equivalence.toOrderIso_symm_apply (e : X ≌ Y) (y : Y) :
    e.toOrderIso.symm y = e.inverse.obj y
-- Mathlib/Analysis/SpecialFunctions/Arsinh.lean
/-- `sinh` is surjective, `∀ b, ∃ a, sinh a = b`. In this case, we use `a = arsinh b`. -/
theorem sinh_surjective : Surjective sinh
-- Mathlib/Data/Part.lean
@[to_additive]
theorem one_mem_one [One α] : (1 : α) ∈ (1 : Part α)
-- Mathlib/Analysis/Normed/Order/Lattice.lean
/-- If `α` has a solid norm, then the balls centered at the origin of `α` are solid sets. -/
theorem LatticeOrderedAddCommGroup.isSolid_ball (r : ℝ) :
    LatticeOrderedAddCommGroup.IsSolid (Metric.ball (0 : α) r)
-- Mathlib/Order/Filter/ENNReal.lean
theorem limsup_const_mul_of_ne_top {u : α → ℝ≥0∞} {a : ℝ≥0∞} (ha_top : a ≠ ⊤) :
    (f.limsup fun x : α => a * u x) = a * f.limsup u
-- Mathlib/Combinatorics/SimpleGraph/Clique.lean
@[simp]
theorem mem_cliqueFinset_iff : s ∈ G.cliqueFinset n ↔ G.IsNClique n s
-- Mathlib/RingTheory/GradedAlgebra/Basic.lean
/-- The ring homomorphism `GradedRing.projZeroRingHom' 𝒜` is surjective. -/
lemma GradedRing.projZeroRingHom'_surjective :
    Function.Surjective (GradedRing.projZeroRingHom' 𝒜)
-- Mathlib/Data/List/Intervals.lean
theorem filter_lt_of_succ_bot {n m : ℕ} (hnm : n < m) :
    ((Ico n m).filter fun x => x < n + 1) = [n]
-- Mathlib/LinearAlgebra/Matrix/MvPolynomial.lean
/-- A variant of `Matrix.mvPolynomialX_map_eval₂` with a bundled `AlgHom` on the LHS. -/
theorem mvPolynomialX_mapMatrix_aeval [Fintype m] [DecidableEq m] [CommSemiring R] [CommSemiring S]
    [Algebra R S] (A : Matrix m m S) :
    (MvPolynomial.aeval fun p : m × m => A p.1 p.2).mapMatrix (mvPolynomialX m m R) = A
-- Mathlib/RingTheory/Ideal/QuotientOperations.lean
@[simp]
theorem quotLeftToQuotSupₐ_toRingHom :
    (quotLeftToQuotSupₐ R I J : _ →+* _) = quotLeftToQuotSup I J
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem normalize_eq_iff (z₁ : d₁ ≠ 0) (z₂ : d₂ ≠ 0) :
    normalize n₁ d₁ z₁ = normalize n₂ d₂ z₂ ↔ n₁ * d₂ = n₂ * d₁
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[to_additive]
lemma prod_preimage' (f : ι → κ) [DecidablePred (· ∈ Set.range f)] (s : Finset κ) (hf) (g : κ → β) :
    ∏ x ∈ s.preimage f hf, g (f x) = ∏ x ∈ s.filter (· ∈ Set.range f), g x
-- Mathlib/Data/Matrix/ColumnRowPartitioned.lean
/-- A row partioned matrix when transposed gives a column partioned matrix with rows of the initial
matrix tranposed to become columns. -/
lemma transpose_fromRows (A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R) :
    transpose (fromRows A₁ A₂) = fromColumns (transpose A₁) (transpose A₂)
-- Mathlib/CategoryTheory/Sites/Sheaf.lean
theorem IsSheaf.hom_ext {A : Type u₂} [Category.{v₂} A] {E : A} {X : C} {P : Cᵒᵖ ⥤ A}
    (hP : Presheaf.IsSheaf J P) (S : J.Cover X) (e₁ e₂ : E ⟶ P.obj (op X))
    (h : ∀ I : S.Arrow, e₁ ≫ P.map I.f.op = e₂ ≫ P.map I.f.op) : e₁ = e₂
-- Mathlib/Topology/Algebra/Order/Rolle.lean
/-- A continuous function on a closed interval with `f a = f b`
has a local extremum at some point of the corresponding open interval. -/
theorem exists_isLocalExtr_Ioo (hab : a < b) (hfc : ContinuousOn f (Icc a b)) (hfI : f a = f b) :
    ∃ c ∈ Ioo a b, IsLocalExtr f c
-- Mathlib/Topology/Baire/Lemmas.lean
/-- Baire theorem: if countably many closed sets cover the whole space, then their interiors
are dense. Formulated here with an index set which is a countable type. -/
theorem dense_iUnion_interior_of_closed [Countable ι] {f : ι → Set X} (hc : ∀ i, IsClosed (f i))
    (hU : ⋃ i, f i = univ) : Dense (⋃ i, interior (f i))
-- Mathlib/Data/Fin/Basic.lean
/-- Embedding `i : Fin n` into `Fin (n + 1)` using a pivot `p` that is lesser
results in a value that is greater than `p`. -/
lemma lt_succAbove_iff_le_castSucc (p : Fin (n + 1)) (i : Fin n) :
    p < p.succAbove i ↔ p ≤ castSucc i
-- Mathlib/Data/Seq/Seq.lean
@[simp]
theorem nats_get? (n : ℕ) : nats.get? n = some n
-- Mathlib/CategoryTheory/Sites/Coherent/RegularTopology.lean
/-- A sieve is a cover for the regular topology if and only if it contains an `EffectiveEpi`. -/
theorem mem_sieves_iff_hasEffectiveEpi (S : Sieve X) :
    (S ∈ (regularTopology C).sieves  X) ↔
    ∃ (Y : C) (π : Y ⟶ X), EffectiveEpi π ∧ (S.arrows π)
-- .lake/packages/batteries/Batteries/Data/String/Lemmas.lean
@[simp] theorem data_join (ss : List String) : (join ss).data = (ss.map data).join
-- Mathlib/Analysis/Calculus/Dslope.lean
@[simp]
theorem continuousAt_dslope_same : ContinuousAt (dslope f a) a ↔ DifferentiableAt 𝕜 f a
-- Mathlib/Data/Set/Function.lean
theorem injOn_iff_invFunOn_image_image_eq_self [Nonempty α] :
    InjOn f s ↔ (invFunOn f s) '' (f '' s) = s
-- Mathlib/Analysis/Normed/Group/Seminorm.lean
/-- A norm on an additive group `G` is a function `f : G → ℝ` that preserves zero, is subadditive
and such that `f (-x) = f x` and `f x = 0 → x = 0` for all `x`. -/
structure AddGroupNorm (G : Type*) [AddGroup G] extends AddGroupSeminorm G where
  /-- If the image under the seminorm is zero, then the argument is zero. -/
  protected eq_zero_of_map_eq_zero' : ∀ x, toFun x = 0 → x = 0
-- Mathlib/Combinatorics/SimpleGraph/Walk.lean
@[simp]
theorem edges_reverse {u v : V} (p : G.Walk u v) : p.reverse.edges = p.edges.reverse
-- Mathlib/Analysis/SpecialFunctions/Integrals.lean
@[simp]
theorem integral_sin_sq_mul_cos :
    ∫ x in a..b, sin x ^ 2 * cos x = (sin b ^ 3 - sin a ^ 3) / 3