ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Data/Part.lean
@[simp]
theorem getOrElse_none (d : α) [Decidable (none : Part α).Dom] : getOrElse none d = d
-- Mathlib/Data/Vector/Snoc.lean
@[simp]
theorem reverse_snoc : reverse (xs.snoc x) = x ::ᵥ (reverse xs)
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[reassoc (attr := simp)]
theorem kernelComparison_comp_ι [HasKernel f] [HasKernel (G.map f)] :
    kernelComparison f G ≫ kernel.ι (G.map f) = G.map (kernel.ι f)
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
lemma norm_fourierSMulRight (L : V →L[ℝ] W →L[ℝ] ℝ) (f : V → E) (v : V) :
    ‖fourierSMulRight L f v‖ = (2 * π) * ‖L v‖ * ‖f v‖
-- Mathlib/Combinatorics/Colex.lean
lemma IsInitSeg.exists_initSeg (h𝒜 : IsInitSeg 𝒜 r) (h𝒜₀ : 𝒜.Nonempty) :
    ∃ s : Finset α, s.card = r ∧ 𝒜 = initSeg s
-- Mathlib/MeasureTheory/Decomposition/Lebesgue.lean
lemma rnDeriv_add_of_mutuallySingular (ν₁ ν₂ μ : Measure α)
    [SigmaFinite ν₁] [SigmaFinite ν₂] [SigmaFinite μ] (h : ν₂ ⟂ₘ μ) :
    (ν₁ + ν₂).rnDeriv μ =ᵐ[μ] ν₁.rnDeriv μ
-- Mathlib/Analysis/Normed/Module/Complemented.lean
theorem closedComplemented_iff_isClosed_exists_isClosed_isCompl :
    p.ClosedComplemented ↔
      IsClosed (p : Set E) ∧ ∃ q : Submodule 𝕜 E, IsClosed (q : Set E) ∧ IsCompl p q
-- Mathlib/Algebra/GroupWithZero/Units/Basic.lean
lemma zpow_neg_mul_zpow_self (n : ℤ) (ha : a ≠ 0) : a ^ (-n) * a ^ n = 1
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
/-- Given a point in an affine subspace, a vector is in its direction if and only if it results from
subtracting that point on the left. -/
theorem mem_direction_iff_eq_vsub_left {s : AffineSubspace k P} {p : P} (hp : p ∈ s) (v : V) :
    v ∈ s.direction ↔ ∃ p2 ∈ s, v = p -ᵥ p2
-- Mathlib/Algebra/Star/StarAlgHom.lean
@[simp]
theorem fst_prod (f : A →⋆ₙₐ[R] B) (g : A →⋆ₙₐ[R] C) : (fst R B C).comp (prod f g) = f
-- Mathlib/Order/LiminfLimsup.lean
theorem isBounded_principal (s : Set α) : IsBounded r (𝓟 s) ↔ ∃ t, ∀ x ∈ s, r x t
-- Mathlib/Analysis/Complex/Liouville.lean
/-- An auxiliary lemma for Liouville's theorem `Differentiable.apply_eq_apply_of_bounded`. -/
theorem liouville_theorem_aux {f : ℂ → F} (hf : Differentiable ℂ f) (hb : IsBounded (range f))
    (z w : ℂ) : f z = f w
-- Mathlib/AlgebraicTopology/SimplexCategory.lean
theorem eq_σ_of_epi {n : ℕ} (θ : mk (n + 1) ⟶ mk n) [Epi θ] : ∃ i : Fin (n + 1), θ = σ i
-- Mathlib/Topology/MetricSpace/Holder.lean
/-- A Hölder continuous function is uniformly continuous -/
protected theorem uniformContinuous (hf : HolderWith C r f) (h0 : 0 < r) : UniformContinuous f
-- Mathlib/Data/Nat/ModEq.lean
lemma cancel_left_div_gcd' (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : c * a ≡ d * b [MOD m]) :
    a ≡ b [MOD m / gcd m c]
-- Mathlib/Data/Finsupp/Interval.lean
theorem card_uIcc :
    (uIcc f g).card = ∏ i ∈ f.support ∪ g.support, (uIcc (f i) (g i)).card
