ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/RingTheory/FractionalIdeal/Operations.lean
theorem _root_.IsFractional.map (g : P →ₐ[R] P') {I : Submodule R P} :
    IsFractional S I → IsFractional S (Submodule.map g.toLinearMap I)
-- Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean
@[simp]
theorem cpow_one (x : ℂ) : x ^ (1 : ℂ) = x
-- Mathlib/Algebra/Algebra/Tower.lean
theorem span_algebraMap_image_of_tower {S T : Type*} [CommSemiring S] [Semiring T] [Module R S]
    [Algebra R T] [Algebra S T] [IsScalarTower R S T] (a : Set S) :
    Submodule.span R (algebraMap S T '' a) =
      (Submodule.span R a).map ((Algebra.linearMap S T).restrictScalars R)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
@[simp]
theorem contDiffOn_zero : ContDiffOn 𝕜 0 f s ↔ ContinuousOn f s
-- Mathlib/SetTheory/Cardinal/Basic.lean
@[simp]
theorem lift_aleph0 : lift ℵ₀ = ℵ₀
-- Mathlib/Topology/Bornology/Absorbs.lean
@[simp]
lemma _root_.absorbs_union : Absorbs M s (t₁ ∪ t₂) ↔ Absorbs M s t₁ ∧ Absorbs M s t₂
-- Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean
theorem commute_add_int : ∀ n : ℤ, Function.Commute f (· + n)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem degree_sub_le_of_le {a b : WithBot ℕ} (hp : degree p ≤ a) (hq : degree q ≤ b) :
    degree (p - q) ≤ max a b
-- Mathlib/Probability/Martingale/Basic.lean
/-- A predictable supermartingale is a.e. less equal than its initial state. -/
theorem Supermartingale.le_zero_of_predictable [Preorder E] [SigmaFiniteFiltration μ 𝒢]
    {f : ℕ → Ω → E} (hfmgle : Supermartingale f 𝒢 μ) (hfadp : Adapted 𝒢 fun n => f (n + 1))
    (n : ℕ) : f n ≤ᵐ[μ] f 0
-- Mathlib/LinearAlgebra/Matrix/GeneralLinearGroup/Defs.lean
@[simp]
theorem coe_to_GLPos_to_GL_det (g : SpecialLinearGroup n R) :
    Matrix.GeneralLinearGroup.det ((g : GLPos n R) : GL n R) = 1
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem find?_map (f : β → α) (l : List β) : find? p (l.map f) = (l.find? (p ∘ f)).map f
-- Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean
lemma preΨ'_ne_zero [Nontrivial R] {n : ℕ} (h : (n : R) ≠ 0) : W.preΨ' n ≠ 0
-- Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean
theorem midpoint_eq_iff' {x y z : P} : midpoint R x y = z ↔ Equiv.pointReflection z x = y
-- Mathlib/Algebra/Order/Monovary.lean
lemma monovaryOn_iff_forall_mul_nonneg :
    MonovaryOn f g s ↔ ∀ ⦃i⦄, i ∈ s → ∀ ⦃j⦄, j ∈ s → 0 ≤ (f j - f i) * (g j - g i)
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem mapM_cons [Monad m] [LawfulMonad m] (f : α → m β) :
    (a :: l).mapM f = (return (← f a) :: (← l.mapM f))
-- Mathlib/Combinatorics/SimpleGraph/Connectivity/WalkCounting.lean
theorem reachable_iff_exists_finsetWalkLength_nonempty (u v : V) :
    G.Reachable u v ↔ ∃ n : Fin (Fintype.card V), (G.finsetWalkLength n u v).Nonempty
-- Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean
/-- The differential on the complex of morphisms between cochain complexes, as a linear map. -/
@[simps!]
def δ_hom : Cochain F G n →ₗ[R] Cochain F G m
-- Mathlib/Algebra/Star/Pi.lean
theorem star_def [∀ i, Star (f i)] (x : ∀ i, f i) : star x = fun i => star (x i)
-- Mathlib/Analysis/NormedSpace/Exponential.lean
theorem expSeries_apply_eq (x : 𝔸) (n : ℕ) :
    (expSeries 𝕂 𝔸 n fun _ => x) = (n !⁻¹ : 𝕂) • x ^ n
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Cauchy–Schwarz inequality with norm -/
theorem norm_inner_le_norm (x y : F) : ‖⟪x, y⟫‖ ≤ ‖x‖ * ‖y‖
-- Mathlib/Algebra/Homology/Homotopy.lean
/-- A homotopy `h` between chain maps `f` and `g` consists of components `h i j : C.X i ⟶ D.X j`
which are zero unless `c.Rel j i`, satisfying the homotopy condition.
-/
@[ext]
structure Homotopy (f g : C ⟶ D) where
  hom : ∀ i j, C.X i ⟶ D.X j
  zero : ∀ i j, ¬c.Rel j i → hom i j = 0 := by aesop_cat
  comm : ∀ i, f.f i = dNext i hom + prevD i hom + g.f i := by aesop_cat
-- Mathlib/Data/Sym/Basic.lean
@[simp]
theorem cons_erase [DecidableEq α] {s : Sym α n.succ} {a : α} (h : a ∈ s) : a ::ₛ s.erase a h = s
-- Mathlib/Data/Fintype/BigOperators.lean
@[to_additive]
theorem prod_congr (f g : α → M) (h : ∀ a, f a = g a) : ∏ a, f a = ∏ a, g a
-- Mathlib/Order/Monotone/Monovary.lean
theorem antivaryOn_comm : AntivaryOn f g s ↔ AntivaryOn g f s
-- Mathlib/Data/Nat/Bits.lean
@[simp] lemma shiftRight_eq (m n : Nat) : shiftRight m n = m >>> n
-- .lake/packages/lean4/src/lean/Init/Data/Array/Lemmas.lean
@[simp] theorem filterMap_data (f : α → Option β) (l : Array α) :
    (l.filterMap f).data = l.data.filterMap f
-- Mathlib/Data/Bool/Basic.lean
@[simp]
theorem false_lt_true : false < true
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem add_le_add_three {a b c d e f : Int}
    (h₁ : a ≤ d) (h₂ : b ≤ e) (h₃ : c ≤ f) : a + b + c ≤ d + e + f
-- .lake/packages/lean4/src/lean/Init/Data/BitVec/Bitblast.lean
theorem bit_neg_eq_neg (x : BitVec w) : -x = (adc (((iunfoldr (fun (i : Fin w) c => (c, !(x.getLsb i)))) ()).snd) (BitVec.ofNat w 1) false).snd
-- Mathlib/Algebra/Lie/Solvable.lean
theorem abelian_derivedAbelianOfIdeal (I : LieIdeal R L) :
    IsLieAbelian (derivedAbelianOfIdeal I)
-- Mathlib/LinearAlgebra/SesquilinearForm.lean
theorem isAdjointPair_id : IsAdjointPair B B 1 1
-- Mathlib/Algebra/Homology/HomotopyCofiber.lean
lemma shape (i j : ι) (hij : ¬ c.Rel i j) :
    d φ i j = 0
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `r` is a negative constant, `fun x ↦ f x * r` tends to infinity along a filter `l`
if and only if `f` tends to negative infinity along `l`. -/
theorem tendsto_mul_const_atTop_of_neg (hr : r < 0) :
    Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atBot
-- Mathlib/Topology/PartialHomeomorph.lean
theorem symm_trans_self : e.symm.trans e ≈ PartialHomeomorph.ofSet e.target e.open_target
-- Mathlib/Data/PNat/Prime.lean
theorem Prime.one_lt {p : ℕ+} : p.Prime → 1 < p
-- Mathlib/Data/Nat/Defs.lean
lemma strongRecOn'_beta {P : ℕ → Sort*} {h} :
    (strongRecOn' n h : P n) = h n fun m _ ↦ (strongRecOn' m h : P m)
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/StructureSheaf.lean
theorem neg_mem' (U : (Opens (ProjectiveSpectrum.top 𝒜))ᵒᵖ) (a : ∀ x : U.unop, at x.1)
    (ha : (isLocallyFraction 𝒜).pred a) : (isLocallyFraction 𝒜).pred (-a)
-- Mathlib/LinearAlgebra/PiTensorProduct.lean
@[simp]
theorem lift_symm (φ' : (⨂[R] i, s i) →ₗ[R] E) : lift.symm φ' = φ'.compMultilinearMap (tprod R)
-- Mathlib/RingTheory/Localization/Basic.lean
/-- A `CommRing` `S` which is the localization of an integral domain `R` at a subset of
non-zero elements is an integral domain. -/
theorem isDomain_of_le_nonZeroDivisors [Algebra A S] {M : Submonoid A} [IsLocalization M S]
    (hM : M ≤ nonZeroDivisors A) : IsDomain S
-- Mathlib/Algebra/Polynomial/Degree/Lemmas.lean
theorem degree_pos_of_eval₂_root {p : R[X]} (hp : p ≠ 0) (f : R →+* S) {z : S}
    (hz : eval₂ f z p = 0) (inj : ∀ x : R, f x = 0 → x = 0) : 0 < degree p
-- Mathlib/Analysis/InnerProductSpace/Projection.lean
/-- Given a monotone family `U` of complete submodules of `E` with dense span supremum,
and a fixed `x : E`, the orthogonal projection of `x` on `U i` tends to `x` along `at_top`. -/
theorem orthogonalProjection_tendsto_self [CompleteSpace E] {ι : Type*} [SemilatticeSup ι]
    (U : ι → Submodule 𝕜 E) [∀ t, CompleteSpace (U t)] (hU : Monotone U) (x : E)
    (hU' : ⊤ ≤ (⨆ t, U t).topologicalClosure) :
    Filter.Tendsto (fun t => (orthogonalProjection (U t) x : E)) atTop (𝓝 x)
-- Mathlib/Algebra/Lie/Basic.lean
@[simp]
theorem coe_to_linearEquiv (e : L₁ ≃ₗ⁅R⁆ L₂) : ⇑(e : L₁ ≃ₗ[R] L₂) = e
-- Mathlib/LinearAlgebra/Ray.lean
/-- Two vectors are in the same ray, or the first is in the same ray as the negation of the
second, if and only if they are not linearly independent. -/
theorem sameRay_or_sameRay_neg_iff_not_linearIndependent {x y : M} :
    SameRay R x y ∨ SameRay R x (-y) ↔ ¬LinearIndependent R ![x, y]
-- Mathlib/Data/Nat/Defs.lean
lemma and_forall_succ : p 0 ∧ (∀ n, p (n + 1)) ↔ ∀ n, p n
-- Mathlib/NumberTheory/MulChar/Basic.lean
protected theorem map_one (χ : MulChar R R') : χ (1 : R) = 1
-- Mathlib/Algebra/Ring/Semiconj.lean
theorem neg_left (h : SemiconjBy a x y) : SemiconjBy (-a) x y
-- Mathlib/MeasureTheory/Measure/LevyProkhorovMetric.lean
lemma left_measure_le_of_levyProkhorovEDist_lt {μ ν : Measure Ω} {c : ℝ≥0∞}
    (h : levyProkhorovEDist μ ν < c) {B : Set Ω} (B_mble : MeasurableSet B) :
    μ B ≤ ν (thickening c.toReal B) + c
-- Mathlib/RingTheory/WittVector/Basic.lean
theorem map_surjective (f : R →+* S) (hf : Surjective f) : Surjective (map f : 𝕎 R → 𝕎 S)
-- Mathlib/CategoryTheory/Preadditive/Biproducts.lean
@[reassoc]
theorem biproduct.lift_desc {T U : C} {g : ∀ j, T ⟶ f j} {h : ∀ j, f j ⟶ U} :
    biproduct.lift g ≫ biproduct.desc h = ∑ j : J, g j ≫ h j
-- Mathlib/Combinatorics/SetFamily/Compression/Down.lean
theorem mem_compression_of_insert_mem_compression (h : insert a s ∈ 𝓓 a 𝒜) : s ∈ 𝓓 a 𝒜
-- Mathlib/Topology/MetricSpace/Pseudo/Defs.lean
@[simp]
theorem sphere_eq_empty_of_neg (hε : ε < 0) : sphere x ε = ∅
-- Mathlib/RingTheory/IntegralClosure/IntegrallyClosed.lean
theorem exists_algebraMap_eq_of_pow_mem_subalgebra {K : Type*} [CommRing K] [Algebra R K]
    {S : Subalgebra R K} [IsIntegrallyClosed S] [IsFractionRing S K] {x : K} {n : ℕ} (hn : 0 < n)
    (hx : x ^ n ∈ S) : ∃ y : S, algebraMap S K y = x
-- Mathlib/Topology/PartialHomeomorph.lean
theorem openEmbedding_restrict : OpenEmbedding (e.source.restrict e)
-- Mathlib/Algebra/Group/AddChar.lean
@[simp, norm_cast] lemma mul_apply (ψ φ : AddChar A M) (a : A) : (ψ * φ) a = ψ a * φ a
-- Mathlib/Data/Finset/Lattice.lean
/-- To rewrite from right to left, use `Monotone.map_finset_max'`. -/
@[simp]
theorem max'_image [LinearOrder β] {f : α → β} (hf : Monotone f) (s : Finset α)
    (h : (s.image f).Nonempty) : (s.image f).max' h = f (s.max' h.of_image)
-- Mathlib/Analysis/NormedSpace/AffineIsometry.lean
@[simp]
theorem coe_inv (e : P ≃ᵃⁱ[𝕜] P) : ⇑e⁻¹ = e.symm
-- Mathlib/Analysis/Fourier/FourierTransformDeriv.lean
lemma _root_.ContDiff.fourierPowSMulRight {f : V → E} {k : ℕ∞} (hf : ContDiff ℝ k f) (n : ℕ) :
    ContDiff ℝ k (fun v ↦ fourierPowSMulRight L f v n)
-- Mathlib/Algebra/TrivSqZeroExt.lean
@[ext]
theorem algHom_ext' {A} [Semiring A] [Algebra S A] ⦃f g : tsze R M →ₐ[S] A⦄
    (hinl : f.comp (inlAlgHom S R M) = g.comp (inlAlgHom S R M))
    (hinr : f.toLinearMap.comp (inrHom R M |>.restrictScalars S) =
      g.toLinearMap.comp (inrHom R M |>.restrictScalars S)) : f = g
-- Mathlib/Geometry/RingedSpace/LocallyRingedSpace/ResidueField.lean
@[simp]
lemma residueFieldMap_id (x : X) :
    residueFieldMap (𝟙 X) x = 𝟙 (X.residueField x)
-- Mathlib/Algebra/Ring/Subring/MulOpposite.lean
/-- Pull an opposite subring back to a subring along `MulOpposite.op` -/
@[simps toSubsemiring]
protected def unop (S : Subring Rᵐᵒᵖ) : Subring R
-- Mathlib/Analysis/Asymptotics/Asymptotics.lean
theorem IsBigOWith.trans_le (hfg : IsBigOWith c l f g) (hgk : ∀ x, ‖g x‖ ≤ ‖k x‖) (hc : 0 ≤ c) :
    IsBigOWith c l f k
-- Mathlib/FieldTheory/KummerExtension.lean
lemma autEquivZmod_symm_apply_natCast {ζ : K} (hζ : IsPrimitiveRoot ζ n) (m : ℕ) :
    (autEquivZmod H L hζ).symm (Multiplicative.ofAdd (m : ZMod n)) α = ζ ^ m • α
-- Mathlib/RingTheory/Ideal/Cotangent.lean
theorem toCotangent_eq_zero (x : I) : I.toCotangent x = 0 ↔ (x : R) ∈ I ^ 2
-- Mathlib/CategoryTheory/MorphismProperty/Basic.lean
theorem epimorphisms.infer_property [hf : Epi f] : (epimorphisms C) f
-- Mathlib/SetTheory/Ordinal/NaturalOps.lean
theorem lt_nmul_iff : c < a ⨳ b ↔ ∃ a' < a, ∃ b' < b, c ♯ a' ⨳ b' ≤ a' ⨳ b ♯ a ⨳ b'
-- Mathlib/Data/Set/Subsingleton.lean
theorem nontrivial_of_exists_lt [Preorder α]
    (H : ∃ᵉ (x ∈ s) (y ∈ s), x < y) : s.Nontrivial
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_coe_sign (x : SignType) : ((x : ℝ) : EReal) = x
-- Mathlib/Data/Set/Basic.lean
protected theorem ssubset_iff_subset_ne {s t : Set α} : s ⊂ t ↔ s ⊆ t ∧ s ≠ t
-- .lake/packages/lean4/src/lean/Init/PropLemmas.lean
theorem Decidable.not_and_iff_or_not_not [Decidable a] : ¬(a ∧ b) ↔ ¬a ∨ ¬b
-- Mathlib/Data/Countable/Defs.lean
lemma not_countable_iff : ¬Countable α ↔ Uncountable α
-- Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean
theorem const_smul {f : X → Y} (hf : Conformal f) {c : ℝ} (hc : c ≠ 0) : Conformal (c • f)
-- Mathlib/CategoryTheory/Preadditive/FunctorCategory.lean
@[simp]
theorem app_neg (X : C) (α : F ⟶ G) : (-α).app X = -α.app X
-- Mathlib/Data/List/Sort.lean
theorem length_split_le :
    ∀ {l l₁ l₂ : List α}, split l = (l₁, l₂) → length l₁ ≤ length l ∧ length l₂ ≤ length l
-- Mathlib/CategoryTheory/Linear/Yoneda.lean
@[simp]
theorem whiskering_linearCoyoneda :
    linearCoyoneda R C ⋙ (whiskeringRight _ _ _).obj (forget (ModuleCat.{v} R)) = coyoneda
-- Mathlib/Data/List/Nodup.lean
@[simp]
theorem nodup_nil : @Nodup α []
-- Mathlib/Order/Interval/Set/Image.lean
private lemma image_subtype_val_Ixx_Ixi {p q r : α → α → Prop} {a b : α} (c : {x // p a x ∧ q x b})
    (h : ∀ {x}, r c x → p a x) :
    Subtype.val '' {y : {x // p a x ∧ q x b} | r c.1 y.1} = {y : α | r c.1 y ∧ q y b}
-- Mathlib/Probability/Variance.lean
theorem variance_smul (c : ℝ) (X : Ω → ℝ) (μ : Measure Ω) :
    variance (c • X) μ = c ^ 2 * variance X μ
-- Mathlib/RingTheory/MvPolynomial/Homogeneous.lean
theorem add (hφ : IsHomogeneous φ n) (hψ : IsHomogeneous ψ n) : IsHomogeneous (φ + ψ) n
-- Mathlib/Computability/TMToPartrec.lean
theorem exists_code.comp {m n} {f : Vector ℕ n →. ℕ} {g : Fin n → Vector ℕ m →. ℕ}
    (hf : ∃ c : Code, ∀ v : Vector ℕ n, c.eval v.1 = pure <$> f v)
    (hg : ∀ i, ∃ c : Code, ∀ v : Vector ℕ m, c.eval v.1 = pure <$> g i v) :
    ∃ c : Code, ∀ v : Vector ℕ m, c.eval v.1 = pure <$> ((Vector.mOfFn fun i => g i v) >>= f)
-- Mathlib/CategoryTheory/DiscreteCategory.lean
@[simp]
theorem natIso_app {I : Type u₁} {F G : Discrete I ⥤ C} (f : ∀ i : Discrete I, F.obj i ≅ G.obj i)
    (i : Discrete I) : (Discrete.natIso f).app i = f i
-- Mathlib/Deprecated/Subgroup.lean
/-- The normal closure of s is the smallest normal subgroup containing s. -/
theorem normalClosure_subset {s t : Set G} (ht : IsNormalSubgroup t) (h : s ⊆ t) :
    normalClosure s ⊆ t
-- Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean
theorem nValue_pos (hN : 2 ≤ N) : 0 < nValue N
-- Mathlib/Data/Nat/Count.lean
theorem lt_of_count_lt_count {a b : ℕ} (h : count p a < count p b) : a < b
-- Mathlib/Analysis/Analytic/CPolynomial.lean
theorem changeOrigin_eval_of_finite (p : FormalMultilinearSeries 𝕜 E F) {n : ℕ}
    (hn : ∀ (m : ℕ), n ≤ m → p m = 0) (x y : E) :
    (p.changeOrigin x).sum y = p.sum (x + y)
-- Mathlib/Analysis/Normed/Group/Hom.lean
theorem bounds_bddBelow {f : NormedAddGroupHom V₁ V₂} :
    BddBelow { c | 0 ≤ c ∧ ∀ x, ‖f x‖ ≤ c * ‖x‖ }
-- Mathlib/Data/Set/Sigma.lean
theorem mk_sigma_iff : (⟨i, a⟩ : Σ i, α i) ∈ s.sigma t ↔ i ∈ s ∧ a ∈ t i
-- Mathlib/CategoryTheory/GradedObject.lean
@[reassoc (attr := simp)]
lemma hom_inv_id_eval (e : X ≅ Y) (j : J) :
    e.hom j ≫ e.inv j = 𝟙 _
-- Mathlib/Data/Set/Lattice.lean
theorem mem_iInter₂ {x : γ} {s : ∀ i, κ i → Set γ} : (x ∈ ⋂ (i) (j), s i j) ↔ ∀ i j, x ∈ s i j
-- Mathlib/LinearAlgebra/Matrix/BilinearForm.lean
@[simp]
theorem BilinForm.toMatrix_mul_basis_toMatrix (c : Basis o R₂ M₂) (B : BilinForm R₂ M₂) :
    (b.toMatrix c)ᵀ * BilinForm.toMatrix b B * b.toMatrix c = BilinForm.toMatrix c B
-- Mathlib/NumberTheory/PellMatiyasevic.lean
theorem yn_modEq_a_sub_one : ∀ n, yn a1 n ≡ n [MOD a - 1]
-- Mathlib/Analysis/Convex/Deriv.lean
/-- If `f : ℝ → ℝ` is strictly convex on `S` and differentiable at `y ∈ S`, then the slope of any
secant line with right endpoint at `y` is strictly less than the derivative of `f` at `y`. -/
lemma slope_lt_of_hasDerivAt (hfc : StrictConvexOn ℝ S f) (hx : x ∈ S) (hy : y ∈ S) (hxy : x < y)
    (hf' : HasDerivAt f f' y) :
    slope f x y < f'
-- Mathlib/GroupTheory/GroupAction/ConjAct.lean
@[simp]
theorem «forall» (p : ConjAct G → Prop) : (∀ x : ConjAct G, p x) ↔ ∀ x : G, p (toConjAct x)
-- Mathlib/Algebra/Ring/Subring/Pointwise.lean
theorem mem_inv_pointwise_smul_iff₀ {a : M} (ha : a ≠ 0) (S : Subring R) (x : R) :
    x ∈ a⁻¹ • S ↔ a • x ∈ S
-- Mathlib/Data/Int/AbsoluteValue.lean
@[simp]
theorem AbsoluteValue.map_units_intCast [Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ) :
    abv ((x : ℤ) : R) = 1
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Scheme.lean
theorem mem_carrier_iff (q : Spec.T A⁰_ f) (a : A) :
    a ∈ carrier f_deg q ↔ ∀ i, (HomogeneousLocalization.mk ⟨m * i, ⟨proj 𝒜 i a ^ m, by mem_tac⟩,
      ⟨f ^ i, by rw [mul_comm]; mem_tac⟩, ⟨_, rfl⟩⟩ : A⁰_ f) ∈ q.1
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
@[simp] theorem add_eq : Nat.add x y = x + y
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
@[simp]
theorem Basis.ofZlatticeBasis_apply (i : ι) :
    b.ofZlatticeBasis K L i =  b i
-- Mathlib/MeasureTheory/Measure/Dirac.lean
/-- If `f` is a map with countable codomain, then `μ.map f` is a sum of Dirac measures. -/
theorem map_eq_sum [Countable β] [MeasurableSingletonClass β] (μ : Measure α) (f : α → β)
    (hf : Measurable f) : μ.map f = sum fun b : β => μ (f ⁻¹' {b}) • dirac b
-- Mathlib/RingTheory/TensorProduct/Basic.lean
theorem natCast_def' (n : ℕ) : (n : A ⊗[R] B) = (1 : A) ⊗ₜ (n : B)
-- Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean
/-- The constant factor occurring in the conclusion of `eLpNorm_le_eLpNorm_fderiv_one`.
It only depends on `E`, `μ` and `p`. -/
irreducible_def eLpNormLESNormFDerivOneConst (p : ℝ) : ℝ≥0
-- Mathlib/SetTheory/Surreal/Basic.lean
/-- A small family of surreals is bounded below. -/
lemma bddBelow_range_of_small {ι : Type*} [Small.{u} ι] (f : ι → Surreal.{u}) :
    BddBelow (Set.range f)
-- Mathlib/Order/Hom/Basic.lean
/-- A bundled expression of the fact that a map between partial orders that is strictly monotone
is weakly monotone. -/
@[simps (config := .asFn)]
def toOrderHom : α →o β
-- Mathlib/Geometry/Manifold/PartitionOfUnity.lean
theorem toSmoothPartitionOfUnity_apply (i : ι) (x : M) :
    fs.toSmoothPartitionOfUnity i x = fs i x * ∏ᶠ (j) (_ : WellOrderingRel j i), (1 - fs j x)
-- Mathlib/Data/Ordmap/Ordset.lean
@[simp]
theorem Sized.size_eq_zero {t : Ordnode α} (ht : Sized t) : size t = 0 ↔ t = nil
-- Mathlib/Topology/Category/Profinite/Nobeling.lean
theorem succ_exact :
    (ShortComplex.mk (ModuleCat.ofHom (πs C o)) (ModuleCat.ofHom (Linear_CC' C hsC ho))
    (by ext; apply CC_comp_zero)).Exact
-- Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean
/-- The sine of an angle in a right-angled triangle multiplied by the hypotenuse equals the
opposite side. -/
theorem sin_oangle_right_mul_dist_of_oangle_eq_pi_div_two {p₁ p₂ p₃ : P}
    (h : ∡ p₁ p₂ p₃ = ↑(π / 2)) : Real.Angle.sin (∡ p₂ p₃ p₁) * dist p₁ p₃ = dist p₁ p₂
-- Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean
lemma measurableSet_natGeneratingSequence [MeasurableSpace α] [CountablyGenerated α] (n : ℕ) :
    MeasurableSet (natGeneratingSequence α n)
-- Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean
@[simp]
lemma nndist_pi_const [Nonempty β] (a b : α) : (nndist (fun _ : β => a) fun _ => b) = nndist a b
-- Mathlib/Data/Finsupp/Indicator.lean
theorem indicator_of_mem (hi : i ∈ s) (f : ∀ i ∈ s, α) : indicator s f i = f i hi
-- Mathlib/Algebra/CharP/ExpChar.lean
theorem coe_iterateFrobenius_mul : iterateFrobenius R p (m * n) = (iterateFrobenius R p m)^[n]
-- Mathlib/Analysis/Normed/Module/Dual.lean
/-- If one controls the norm of every `f x`, then one controls the norm of `x`.
    Compare `ContinuousLinearMap.opNorm_le_bound`. -/
theorem norm_le_dual_bound (x : E) {M : ℝ} (hMp : 0 ≤ M) (hM : ∀ f : Dual 𝕜 E, ‖f x‖ ≤ M * ‖f‖) :
    ‖x‖ ≤ M
-- Mathlib/Algebra/Order/Interval/Basic.lean
@[simp]
theorem length_neg : ∀ s : Interval α, (-s).length = s.length
-- Mathlib/Data/Real/EReal.lean
@[simp, norm_cast]
theorem coe_ennreal_eq_zero {x : ℝ≥0∞} : (x : EReal) = 0 ↔ x = 0
-- Mathlib/Analysis/Calculus/FDeriv/Prod.lean
@[fun_prop]
theorem hasStrictFDerivAt_snd : HasStrictFDerivAt (@Prod.snd E F) (snd 𝕜 E F) p
-- Mathlib/Order/Hom/Bounded.lean
@[simp]
theorem dual_comp (g : BoundedOrderHom β γ) (f : BoundedOrderHom α β) :
    BoundedOrderHom.dual (g.comp f) = g.dual.comp (BoundedOrderHom.dual f)
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem natDegree_quadratic (ha : a ≠ 0) : natDegree (C a * X ^ 2 + C b * X + C c) = 2
-- Mathlib/Data/PEquiv.lean
theorem single_trans_of_mem (a : α) {b : β} {c : γ} {f : β ≃. γ} (h : c ∈ f b) :
    (single a b).trans f = single a c
-- Mathlib/Topology/VectorBundle/Basic.lean
theorem symmL_continuousLinearMapAt (e : Trivialization F (π F E)) [e.IsLinear R] {b : B}
    (hb : b ∈ e.baseSet) (y : E b) : e.symmL R b (e.continuousLinearMapAt R b y) = y
-- Mathlib/MeasureTheory/MeasurableSpace/Card.lean
/-- `generateMeasurableRec s` generates precisely the smallest sigma-algebra containing `s`. -/
theorem generateMeasurable_eq_rec (s : Set (Set α)) :
    { t | GenerateMeasurable s t } =
        ⋃ (i : (Quotient.out (aleph 1).ord).α), generateMeasurableRec s i
-- Mathlib/RingTheory/Regular/RegularSequence.lean
lemma nil [Nontrivial M] : IsRegular M ([] : List R)
-- Mathlib/Algebra/Group/Basic.lean
@[to_additive]
theorem mul_eq_of_eq_inv_mul (h : b = a⁻¹ * c) : a * b = c
-- Mathlib/Analysis/InnerProductSpace/Basic.lean
/-- Polarization identity: The real part of the inner product, in terms of the norm. -/
theorem re_inner_eq_norm_add_mul_self_sub_norm_mul_self_sub_norm_mul_self_div_two (x y : E) :
    re ⟪x, y⟫ = (‖x + y‖ * ‖x + y‖ - ‖x‖ * ‖x‖ - ‖y‖ * ‖y‖) / 2
-- Mathlib/RingTheory/Finiteness.lean
theorem fg_def {N : Submodule R M} : N.FG ↔ ∃ S : Set M, S.Finite ∧ span R S = N
-- Mathlib/Algebra/Group/Fin/Tuple.lean
lemma cons_nonzero_iff {v : Fin n → α} {x : α} : vecCons x v ≠ 0 ↔ x ≠ 0 ∨ v ≠ 0
-- Mathlib/Analysis/Normed/Algebra/Unitization.lean
lemma norm_inr (a : A) : ‖(a : Unitization 𝕜 A)‖ = ‖a‖
-- Mathlib/Algebra/Order/Monoid/Unbundled/Defs.lean
theorem contravariant_le_iff_contravariant_lt_and_eq [PartialOrder N] :
    Contravariant M N μ (· ≤ ·) ↔ Contravariant M N μ (· < ·) ∧ Contravariant M N μ (· = ·)
-- Mathlib/LinearAlgebra/Dual.lean
theorem range_dualMap_le_dualAnnihilator_ker :
    LinearMap.range f.dualMap ≤ f.ker.dualAnnihilator
-- Mathlib/Algebra/Homology/Single.lean
@[simp]
lemma fromSingle₀Equiv_symm_apply_f_zero {C : CochainComplex V ℕ} {X : V}
    (f : X ⟶ C.X 0) (hf : f ≫ C.d 0 1 = 0) :
    ((fromSingle₀Equiv C X).symm ⟨f, hf⟩).f 0 = f
-- Mathlib/MeasureTheory/Measure/Restrict.lean
@[simp]
theorem restrict_compl_add_restrict (hs : MeasurableSet s) : μ.restrict sᶜ + μ.restrict s = μ
-- Mathlib/Data/Finite/Defs.lean
theorem Finite.exists_equiv_fin (α : Sort*) [h : Finite α] : ∃ n : ℕ, Nonempty (α ≃ Fin n)
-- Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean
/-- The derivative of `det (1 + M X)` at `0` is the trace of `M`. -/
lemma derivative_det_one_add_X_smul (M : Matrix n n R) :
    (derivative <| det (1 + (X : R[X]) • M.map C)).eval 0 = trace M
-- Mathlib/Algebra/RingQuot.lean
theorem Rel.smul {r : A → A → Prop} (k : S) ⦃a b : A⦄ (h : Rel r a b) : Rel r (k • a) (k • b)
-- Mathlib/Algebra/BigOperators/Group/Finset.lean
@[simp]
theorem ofAdd_list_prod (s : List α) : ofAdd s.sum = (s.map ofAdd).prod
-- Mathlib/Order/Hom/Basic.lean
@[simp]
theorem lt_map_inv_iff (f : F) {a : α} {b : β} : a < EquivLike.inv f b ↔ f a < b
-- Mathlib/Data/Set/Pointwise/Interval.lean
@[simp]
theorem image_sub_const_Icc : (fun x => x - a) '' Icc b c = Icc (b - a) (c - a)
-- Mathlib/Computability/AkraBazzi/GrowsPolynomially.lean
protected lemma neg {f : ℝ → ℝ} (hf : GrowsPolynomially f) : GrowsPolynomially (-f)
-- Mathlib/Logic/Function/FromTypes.lean
@[simp]
theorem const_zero (p : Fin 0 → Type u) {τ : Type u} (t : τ) : const p t = t
-- Mathlib/Data/Set/Image.lean
@[deprecated exists_subset_range_and_iff (since := "2024-06-06")]
theorem exists_subset_range_iff {f : α → β} {p : Set β → Prop} :
    (∃ (s : _) (_ : s ⊆ range f), p s) ↔ ∃ s, p (f '' s)
-- Mathlib/Data/Real/Basic.lean
theorem cauchy_zero : (0 : ℝ).cauchy = 0
-- Mathlib/Algebra/Homology/ShortComplex/Homology.lean
@[simp]
lemma HomologyData.leftRightHomologyComparison'_eq (h : S.HomologyData) :
    leftRightHomologyComparison' h.left h.right = h.iso.hom
-- Mathlib/Order/Booleanisation.lean
@[simp] lemma comp_sdiff_comp (a b : α) : comp a \ comp b = lift (b \ a)
-- Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean
theorem transcendental_liouvilleNumber {m : ℕ} (hm : 2 ≤ m) :
    Transcendental ℤ (liouvilleNumber m)