ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Order/WithBot.lean
@[simp]
theorem monotone_map_iff {f : α → β} : Monotone (WithTop.map f) ↔ Monotone f
-- Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean
/-- The tangent of an angle in a right-angled triangle multiplied by the adjacent side equals
the opposite side, version subtracting vectors. -/
theorem tan_angle_sub_mul_norm_of_inner_eq_zero {x y : V} (h : ⟪x, y⟫ = 0) (h0 : x ≠ 0 ∨ y = 0) :
    Real.tan (angle x (x - y)) * ‖x‖ = ‖y‖
-- Mathlib/RingTheory/Derivation/Basic.lean
@[simp]
theorem mk_coe (f : A →ₗ[R] M) (h₁ h₂) : ((⟨f, h₁, h₂⟩ : Derivation R A M) : A → M) = f
-- Mathlib/Data/Finset/Basic.lean
theorem disjoint_or_nonempty_inter (s t : Finset α) : Disjoint s t ∨ (s ∩ t).Nonempty
-- Mathlib/ModelTheory/Satisfiability.lean
theorem models_sentence_of_mem {φ : L.Sentence} (h : φ ∈ T) : T ⊨ᵇ φ
-- Mathlib/Analysis/Convex/Integral.lean
/-- If `E` is a strictly convex normed space and `f : α → E` is a function such that `‖f x‖ ≤ C`
a.e., then either this function is a.e. equal to its average value, or the norm of its average value
is strictly less than `C`. -/
theorem ae_eq_const_or_norm_average_lt_of_norm_le_const [StrictConvexSpace ℝ E]
    (h_le : ∀ᵐ x ∂μ, ‖f x‖ ≤ C) : f =ᵐ[μ] const α (⨍ x, f x ∂μ) ∨ ‖⨍ x, f x ∂μ‖ < C
-- Mathlib/LinearAlgebra/Dual.lean
theorem dualDistrib_dualDistribInvOfBasis_right_inverse (b : Basis ι R M) (c : Basis κ R N) :
    comp (dualDistribInvOfBasis b c) (dualDistrib R M N) = LinearMap.id
-- Mathlib/CategoryTheory/Limits/Shapes/ZeroMorphisms.lean
@[simp]
theorem _root_.CategoryTheory.Functor.zero_obj [HasZeroObject D] (X : C) :
    IsZero ((0 : C ⥤ D).obj X)
-- Mathlib/Data/Finset/Card.lean
theorem card_le_one_iff_subsingleton_coe : s.card ≤ 1 ↔ Subsingleton (s : Type _)
-- Mathlib/Data/List/Sigma.lean
theorem nodupKeys_join {L : List (List (Sigma β))} :
    NodupKeys (join L) ↔ (∀ l ∈ L, NodupKeys l) ∧ Pairwise Disjoint (L.map keys)
-- Mathlib/Order/Bounds/Basic.lean
@[simp] theorem isLUB_singleton : IsLUB {a} a
-- Mathlib/Logic/Basic.lean
theorem not_forall₂_of_exists₂_not : (∃ x h, ¬P x h) → ¬∀ x h, P x h
-- Mathlib/Algebra/Order/Module/Rat.lean
@[simp] lemma abs_nnqsmul [DistribMulAction ℚ≥0 α] [PosSMulMono ℚ≥0 α] (q : ℚ≥0) (a : α) :
    |q • a| = q • |a|
-- Mathlib/Topology/VectorBundle/Basic.lean
@[simp, mfld_simps]
theorem mem_source_at : (⟨b, a⟩ : Z.TotalSpace) ∈ (Z.localTrivAt b).source
-- Mathlib/Analysis/MellinTransform.lean
/-- If `f` is a locally integrable real-valued function on `Ioi 0` which is `O(x ^ (-a))` at `∞`
and `O(x ^ (-b))` at `0`, then its Mellin transform integral converges for `b < s < a`. -/
theorem mellin_convergent_of_isBigO_scalar {a b : ℝ} {f : ℝ → ℝ} {s : ℝ}
    (hfc : LocallyIntegrableOn f <| Ioi 0) (hf_top : f =O[atTop] (· ^ (-a)))
    (hs_top : s < a) (hf_bot : f =O[𝓝[>] 0] (· ^ (-b))) (hs_bot : b < s) :
    IntegrableOn (fun t : ℝ => t ^ (s - 1) * f t) (Ioi 0)