-- Mathlib/RingTheory/Polynomial/Basic.lean
@[simp]
theorem restriction_zero : restriction (0 : R[X]) = 0
-- Mathlib/GroupTheory/GroupAction/Basic.lean
@[to_additive (attr := norm_cast, simp)]
lemma orbitRel.Quotient.mem_subgroup_orbit_iff {H : Subgroup G} {x : orbitRel.Quotient G α}
    {a b : x.orbit} : (a : α) ∈ MulAction.orbit H (b : α) ↔ a ∈ MulAction.orbit H b
-- Mathlib/Analysis/NormedSpace/PiTensorProduct/InjectiveSeminorm.lean
@[simp]
theorem mapL_one : mapL (fun (i : ι) ↦ (1 : E i →L[𝕜] E i)) = 1
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma MorphismProperty.RightFraction.map_eq_iff
    {X Y : C} (φ ψ : W.RightFraction X Y) :
    φ.map L (Localization.inverts _ _) = ψ.map L (Localization.inverts _ _) ↔
      RightFractionRel φ ψ
-- Mathlib/Algebra/BigOperators/Associated.lean
theorem Finset.prod_primes_dvd [CancelCommMonoidWithZero α] [Unique αˣ] {s : Finset α} (n : α)
    (h : ∀ a ∈ s, Prime a) (div : ∀ a ∈ s, a ∣ n) : (∏ p ∈ s, p) ∣ n
-- Mathlib/Algebra/CharP/Basic.lean
theorem CharP.neg_one_pow_char_pow [Ring R] (p n : ℕ) [CharP R p] [Fact p.Prime] :
    (-1 : R) ^ p ^ n = -1
-- Mathlib/GroupTheory/Coxeter/Inversion.lean
@[simp] theorem length_leftInvSeq (ω : List B) : (lis ω).length = ω.length
-- Mathlib/Probability/Variance.lean
@[simp]
theorem evariance_zero : evariance 0 μ = 0
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean
@[measurability]
theorem add_measure [PseudoMetrizableSpace β] {ν : Measure α} {f : α → β}
    (hμ : AEStronglyMeasurable f μ) (hν : AEStronglyMeasurable f ν) :
    AEStronglyMeasurable f (μ + ν)
-- Mathlib/Data/Finset/Sort.lean
theorem orderEmbOfFin_apply (s : Finset α) {k : ℕ} (h : s.card = k) (i : Fin k) :
    s.orderEmbOfFin h i =
      (s.sort (· ≤ ·)).get ⟨i, by rw [length_sort, h]; exact i.2⟩
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
@[simp] theorem cons_merge_cons_neg (s : α → α → Bool) (l r) (h : ¬ s a b) :
    merge s (a::l) (b::r) = b :: merge s (a::l) r
-- Mathlib/Combinatorics/SimpleGraph/Regularity/Chunk.lean
/-- Lower bound on the edge densities between parts of `SzemerediRegularity.increment`. This is the
blanket lower bound used the uniform parts. -/
theorem edgeDensity_chunk_uniform [Nonempty α] (hPα : P.parts.card * 16 ^ P.parts.card ≤ card α)
    (hPε : ↑100 ≤ ↑4 ^ P.parts.card * ε ^ 5) (hU : U ∈ P.parts) (hV : V ∈ P.parts) :
    (G.edgeDensity U V : ℝ) ^ 2 - ε ^ 5 / ↑25 ≤
    (∑ ab ∈ (chunk hP G ε hU).parts.product (chunk hP G ε hV).parts,
      (G.edgeDensity ab.1 ab.2 : ℝ) ^ 2) / ↑16 ^ P.parts.card
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
@[simp]
lemma ofHom_v (φ : F ⟶ G) (p : ℤ) : (ofHom φ).v p p (add_zero p) = φ.f p
-- Mathlib/Algebra/Polynomial/Splits.lean
theorem eq_prod_roots_of_splits {p : K[X]} {i : K →+* L} (hsplit : Splits i p) :
    p.map i = C (i p.leadingCoeff) * ((p.map i).roots.map fun a => X - C a).prod
-- Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean
lemma mk' (h : S.RightHomologyData) : HasRightHomology S
-- Mathlib/Algebra/Polynomial/EraseLead.lean
@[simp]
theorem eraseLead_add_monomial_natDegree_leadingCoeff (f : R[X]) :
    f.eraseLead + monomial f.natDegree f.leadingCoeff = f