-- Mathlib/CategoryTheory/Limits/Shapes/Images.lean
/-- If a category `has_image_maps`, then all commutative squares induce morphisms on images. -/
class HasImageMaps : Prop where
  has_image_map : ∀ {f g : Arrow C} (st : f ⟶ g), HasImageMap st
-- Mathlib/Tactic/Ring/Basic.lean
theorem inv_mul {R} [DivisionRing R] {a₁ a₂ a₃ b₁ b₃ c}
    (_ : (a₁⁻¹ : R) = b₁) (_ : (a₃⁻¹ : R) = b₃)
    (_ : b₃ * (b₁ ^ a₂ * (nat_lit 1).rawCast) = c) :
    (a₁ ^ a₂ * a₃ : R)⁻¹ = c
-- Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean
theorem map_span (s : Set P₁) : (affineSpan k s).map f = affineSpan k (f '' s)
-- Mathlib/Order/RelIso/Basic.lean
protected theorem isIrrefl [RelHomClass F r s] (f : F) : ∀ [IsIrrefl β s], IsIrrefl α r
-- Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean
@[simp]
theorem cokernel.desc_zero {W : C} {h} : cokernel.desc f (0 : Y ⟶ W) h = 0
-- Mathlib/Topology/Algebra/Module/Basic.lean
@[simp]
theorem snd_equivOfRightInverse (f₁ : M →L[R] M₂) (f₂ : M₂ →L[R] M)
    (h : Function.RightInverse f₂ f₁) (x : M) :
    ((equivOfRightInverse f₁ f₂ h x).2 : M) = x - f₂ (f₁ x)
-- Mathlib/Topology/Order/IsLUB.lean
theorem IsLUB.isGLB_of_tendsto [Preorder γ] [TopologicalSpace γ] [OrderClosedTopology γ] :
    ∀ {f : α → γ} {s : Set α} {a : α} {b : γ},
      AntitoneOn f s → IsLUB s a → s.Nonempty → Tendsto f (𝓝[s] a) (𝓝 b) → IsGLB (f '' s) b
-- Mathlib/Topology/ContinuousFunction/Basic.lean
theorem map_continuousAt (f : F) (a : α) : ContinuousAt f a
-- Mathlib/RingTheory/Ideal/Cotangent.lean
theorem toCotangent_range : LinearMap.range I.toCotangent = ⊤
-- Mathlib/Data/Nat/Digits.lean
@[simp]
theorem digits_zero (b : ℕ) : digits b 0 = []
-- Mathlib/Combinatorics/SimpleGraph/Path.lean
@[simp]
theorem nodup_support {u v : V} (p : G.Path u v) : (p : G.Walk u v).support.Nodup
-- Mathlib/Algebra/RingQuot.lean
theorem one_quot : (⟨Quot.mk _ 1⟩ : RingQuot r) = 1
-- Mathlib/RingTheory/FreeRing.lean
@[simp]
theorem map_of (x : α) : map f (of x) = of (f x)
-- Mathlib/Analysis/InnerProductSpace/Orientation.lean
/-- `adjustToOrientation` gives an orthonormal basis with the required orientation. -/
@[simp]
theorem orientation_adjustToOrientation : (e.adjustToOrientation x).toBasis.orientation = x
-- Mathlib/NumberTheory/Padics/PadicVal.lean
@[simp]
protected theorem prime_pow (n : ℕ) : padicValNat p (p ^ n) = n
-- Mathlib/Analysis/LocallyConvex/Bounded.lean
theorem IsVonNBounded.of_boundedSpace [BoundedSpace 𝕜] {s : Set E} : IsVonNBounded 𝕜 s
-- Mathlib/Order/SupClosed.lean
lemma InfClosed.image [FunLike F α β] [InfHomClass F α β] (hs : InfClosed s) (f : F) :
    InfClosed (f '' s)
-- Mathlib/RingTheory/FreeRing.lean
@[ext]
theorem hom_ext ⦃f g : FreeRing α →+* R⦄ (h : ∀ x, f (of x) = g (of x)) : f = g
-- Mathlib/Analysis/InnerProductSpace/l2Space.lean
protected theorem hasSum_repr_symm (b : HilbertBasis ι 𝕜 E) (f : ℓ²(ι, 𝕜)) :
    HasSum (fun i => f i • b i) (b.repr.symm f)
-- Mathlib/Topology/FiberBundle/Trivialization.lean
theorem coordChange_same (e : Trivialization F proj) {b : B} (h : b ∈ e.baseSet) :
    e.coordChange e b = id
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
@[simp] theorem countP_nil : countP p [] = 0
-- Mathlib/Order/Compare.lean
@[simp]
theorem cmpLE_ofDual [LE α] [@DecidableRel α (· ≤ ·)] (x y : αᵒᵈ) :
    cmpLE (ofDual x) (ofDual y) = cmpLE y x