-- Mathlib/Analysis/Normed/Group/AddTorsor.lean
theorem ContinuousOn.vsub {f g : α → P} {s : Set α} (hf : ContinuousOn f s)
    (hg : ContinuousOn g s) : ContinuousOn (f -ᵥ g) s
-- Mathlib/CategoryTheory/Comma/Over.lean
/-- Mapping by `f` and then forgetting is the same as forgetting. -/
theorem mapForget_eq {X Y : T} (f : X ⟶ Y) :
    (map f) ⋙ (forget Y) = (forget X)
-- Mathlib/LinearAlgebra/LinearIndependent.lean
/-- A version of `linearDependent_comp_subtype'` with `Finsupp.total` unfolded. -/
theorem linearDependent_comp_subtype {s : Set ι} :
    ¬LinearIndependent R (v ∘ (↑) : s → M) ↔
      ∃ f : ι →₀ R, f ∈ Finsupp.supported R R s ∧ ∑ i ∈ f.support, f i • v i = 0 ∧ f ≠ 0
-- Mathlib/CategoryTheory/Extensive.lean
theorem FinitaryExtensive.mono_inr_of_isColimit [FinitaryExtensive C] {c : BinaryCofan X Y}
    (hc : IsColimit c) : Mono c.inr
-- Mathlib/Analysis/Calculus/LineDeriv/Basic.lean
theorem Filter.EventuallyEq.hasLineDerivAt_iff (h : f₀ =ᶠ[𝓝 x] f₁) :
    HasLineDerivAt 𝕜 f₀ f' x v ↔ HasLineDerivAt 𝕜 f₁ f' x v
-- Mathlib/Order/RelIso/Basic.lean
/-- Identity map is a relation embedding. -/
@[refl, simps!]
protected def refl (r : α → α → Prop) : r ↪r r
-- Mathlib/Analysis/InnerProductSpace/NormPow.lean
theorem differentiable_norm_rpow {p : ℝ} (hp : 1 < p) :
    Differentiable ℝ (fun x : E ↦ ‖x‖ ^ p)
-- Mathlib/Topology/Algebra/Module/CharacterSpace.lean
/-- The **Gelfand transform** is an algebra homomorphism (over `𝕜`) from a topological `𝕜`-algebra
`A` into the `𝕜`-algebra of continuous `𝕜`-valued functions on the `characterSpace 𝕜 A`.
The character space itself consists of all algebra homomorphisms from `A` to `𝕜`.  -/
@[simps]
def gelfandTransform : A →ₐ[𝕜] C(characterSpace 𝕜 A, 𝕜)
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
@[simp]
theorem MulEquiv.restrictRootsOfUnity_symm (σ : R ≃* S) :
    (σ.restrictRootsOfUnity k).symm = σ.symm.restrictRootsOfUnity k
-- Mathlib/Order/UpperLower/Basic.lean
@[simp]
theorem compl_iSup₂ (f : ∀ i, κ i → LowerSet α) :
    (⨆ (i) (j), f i j).compl = ⨆ (i) (j), (f i j).compl
-- Mathlib/Algebra/Polynomial/Derivative.lean
theorem coeff_derivative (p : R[X]) (n : ℕ) :
    coeff (derivative p) n = coeff p (n + 1) * (n + 1)
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
@[simp, norm_cast]
theorem ascPochhammer_eval_cast (n k : ℕ) :
    (((ascPochhammer ℕ n).eval k : ℕ) : S) = ((ascPochhammer S n).eval k : S)
-- Mathlib/MeasureTheory/MeasurableSpace/Defs.lean
theorem Set.Subsingleton.measurableSet {s : Set α} (hs : s.Subsingleton) : MeasurableSet s
-- Mathlib/Topology/MetricSpace/Thickening.lean
theorem closure_thickening_subset_cthickening (δ : ℝ) (E : Set α) :
    closure (thickening δ E) ⊆ cthickening δ E
-- Mathlib/Algebra/ContinuedFractions/Translations.lean
theorem exists_s_b_of_partDen {b : α}
    (nth_partDen_eq : g.partDens.get? n = some b) :
    ∃ gp, g.s.get? n = some gp ∧ gp.b = b
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean
@[simp]
lemma ψ_four : W.ψ 4 = C W.preΨ₄ * W.ψ₂
-- Mathlib/Data/DFinsupp/Order.lean
theorem support_inf_union_support_sup : (f ⊓ g).support ∪ (f ⊔ g).support = f.support ∪ g.support
-- Mathlib/NumberTheory/ArithmeticFunction.lean
@[simp, arith_mult]
theorem map_one {f : ArithmeticFunction R} (h : f.IsMultiplicative) : f 1 = 1
-- Mathlib/Data/Finset/Sups.lean
theorem disjSups_disjSups_disjSups_comm : s ○ t ○ (u ○ v) = s ○ u ○ (t ○ v)
-- Mathlib/Analysis/InnerProductSpace/OfNorm.lean
theorem inner_.norm_sq (x : E) : ‖x‖ ^ 2 = re (inner_ 𝕜 x x)
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- A dilation from a metric space is a uniform inducing map -/
protected theorem uniformInducing : UniformInducing (f : α → β)
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
theorem intValuation.le_max_iff_min_le {a b c : ℕ} :
    Multiplicative.ofAdd (-c : ℤ) ≤
      max (Multiplicative.ofAdd (-a : ℤ)) (Multiplicative.ofAdd (-b : ℤ)) ↔
      min a b ≤ c
-- Mathlib/FieldTheory/RatFunc/Basic.lean
theorem mk_eq_mk' (f : Polynomial K) {g : Polynomial K} (hg : g ≠ 0) :
    RatFunc.mk f g = IsLocalization.mk' (RatFunc K) f ⟨g, mem_nonZeroDivisors_iff_ne_zero.2 hg⟩
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem id_whiskerRight_bimod {X Y Z : Mon_ C} {M : Bimod X Y} {N : Bimod Y Z} :
    whiskerRight (𝟙 M) N = 𝟙 (M.tensorBimod N)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem count_ne_zero_iff_dvd {a p : α} (ha0 : a ≠ 0) (hp : Irreducible p) :
    (Associates.mk p).count (Associates.mk a).factors ≠ 0 ↔ p ∣ a
-- Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean
/-- Equivalent characterizations for equicontinuity of a family of continuous linear maps
between normed spaces. See also `WithSeminorms.equicontinuous_TFAE` for similar characterizations
between spaces satisfying `WithSeminorms`. -/
protected theorem NormedSpace.equicontinuous_TFAE : List.TFAE
    [ EquicontinuousAt ((↑) ∘ f) 0,
      Equicontinuous ((↑) ∘ f),
      UniformEquicontinuous ((↑) ∘ f),
      ∃ C, ∀ i x, ‖f i x‖ ≤ C * ‖x‖,
      ∃ C ≥ 0, ∀ i x, ‖f i x‖ ≤ C * ‖x‖,
      ∃ C, ∀ i, ‖f i‖ ≤ C,
      ∃ C ≥ 0, ∀ i, ‖f i‖ ≤ C,
      BddAbove (Set.range (‖f ·‖)),
      (⨆ i, (‖f i‖₊ : ENNReal)) < ⊤ ]
-- Mathlib/AlgebraicGeometry/Spec.lean
lemma Spec.locallyRingedSpaceObj_presheaf_map' (R : Type u) [CommRing R] {U V} (i : U ⟶ V) :
    (Spec.locallyRingedSpaceObj <| CommRingCat.of R).presheaf.map i =
    (structureSheaf R).1.map i
-- .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean
theorem normalize_add_normalize (n₁ n₂) {d₁ d₂} (z₁ z₂) :
    normalize n₁ d₁ z₁ + normalize n₂ d₂ z₂ =
    normalize (n₁ * d₂ + n₂ * d₁) (d₁ * d₂) (Nat.mul_ne_zero z₁ z₂)
-- Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean
/-- The `n+1`-th iterated derivative within a set with unique derivatives can be obtained by
differentiating the `n`-th iterated derivative. -/
theorem iteratedDerivWithin_succ {x : 𝕜} (hxs : UniqueDiffWithinAt 𝕜 s x) :
    iteratedDerivWithin (n + 1) f s x = derivWithin (iteratedDerivWithin n f s) s x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean
/-- If the second of three points is strictly between the other two, the oriented angle at the
third point is zero. -/
theorem _root_.Sbtw.oangle₂₃₁_eq_zero {p₁ p₂ p₃ : P} (h : Sbtw ℝ p₁ p₂ p₃) : ∡ p₂ p₃ p₁ = 0
-- Mathlib/LinearAlgebra/QuadraticForm/Isometry.lean
@[simp]
theorem ofEq_rfl {Q : QuadraticMap R M₁ N} : ofEq (rfl : Q = Q) = .id Q
-- Mathlib/CategoryTheory/Limits/TypesFiltered.lean
theorem eqvGen_quot_rel_of_rel (x y : Σ j, F.obj j) :
    FilteredColimit.Rel.{v, u} F x y → EqvGen (Quot.Rel F) x y