-- Mathlib/Algebra/Lie/TraceForm.lean
lemma coe_killingCompl_top :
    killingCompl R L ⊤ = LinearMap.ker (killingForm R L)
-- Mathlib/Order/Monotone/Union.lean
/-- If `f` is monotone both on `(-∞, a]` and `[a, ∞)`, then it is monotone on the whole line. -/
protected theorem MonotoneOn.Iic_union_Ici (h₁ : MonotoneOn f (Iic a)) (h₂ : MonotoneOn f (Ici a)) :
    Monotone f
-- Mathlib/Analysis/Normed/Field/Basic.lean
@[simp]
theorem norm_div (a b : α) : ‖a / b‖ = ‖a‖ / ‖b‖
-- Mathlib/Algebra/MvPolynomial/Monad.lean
theorem eval₂Hom_bind₂ (f : S →+* T) (g : σ → T) (h : R →+* MvPolynomial σ S)
    (φ : MvPolynomial σ R) : eval₂Hom f g (bind₂ h φ) = eval₂Hom ((eval₂Hom f g).comp h) g φ
-- Mathlib/CategoryTheory/Limits/Shapes/Pullback/Mono.lean
@[simp]
theorem pullback_symmetry_hom_of_epi_eq [Epi f] : (pushoutSymmetry f f).hom = 𝟙 _
-- Mathlib/Algebra/Homology/TotalComplexShift.lean
@[reassoc]
lemma D₁_totalShift₁XIso_hom (n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + x = n₀') (h₁ : n₁ + x = n₁') :
    ((shiftFunctor₁ C x).obj K).D₁ (up ℤ) n₀ n₁ ≫ (K.totalShift₁XIso x n₁ n₁' h₁).hom =
      x.negOnePow • ((K.totalShift₁XIso x n₀ n₀' h₀).hom ≫ K.D₁ (up ℤ) n₀' n₁')
-- Mathlib/Analysis/Calculus/BumpFunction/Basic.lean
theorem one_lt_rOut_div_rIn {c : E} (f : ContDiffBump c) : 1 < f.rOut / f.rIn
-- Mathlib/Algebra/Homology/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma XIsoOfEq_hom_comp_d (K : HomologicalComplex V c) {p₁ p₂ : ι} (h : p₁ = p₂) (p₃ : ι) :
    (K.XIsoOfEq h).hom ≫ K.d p₂ p₃ = K.d p₁ p₃
-- Mathlib/Combinatorics/SimpleGraph/AdjMatrix.lean
/-- The adjacency matrix of `G` is an adjacency matrix. -/
@[simp]
theorem isAdjMatrix_adjMatrix [Zero α] [One α] : (G.adjMatrix α).IsAdjMatrix
-- Mathlib/Algebra/Homology/ComplexShapeSigns.lean
lemma σ_symm (i₁ : I₁) (i₂ : I₂) :
    σ c₂ c₁ c₁₂ i₂ i₁ = σ c₁ c₂ c₁₂ i₁ i₂
-- Mathlib/Data/Nat/Factorization/Defs.lean
/-- The only prime factor of prime `p` is `p` itself, with multiplicity `1` -/
@[simp]
protected theorem Prime.factorization {p : ℕ} (hp : Prime p) : p.factorization = single p 1
-- Mathlib/Analysis/BoxIntegral/Basic.lean
theorem norm_integral_le_of_le_const {c : ℝ}
    (hc : ∀ x ∈ Box.Icc I, ‖f x‖ ≤ c) (μ : Measure ℝⁿ) [IsLocallyFiniteMeasure μ] :
    ‖(integral I l f μ.toBoxAdditive.toSMul : E)‖ ≤ (μ I).toReal * c
-- Mathlib/Data/Real/Hyperreal.lean
@[norm_cast]
theorem coe_ne_one {x : ℝ} : (x : ℝ*) ≠ 1 ↔ x ≠ 1
-- Mathlib/Topology/PartialHomeomorph.lean
@[simp, mfld_simps]
theorem subtypeRestr_coe :
    ((e.subtypeRestr hs : PartialHomeomorph s Y) : s → Y) = Set.restrict ↑s (e : X → Y)
-- Mathlib/Geometry/Euclidean/MongePoint.lean
/-- An altitude is one-dimensional (i.e., a line). -/
@[simp]
theorem finrank_direction_altitude {n : ℕ} (s : Simplex ℝ P (n + 1)) (i : Fin (n + 2)) :
    finrank ℝ (s.altitude i).direction = 1
-- Mathlib/RingTheory/HahnSeries/Multiplication.lean
theorem ext_iff (x y : HahnModule Γ R V) :
    ((of R).symm x).coeff = ((of R).symm y).coeff ↔ x = y
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem and_right_comm : (a ∧ b) ∧ c ↔ (a ∧ c) ∧ b
-- Mathlib/Algebra/Order/Group/Unbundled/Basic.lean
@[to_additive]
theorem le_inv_iff_mul_le_one_left : a ≤ b⁻¹ ↔ b * a ≤ 1
-- Mathlib/Order/SuccPred/IntervalSucc.lean
/-- If `α` is a linear succ order, `β` is a preorder, and `f : α → β` is a monotone function, then
the intervals `Set.Ioo (f n) (f (Order.succ n))` are pairwise disjoint. -/
theorem pairwise_disjoint_on_Ioo_succ [SuccOrder α] [Preorder β] {f : α → β} (hf : Monotone f) :
    Pairwise (Disjoint on fun n => Ioo (f n) (f (succ n)))
-- Mathlib/Computability/Ackermann.lean
theorem ack_pair_lt (m n k : ℕ) : ack m (pair n k) < ack (m + 4) (max n k)
-- Mathlib/GroupTheory/Perm/Fin.lean
@[simp]
theorem cycleRange_zero (n : ℕ) : cycleRange (0 : Fin n.succ) = 1
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_linear (ha : a ≠ 0) : natDegree (C a * X + C b) = 1
-- Mathlib/LinearAlgebra/Prod.lean
@[simp]
theorem coprod_apply (f : M →ₗ[R] M₃) (g : M₂ →ₗ[R] M₃) (x : M × M₂) :
    coprod f g x = f x.1 + g x.2
-- Mathlib/Algebra/Order/Floor.lean
theorem ceil_eq_on_Ioc (z : ℤ) : ∀ a ∈ Set.Ioc (z - 1 : α) z, ⌈a⌉ = z
-- Mathlib/Data/PNat/Basic.lean
theorem le_sub_one_of_lt {a b : ℕ+} (hab : a < b) : a ≤ b - (1 : ℕ+)
-- Mathlib/Analysis/MellinTransform.lean
theorem mellin_const_smul (f : ℝ → E) (s : ℂ) {𝕜 : Type*} [NontriviallyNormedField 𝕜]
    [NormedSpace 𝕜 E] [SMulCommClass ℂ 𝕜 E] (c : 𝕜) :
    mellin (fun t => c • f t) s = c • mellin f s
-- Mathlib/Data/Set/Function.lean
theorem eqOn_piecewise {f f' g : α → β} {t} :
    EqOn (s.piecewise f f') g t ↔ EqOn f g (t ∩ s) ∧ EqOn f' g (t ∩ sᶜ)
-- Mathlib/RingTheory/UniqueFactorizationDomain.lean
theorem prod_le_prod_iff_le [Nontrivial α] {p q : Multiset (Associates α)}
    (hp : ∀ a ∈ p, Irreducible a) (hq : ∀ a ∈ q, Irreducible a) : p.prod ≤ q.prod ↔ p ≤ q
-- Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean
@[simp]
theorem involute_v (m : M) : involute (v Q m) = -v Q m
-- Mathlib/Order/Interval/Set/Image.lean
lemma StrictMonoOn.image_Ioc_subset (h : StrictMonoOn f (Icc a b)) :
    f '' Ioc a b ⊆ Ioc (f a) (f b)
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
protected nonrec theorem ContMDiffAt.coordChange
    (hf : ContMDiffAt IM IB n f x) (hg : ContMDiffAt IM 𝓘(𝕜, F) n g x) (he : f x ∈ e.baseSet)
    (he' : f x ∈ e'.baseSet) :
    ContMDiffAt IM 𝓘(𝕜, F) n (fun y ↦ e.coordChange e' (f y) (g y)) x
-- Mathlib/Data/Nat/Defs.lean
protected lemma sub_add_sub_cancel (hab : b ≤ a) (hcb : c ≤ b) : a - b + (b - c) = a - c
-- Mathlib/LinearAlgebra/Determinant.lean
/-- If a basis is multiplied columnwise by scalars `w : ι → Rˣ`, then the determinant with respect
to this basis is multiplied by the product of the inverse of these scalars. -/
theorem Basis.det_unitsSMul (e : Basis ι R M) (w : ι → Rˣ) :
    (e.unitsSMul w).det = (↑(∏ i, w i)⁻¹ : R) • e.det
-- Mathlib/SetTheory/Game/PGame.lean
theorem lf_moveRight_of_le {x y : PGame} (h : x ≤ y) (j) : x ⧏ y.moveRight j
-- Mathlib/Topology/Instances/NNReal.lean
/-- A monotone, bounded above sequence `f : ℕ → ℝ` has a finite limit. -/
theorem _root_.Real.tendsto_of_bddAbove_monotone {f : ℕ → ℝ} (h_bdd : BddAbove (Set.range f))
    (h_mon : Monotone f) : ∃ r : ℝ, Tendsto f atTop (𝓝 r)
-- Mathlib/NumberTheory/LSeries/Dirichlet.lean
/-- The L-series of the arithmetic function `ζ` equals the Riemann Zeta Function on its
domain of convergence `1 < re s`. -/
lemma LSeriesHasSum_zeta {s : ℂ} (hs : 1 < s.re) : LSeriesHasSum ↗ζ s (riemannZeta s)
-- Mathlib/Analysis/Calculus/DiffContOnCl.lean
theorem Differentiable.diffContOnCl (h : Differentiable 𝕜 f) : DiffContOnCl 𝕜 f s
-- Mathlib/Order/Filter/Basic.lean
@[simp] theorem comap_top : comap m ⊤ = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem mul_lt_mul' {a b c d : Int}
    (h₁ : a ≤ c) (h₂ : b < d) (h₃ : 0 ≤ b) (h₄ : 0 < c) : a * b < c * d
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem le_neg_add_of_add_le {a b c : Int} (h : a + b ≤ c) : b ≤ -a + c
-- Mathlib/Algebra/Module/LocalizedModule.lean
private theorem add_assoc' (x y z : LocalizedModule S M) : x + y + z = x + (y + z)
-- Mathlib/Computability/Ackermann.lean
theorem add_lt_ack : ∀ m n, m + n < ack m n
-- Mathlib/Data/PFunctor/Univariate/M.lean
theorem bisim (R : M P → M P → Prop)
    (h : ∀ x y, R x y → ∃ a f f', M.dest x = ⟨a, f⟩ ∧ M.dest y = ⟨a, f'⟩ ∧ ∀ i, R (f i) (f' i)) :
    ∀ x y, R x y → x = y
-- Mathlib/Data/List/Basic.lean
theorem mem_takeWhile_imp {x : α} (hx : x ∈ takeWhile p l) : p x
-- Mathlib/Data/Nat/Nth.lean
/-- When `s` is an infinite set, `nth` agrees with `Nat.Subtype.orderIsoOfNat`. -/
theorem nth_eq_orderIsoOfNat (hf : (setOf p).Infinite) :
    nth p = (↑) ∘ @Nat.Subtype.orderIsoOfNat (setOf p) hf.to_subtype
-- Mathlib/RingTheory/FiniteType.lean
theorem of_restrictScalars_finiteType [Algebra S A] [IsScalarTower R S A] [hA : FiniteType R A] :
    FiniteType S A
-- Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean
lemma F_nat_one_le {a : ℝ} (ha : 0 ≤ a) {t : ℝ} (ht : 0 < t) :
    ‖F_nat 1 a t‖ ≤ rexp (-π * (a ^ 2 + 1) * t) / (1 - rexp (-π * t)) ^ 2
      + a * rexp (-π * a ^ 2 * t) / (1 - rexp (-π * t))
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Lemmas.lean
@[simp]
theorem getLsb_twoPow (i j : Nat) : (twoPow w i).getLsb j = ((i < w) && (i = j))
-- Mathlib/GroupTheory/Archimedean.lean
/-- Every subgroup of `ℤ` is cyclic. -/
theorem Int.subgroup_cyclic (H : AddSubgroup ℤ) : ∃ a, H = AddSubgroup.closure {a}
-- Mathlib/Algebra/Lie/Subalgebra.lean
protected theorem add_mem {x y : L} : x ∈ L' → y ∈ L' → (x + y : L) ∈ L'
-- Mathlib/Algebra/Module/FinitePresentation.lean
lemma Module.finitePresentation_of_finite [IsNoetherianRing R] [h : Module.Finite R M] :
    Module.FinitePresentation R M
-- Mathlib/Algebra/Group/Units.lean
@[simp]
theorem mul_divp_cancel (a : α) (u : αˣ) : a * u /ₚ u = a
-- Mathlib/CategoryTheory/Generator.lean
theorem isCoseparator_op_iff (G : C) : IsCoseparator (op G) ↔ IsSeparator G
-- Mathlib/Algebra/Quaternion.lean
@[simp] nonrec theorem add_im : (a + b).im = a.im + b.im
-- Mathlib/Algebra/NeZero.lean
theorem NeZero.ne' (n : R) [h : NeZero n] : 0 ≠ n
-- Mathlib/MeasureTheory/Function/StronglyMeasurable/Inner.lean
protected theorem re {f : α → 𝕜} (hf : AEStronglyMeasurable f μ) :
    AEStronglyMeasurable (fun x => RCLike.re (f x)) μ
-- Mathlib/Combinatorics/SimpleGraph/Hasse.lean
theorem pathGraph_connected (n : ℕ) : (pathGraph (n + 1)).Connected
-- Mathlib/Algebra/GCDMonoid/Basic.lean
@[simp]
theorem gcd_zero_right [NormalizedGCDMonoid α] (a : α) : gcd a 0 = normalize a
-- Mathlib/Topology/Category/Stonean/Basic.lean
@[simp, reassoc]
lemma lift_lifts {X Y : CompHaus} {Z : Stonean} (e : Z.compHaus ⟶ Y) (f : X ⟶ Y) [Epi f] :
    lift e f ≫ f = e
-- Mathlib/MeasureTheory/Constructions/Prod/Basic.lean
/-- If `C` and `D` generate the σ-algebras on `α` resp. `β`, then rectangles formed by `C` and `D`
  generate the σ-algebra on `α × β`. -/
theorem generateFrom_eq_prod {C : Set (Set α)} {D : Set (Set β)} (hC : generateFrom C = ‹_›)
    (hD : generateFrom D = ‹_›) (h2C : IsCountablySpanning C) (h2D : IsCountablySpanning D) :
    generateFrom (image2 (· ×ˢ ·) C D) = Prod.instMeasurableSpace
-- Mathlib/Algebra/MvPolynomial/Basic.lean
@[ext 1200]
theorem algHom_ext {A : Type*} [Semiring A] [Algebra R A] {f g : MvPolynomial σ R →ₐ[R] A}
    (hf : ∀ i : σ, f (X i) = g (X i)) : f = g
-- Mathlib/Algebra/Polynomial/RingDivision.lean
@[simp]
theorem degree_coe_units [Nontrivial R] (u : R[X]ˣ) : degree (u : R[X]) = 0
-- Mathlib/Topology/Category/Compactum.lean
theorem cl_eq_closure {X : Compactum} (A : Set X) : cl A = closure A
-- Mathlib/Topology/Instances/AddCircle.lean
/-- The image of the closed interval `[0, p]` under the quotient map `𝕜 → AddCircle p` is the
entire space. -/
@[simp]
theorem coe_image_Icc_eq : ((↑) : 𝕜 → AddCircle p) '' Icc a (a + p) = univ
-- Mathlib/RingTheory/PowerBasis.lean
theorem algHom_ext {S' : Type*} [Semiring S'] [Algebra R S'] (pb : PowerBasis R S)
    ⦃f g : S →ₐ[R] S'⦄ (h : f pb.gen = g pb.gen) : f = g
-- Mathlib/GroupTheory/GroupAction/Hom.lean
@[simp]
theorem comp_apply (g : S →ₑ+*[ψ] T) (f : R →ₑ+*[φ] S) [MonoidHom.CompTriple φ ψ χ] (x : R) :
    g.comp f x = g (f x)
-- Mathlib/Data/Set/Functor.lean
/-- `Set.image2` in terms of monadic operations. Note that this can't be taken as the definition
because of the lack of universe polymorphism. -/
theorem image2_def {α β γ : Type u} (f : α → β → γ) (s : Set α) (t : Set β) :
    image2 f s t = f <$> s <*> t
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
@[simp]
theorem degree_monomial (n : ℕ) (ha : a ≠ 0) : degree (monomial n a) = n
-- Mathlib/Data/Finset/Basic.lean
theorem mem_cons_of_mem {a b : α} {s : Finset α} {hb : b ∉ s} (ha : a ∈ s) : a ∈ cons b s hb
-- Mathlib/MeasureTheory/PiSystem.lean
theorem isPiSystem_generatePiSystem {α} (S : Set (Set α)) : IsPiSystem (generatePiSystem S)
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- If the liminf and the limsup of a function coincide, then the limit of the function
exists and has the same value. -/
theorem tendsto_of_liminf_eq_limsup {f : Filter β} {u : β → α} {a : α} (hinf : liminf u f = a)
    (hsup : limsup u f = a) (h : f.IsBoundedUnder (· ≤ ·) u := by isBoundedDefault)
    (h' : f.IsBoundedUnder (· ≥ ·) u := by isBoundedDefault) : Tendsto u f (𝓝 a)
-- Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean
lemma eLpNorm_nnreal_eq_lintegral {f : α → F} {p : ℝ≥0} (hp : p ≠ 0) :
    eLpNorm f p μ = (∫⁻ x, ‖f x‖₊ ^ (p : ℝ) ∂μ) ^ (1 / (p : ℝ))
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_mk' (e : P₁ → P₂) (e' : V₁ ≃ₗᵢ[𝕜] V₂) (p h) : ⇑(mk' e e' p h) = e
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Defs.lean
@[simp]
theorem GLPos.coe_neg_apply (g : GLPos n R) (i j : n) :
    ((↑(-g) : GL n R) : Matrix n n R) i j = -((g : GL n R) : Matrix n n R) i j
-- Mathlib/Data/Finsupp/Defs.lean
theorem range_single_subset : Set.range (single a b) ⊆ {0, b}
-- .lake/packages/batteries/Batteries/Data/List/Lemmas.lean
theorem nil_suffix (l : List α) : [] <:+ l
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem eval₂_sum (s : Finset S₂) (p : S₂ → MvPolynomial σ R) :
    eval₂ f g (∑ x ∈ s, p x) = ∑ x ∈ s, eval₂ f g (p x)
-- Mathlib/Data/Finset/Union.lean
lemma subset_biUnion_of_mem (u : α → Finset β) {x : α} (xs : x ∈ s) : u x ⊆ s.biUnion u
-- Mathlib/Geometry/Manifold/VectorBundle/Basic.lean
theorem smoothOn_coordChange (IB : ModelWithCorners 𝕜 EB HB) [h : Z.IsSmooth IB] (i j : ι) :
    SmoothOn IB 𝓘(𝕜, F →L[𝕜] F) (Z.coordChange i j) (Z.baseSet i ∩ Z.baseSet j)
-- Mathlib/Order/LiminfLimsup.lean
theorem IsBoundedUnder.isCoboundedUnder_flip {u : γ → α} {l : Filter γ} [IsTrans α r] [NeBot l]
    (h : l.IsBoundedUnder r u) : l.IsCoboundedUnder (flip r) u
-- Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean
lemma rpow_inv_natCast_pow {n : ℕ} (hn : n ≠ 0) (x : ℝ≥0∞) : (x ^ (n⁻¹ : ℝ)) ^ n = x
-- Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean
/-- The Haar measure equals the Lebesgue measure on `ℝ`. -/
theorem addHaarMeasure_eq_volume : addHaarMeasure Icc01 = volume
-- Mathlib/Topology/PartialHomeomorph.lean
/-- If two partial homeomorphisms are equivalent, so are their inverses. -/
theorem EqOnSource.symm' {e e' : PartialHomeomorph X Y} (h : e ≈ e') : e.symm ≈ e'.symm
-- Mathlib/MeasureTheory/MeasurableSpace/Basic.lean
@[simp]
theorem map_id : m.map id = m
-- Mathlib/Topology/Basic.lean
theorem interior_eq_nhds : interior s = { x | 𝓝 x ≤ 𝓟 s }
-- Mathlib/MeasureTheory/OuterMeasure/Induced.lean
theorem extend_eq {s : α} (h : P s) : extend m s = m s h
-- Mathlib/Analysis/RCLike/Basic.lean
@[simp, rclike_simps]
theorem inv_re (z : K) : re z⁻¹ = re z / normSq z
-- Mathlib/Data/Complex/Basic.lean
theorem im_surjective : Surjective im
-- .lake/packages/batteries/Batteries/Data/List/Count.lean
theorem countP_congr (h : ∀ x ∈ l, p x ↔ q x) : countP p l = countP q l
-- Mathlib/RingTheory/FiniteType.lean
/-- A commutative algebra is finitely generated if and only if it is a quotient of a polynomial ring
in `n` variables. -/
theorem iff_quotient_mvPolynomial'' :
    FiniteType R S ↔ ∃ (n : ℕ) (f : MvPolynomial (Fin n) R →ₐ[R] S), Surjective f
-- Mathlib/Algebra/Order/Hom/Ring.lean
theorem symm_bijective : Bijective (OrderRingIso.symm : (α ≃+*o β) → β ≃+*o α)
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem orthogonalBilin_le (h : N ≤ L) : L.orthogonalBilin B ≤ N.orthogonalBilin B
-- Mathlib/Order/Interval/Finset/Basic.lean
theorem uIcc_subset_uIcc_left (h : x ∈ [[a, b]]) : [[a, x]] ⊆ [[a, b]]
-- Mathlib/Data/Nat/Digits.lean
theorem digits_ofDigits (b : ℕ) (h : 1 < b) (L : List ℕ) (w₁ : ∀ l ∈ L, l < b)
    (w₂ : ∀ h : L ≠ [], L.getLast h ≠ 0) : digits b (ofDigits b L) = L
-- Mathlib/Analysis/InnerProductSpace/Calculus.lean
theorem contDiffAt_inner {p : E × E} {n} : ContDiffAt ℝ n (fun p : E × E => ⟪p.1, p.2⟫) p
-- Mathlib/Probability/IdentDistrib.lean
/-- If `X` and `Y` are independent and `(X, Y)` and `(X', Y')` are identically distributed,
then `X'` and `Y'` are independent. -/
lemma indepFun_of_identDistrib_pair
    {μ : Measure γ} {μ' : Measure δ} [IsFiniteMeasure μ] [IsFiniteMeasure μ']
    {X : γ → α} {X' : δ → α} {Y : γ → β} {Y' : δ → β} (h_indep : IndepFun X Y μ)
    (h_ident : IdentDistrib (fun ω ↦ (X ω, Y ω)) (fun ω ↦ (X' ω, Y' ω)) μ μ') :
    IndepFun X' Y' μ'
-- .lake/packages/lean4/src/lean/Init/Core.lean
theorem Eq.comm {a b : α} : a = b ↔ b = a
-- Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean
/-- Variant of Hahn-Banach, eliminating the hypothesis that `x` be nonzero, but only ensuring that
    the dual element has norm at most `1` (this can not be improved for the trivial
    vector space). -/
theorem exists_dual_vector'' (x : E) : ∃ g : E →L[𝕜] 𝕜, ‖g‖ ≤ 1 ∧ g x = ‖x‖
-- Mathlib/RingTheory/Polynomial/Pochhammer.lean
theorem ascPochhammer_mul (n m : ℕ) :
    ascPochhammer S n * (ascPochhammer S m).comp (X + (n : S[X])) = ascPochhammer S (n + m)
-- Mathlib/CategoryTheory/Sites/OneHypercover.lean
/-- Given an object `W` equipped with morphisms `p₁ : W ⟶ E.X i₁`, `p₂ : W ⟶ E.X i₂`,
this is the sieve of `W` which consists of morphisms `g : Z ⟶ W` such that there exists `j`
and `h : Z ⟶ E.Y j` such that `g ≫ p₁ = h ≫ E.p₁ j` and `g ≫ p₂ = h ≫ E.p₂ j`.
See lemmas `sieve₁_eq_pullback_sieve₁'` and `sieve₁'_eq_sieve₁` for equational lemmas
regarding this sieve. -/
@[simps]
def sieve₁ {i₁ i₂ : E.I₀} {W : C} (p₁ : W ⟶ E.X i₁) (p₂ : W ⟶ E.X i₂) : Sieve W
-- Mathlib/Analysis/InnerProductSpace/TwoDim.lean
theorem norm_kahler (x y : E) : ‖o.kahler x y‖ = ‖x‖ * ‖y‖
-- Mathlib/Order/SymmDiff.lean
theorem symmDiff_left_involutive (a : α) : Involutive (· ∆ a)
-- Mathlib/ModelTheory/Substructures.lean
@[simp]
theorem range_id : range (id L M) = ⊤
-- Mathlib/LinearAlgebra/UnitaryGroup.lean
theorem mem_orthogonalGroup_iff' {A : Matrix n n β} :
    A ∈ Matrix.orthogonalGroup n β ↔ star A * A = 1
-- Mathlib/Data/Real/Irrational.lean
@[simp]
theorem irrational_add_int_iff : Irrational (x + m) ↔ Irrational x
-- Mathlib/Data/Seq/Computation.lean
theorem liftRel_def {R : α → β → Prop} {ca cb} :
    LiftRel R ca cb ↔ (Terminates ca ↔ Terminates cb) ∧ ∀ {a b}, a ∈ ca → b ∈ cb → R a b