-- Mathlib/Control/Fix.lean
theorem fix_def' {x : α} (h' : ¬∃ i, (Fix.approx f i x).Dom) : Part.fix f x = none
-- Mathlib/Order/SuccPred/Basic.lean
theorem pred_eq_iff_covBy : pred b = a ↔ a ⋖ b
-- Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean
theorem two_nsmul_eq_iff {ψ θ : Angle} : (2 : ℕ) • ψ = (2 : ℕ) • θ ↔ ψ = θ ∨ ψ = θ + ↑π
-- Mathlib/Topology/Algebra/Algebra.lean
theorem mul_apply (f g : A →A[R] A) (x : A) : (f * g) x = f (g x)
-- Mathlib/Data/Nat/Factorization/Basic.lean
/-- The multiplicity of prime `p` in `p` is `1` -/
@[simp]
theorem Prime.factorization_self {p : ℕ} (hp : Prime p) : p.factorization p = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[ext] theorem ext_getElem? {l₁ l₂ : List α} (h : ∀ n : Nat, l₁[n]? = l₂[n]?) : l₁ = l₂
-- Mathlib/Analysis/Convex/Cone/Extension.lean
theorem exists_top (p : E →ₗ.[ℝ] ℝ) (hp_nonneg : ∀ x : p.domain, (x : E) ∈ s → 0 ≤ p x)
    (hp_dense : ∀ y, ∃ x : p.domain, (x : E) + y ∈ s) :
    ∃ q ≥ p, q.domain = ⊤ ∧ ∀ x : q.domain, (x : E) ∈ s → 0 ≤ q x
-- Mathlib/Algebra/Order/CauSeq/Basic.lean
theorem lt_trans {f g h : CauSeq α abs} (fg : f < g) (gh : g < h) : f < h
-- Mathlib/Data/Nat/Factorial/Basic.lean
theorem pow_lt_ascFactorial' (n k : ℕ) : (n + 1) ^ (k + 2) < (n + 1).ascFactorial (k + 2)
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem inf_continuous (f g : α →o β) (hf : Continuous f) (hg : Continuous g) :
    Continuous (f ⊓ g)
-- Mathlib/MeasureTheory/Constructions/Pi.lean
theorem pi'_eq_pi [Encodable ι] : pi' μ = Measure.pi μ
-- Mathlib/MeasureTheory/Covering/Differentiation.lean
theorem ae_tendsto_limRatio :
    ∀ᵐ x ∂μ, Tendsto (fun a => ρ a / μ a) (v.filterAt x) (𝓝 (v.limRatio ρ x))
-- Mathlib/LinearAlgebra/Matrix/ToLin.lean
theorem LinearMap.toMatrix_comp [Finite l] [DecidableEq m] (f : M₂ →ₗ[R] M₃) (g : M₁ →ₗ[R] M₂) :
    LinearMap.toMatrix v₁ v₃ (f.comp g) =
    LinearMap.toMatrix v₂ v₃ f * LinearMap.toMatrix v₁ v₂ g
-- Mathlib/Data/Complex/Exponential.lean
theorem exp_eq_exp_re_mul_sin_add_cos : exp x = exp x.re * (cos x.im + sin x.im * I)
-- Mathlib/Data/Set/Function.lean
theorem BijOn.invOn_invFunOn [Nonempty α] (h : BijOn f s t) : InvOn (invFunOn f s) f s t
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem finsetCongr_trans (e : α ≃ β) (e' : β ≃ γ) :
    e.finsetCongr.trans e'.finsetCongr = (e.trans e').finsetCongr
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
theorem bit_not_add_self (x : BitVec w) :
  ((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd + x  = -1
-- Mathlib/Data/Bool/Basic.lean
theorem or_eq_false_eq_eq_false_and_eq_false (a b : Bool) :
    ((a || b) = false) = (a = false ∧ b = false)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Lemmas.lean
protected theorem pred_min_pred : ∀ (x y), min (pred x) (pred y) = pred (min x y)
-- Mathlib/Topology/ContinuousFunction/Basic.lean
@[simp]
theorem cancel_left {f : C(β, γ)} {g₁ g₂ : C(α, β)} (hf : Injective f) :
    f.comp g₁ = f.comp g₂ ↔ g₁ = g₂
-- Mathlib/Algebra/Regular/Basic.lean
/-- A right-regular element of a `Nontrivial` `MulZeroClass` is non-zero. -/
theorem IsRightRegular.ne_zero [Nontrivial R] (ra : IsRightRegular a) : a ≠ 0
-- Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean
lemma LeftFraction.op_map
    {X Y : C} (φ : W.LeftFraction X Y) (L : C ⥤ D) (hL : W.IsInvertedBy L) :
    (φ.map L hL).op = φ.op.map L.op hL.op
-- Mathlib/Data/Set/Image.lean
theorem preimage_congr {f g : α → β} {s : Set β} (h : ∀ x : α, f x = g x) : f ⁻¹' s = g ⁻¹' s
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
/-- A variant of `Finset.mul_prod_erase` with the multiplication swapped. -/
@[to_additive "A variant of `Finset.add_sum_erase` with the addition swapped."]
theorem prod_erase_mul [DecidableEq α] (s : Finset α) (f : α → β) {a : α} (h : a ∈ s) :
    (∏ x ∈ s.erase a, f x) * f a = ∏ x ∈ s, f x
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
theorem rpow_le_one {x : ℝ≥0} {z : ℝ} (hx2 : x ≤ 1) (hz : 0 ≤ z) : x ^ z ≤ 1
-- Mathlib/LinearAlgebra/TensorProduct/Submodule.lean
theorem mulMap_one_right_eq : mulMap M 1 = M.subtype ∘ₗ M.rTensorOne.toLinearMap
-- Mathlib/Data/Set/Sups.lean
theorem sups_subset_left : t₁ ⊆ t₂ → s ⊻ t₁ ⊆ s ⊻ t₂
-- Mathlib/Order/OmegaCompletePartialOrder.lean
theorem top_continuous : Continuous (⊤ : α →o β)
-- Mathlib/LinearAlgebra/Matrix/Hermitian.lean
@[simp]
theorem isHermitian_submatrix_equiv {A : Matrix n n α} (e : m ≃ n) :
    (A.submatrix e e).IsHermitian ↔ A.IsHermitian
-- Mathlib/Data/Finset/Sups.lean
protected theorem Nonempty.infs : s.Nonempty → t.Nonempty → (s ⊼ t).Nonempty
-- Mathlib/Analysis/Complex/TaylorSeries.lean
/-- A function that is complex differentiable on the open ball of radius `r ≤ ∞` around `c`
is given by evaluating its Taylor series at `c` on this open ball. -/
lemma taylorSeries_eq_on_emetric_ball :
    ∑' n : ℕ, (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c = f z
-- .lake/packages/batteries/Batteries/Data/Fin/Lemmas.lean
theorem foldl_succ_last (f : α → Fin (n+1) → α) (x) :
    foldl (n+1) f x = f (foldl n (f · ·.castSucc) x) (last n)
-- Mathlib/Data/List/Perm.lean
@[simp]
theorem mem_permutations {s t : List α} : s ∈ permutations t ↔ s ~ t
-- Mathlib/RingTheory/TensorProduct/Basic.lean
lemma _root_.Basis.baseChange_end (b : Basis ι R M) (ij : ι × ι) :
    baseChange A (b.end ij) = (basis A b).end ij
-- Mathlib/Analysis/Convex/Function.lean
theorem ConvexOn.convex_lt (hf : ConvexOn 𝕜 s f) (r : β) : Convex 𝕜 ({ x ∈ s | f x < r })
-- Mathlib/MeasureTheory/Integral/DominatedConvergence.lean
theorem continuous_parametric_intervalIntegral_of_continuous'
    (hf : Continuous f.uncurry) (a₀ b₀ : ℝ) :
    Continuous fun x ↦ ∫ t in a₀..b₀, f x t ∂μ
-- Mathlib/Algebra/GCDMonoid/Finset.lean
theorem lcm_mono_fun {g : β → α} (h : ∀ b ∈ s, f b ∣ g b) : s.lcm f ∣ s.lcm g
-- Mathlib/Topology/Instances/Rat.lean
theorem uniformEmbedding_coe_real : UniformEmbedding ((↑) : ℚ → ℝ)
-- Mathlib/NumberTheory/LucasLehmer.lean
theorem sMod_lt (p : ℕ) (hp : p ≠ 0) (i : ℕ) : sMod p i < 2 ^ p - 1
-- Mathlib/MeasureTheory/Measure/Restrict.lean
theorem ae_eq_comp' {ν : Measure β} {f : α → β} {g g' : β → δ} (hf : AEMeasurable f μ)
    (h : g =ᵐ[ν] g') (h2 : μ.map f ≪ ν) : g ∘ f =ᵐ[μ] g' ∘ f
-- Mathlib/Data/Set/Basic.lean
theorem union_comm (a b : Set α) : a ∪ b = b ∪ a
-- Mathlib/Order/Interval/Set/WithBotTop.lean
theorem image_coe_Ioo : (some : α → WithBot α) '' Ioo a b = Ioo (a : WithBot α) b
-- Mathlib/Algebra/Polynomial/Eval.lean
@[simp]
theorem natCast_mul_comp {n : ℕ} : ((n : R[X]) * p).comp r = n * p.comp r
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
@[simp]
theorem trim_zero : (0 : OuterMeasure α).trim = 0
-- Mathlib/Tactic/CancelDenoms/Core.lean
theorem neg_subst {α} [Ring α] {n e t : α} (h1 : n * e = t) : n * -e = -t
-- Mathlib/Algebra/Quaternion.lean
theorem finrank_eq_four [StrongRankCondition R] : FiniteDimensional.finrank R ℍ[R,c₁,c₂] = 4
-- Mathlib/CategoryTheory/Abelian/NonPreadditive.lean
theorem sub_def {X Y : C} (a b : X ⟶ Y) : a - b = prod.lift a b ≫ σ
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_iInf {ι} (f : ι → Cardinal) : lift.{u, v} (iInf f) = ⨅ i, lift.{u, v} (f i)
-- Mathlib/RingTheory/DedekindDomain/Ideal.lean
theorem isCoprime_iff_gcd {I J : Ideal A} : IsCoprime I J ↔ gcd I J = 1
-- Mathlib/Data/Multiset/Basic.lean
@[simp]
theorem map_le_map {f : α → β} {s t : Multiset α} (h : s ≤ t) : map f s ≤ map f t
-- .lake/packages/lean4/src/lean/Init/Omega/IntList.lean
@[simp] theorem dot_set_left (xs ys : IntList) (i : Nat) (z : Int) :
    dot (xs.set i z) ys = dot xs ys + (z - xs.get i) * ys.get i
-- .lake/packages/lean4/src/lean/Init/Core.lean
@[elab_as_elim]
protected theorem inductionOn {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop}
    (q : Quot r)
    (h : (a : α) → motive (Quot.mk r a))
    : motive q
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean
theorem measure_interior_of_null_frontier {μ : Measure α'} {s : Set α'} (h : μ (frontier s) = 0) :
    μ (interior s) = μ s
-- Mathlib/MeasureTheory/Integral/BoundedContinuousFunction.lean
lemma integral_add_const (f : X →ᵇ ℝ) (c : ℝ) :
    ∫ x, (f + const X c) x ∂μ = ∫ x, f x ∂μ + ENNReal.toReal (μ (Set.univ)) • c
-- Mathlib/CategoryTheory/MorphismProperty/Limits.lean
theorem StableUnderBaseChange.unop {P : MorphismProperty Cᵒᵖ} (hP : StableUnderBaseChange P) :
    StableUnderCobaseChange P.unop
-- Mathlib/Data/List/Indexes.lean
theorem foldlIdx_eq_foldlIdxSpec (f : ℕ → α → β → α) (a bs start) :
    foldlIdx f a bs start = foldlIdxSpec f a bs start
-- Mathlib/LinearAlgebra/AffineSpace/Basis.lean
theorem exists_affineBasis : ∃ (s : Set P) (b : AffineBasis (↥s) k P), ⇑b = ((↑) : s → P)
-- Mathlib/MeasureTheory/Integral/SetToL1.lean
theorem setToL1_simpleFunc_indicatorConst (hT : DominatedFinMeasAdditive μ T C) {s : Set α}
    (hs : MeasurableSet s) (hμs : μ s < ∞) (x : E) :
    setToL1 hT (simpleFunc.indicatorConst 1 hs hμs.ne x) = T s x
-- Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean
private lemma sup_aux : a ∈ lowerClosure s → (s.filter fun b ↦ a ≤ b).Nonempty
-- Mathlib/AlgebraicGeometry/AffineScheme.lean
/-- The basic open set of a section `f` on an affine open as an `X.affineOpens`. -/
@[simps]
def _root_.AlgebraicGeometry.Scheme.affineBasicOpen
    (X : Scheme) {U : X.affineOpens} (f : Γ(X, U)) : X.affineOpens
-- Mathlib/RingTheory/MvPolynomial/NewtonIdentities.lean
private theorem sum_filter_pairs_eq_sum_powersetCard_sum (k : ℕ)
    (f : Finset σ × σ → MvPolynomial σ R) :
    (∑ t ∈ filter (fun t ↦ card t.fst = k) (pairs σ k), f t) =
    ∑ A ∈ powersetCard k univ, (∑ j ∈ A, f (A, j))
-- Mathlib/MeasureTheory/OuterMeasure/Basic.lean
lemma measure_null_iff_singleton (hs : s.Countable) : μ s = 0 ↔ ∀ x ∈ s, μ {x} = 0
-- Mathlib/MeasureTheory/Integral/IntegrableOn.lean
theorem IntegrableOn.inter_of_restrict (h : IntegrableOn f s (μ.restrict t)) :
    IntegrableOn f (s ∩ t) μ
-- Mathlib/Topology/FiberBundle/Basic.lean
theorem continuous_totalSpaceMk (x : B) : Continuous (@TotalSpace.mk B F E x)
-- Mathlib/Order/Closure.lean
theorem closure_inf_le [SemilatticeInf α] [Preorder β] {u : β → α} (l : LowerAdjoint u) (x y : α) :
    u (l (x ⊓ y)) ≤ u (l x) ⊓ u (l y)
-- Mathlib/MeasureTheory/Function/LpSpace.lean
theorem coeFn_toLp {f : α → E} (hf : Memℒp f p μ) : hf.toLp f =ᵐ[μ] f
-- Mathlib/Logic/Equiv/Defs.lean
@[simp] theorem apply_symm_apply (e : α ≃ β) (x : β) : e (e.symm x) = x
-- Mathlib/CategoryTheory/Triangulated/Pretriangulated.lean
lemma epi₃ (h : T.mor₁ = 0) : Epi T.mor₃
-- Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean
@[simp]
lemma cyclesMap_add : cyclesMap (φ + φ') = cyclesMap φ + cyclesMap φ'
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean
/-- Differentiability of `Θ z τ` in `z`, for fixed `τ`. -/
lemma differentiableAt_jacobiTheta₂_fst (z : ℂ) {τ : ℂ} (hτ : 0 < im τ) :
    DifferentiableAt ℂ (jacobiTheta₂ · τ) z
-- Mathlib/NumberTheory/NumberField/Embeddings.lean
lemma mem_orbit_iff [IsGalois k K] {w w' : InfinitePlace K} :
    w' ∈ MulAction.orbit (K ≃ₐ[k] K) w ↔ w.comap (algebraMap k K) = w'.comap (algebraMap k K)
-- Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean
/-- Post-composition by a uniform embedding is a uniform embedding for the
uniform structures of `𝔖`-convergence.

More precisely, if `f : γ → β` is a uniform embedding, then
`(fun g ↦ f ∘ g) : (α →ᵤ[𝔖] γ) → (α →ᵤ[𝔖] β)` is a uniform embedding. -/
protected theorem postcomp_uniformEmbedding [UniformSpace γ] {f : γ → β} (hf : UniformEmbedding f) :
    UniformEmbedding (ofFun 𝔖 ∘ (f ∘ ·) ∘ toFun 𝔖)
-- Mathlib/GroupTheory/Order/Min.lean
@[to_additive]
lemma minOrder_le_natCard (hs : s ≠ ⊥) (hs' : (s : Set α).Finite) : minOrder α ≤ Nat.card s
-- Mathlib/GroupTheory/GroupAction/DomAct/Basic.lean
@[to_additive]
theorem smul_apply [SMul M α] (c : Mᵈᵐᵃ) (f : α → β) (a : α) : (c • f) a = f (mk.symm c • a)