ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Mathlib/Algebra/Homology/ShortComplex/HomologicalComplex.lean
@[reassoc (attr := simp)]
lemma toCycles_i [K.HasHomology j] :
    K.toCycles i j ≫ K.iCycles j = K.d i j
-- Mathlib/Data/Finset/Sups.lean
@[simp] lemma diffs_eq_empty : s \\ t = ∅ ↔ s = ∅ ∨ t = ∅
-- Mathlib/Analysis/Calculus/ContDiff/Basic.lean
theorem contDiffWithinAt_id {s x} : ContDiffWithinAt 𝕜 n (id : E → E) s x
-- Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean
/-- Rotating the first of two vectors by `θ` scales their Kahler form by `cos (-θ) + sin (-θ) * I`.
-/
theorem kahler_rotation_left' (x y : V) (θ : Real.Angle) :
    o.kahler (o.rotation θ x) y = (-θ).expMapCircle * o.kahler x y
-- Mathlib/Algebra/Algebra/Equiv.lean
@[simp]
theorem ofAlgHom_coe_algHom (f : A₁ ≃ₐ[R] A₂) (g : A₂ →ₐ[R] A₁) (h₁ h₂) :
    ofAlgHom (↑f) g h₁ h₂ = f
-- Mathlib/Data/Finset/Image.lean
@[simp]
theorem map_erase [DecidableEq α] (f : α ↪ β) (s : Finset α) (a : α) :
    (s.erase a).map f = (s.map f).erase (f a)
-- Mathlib/Data/Finset/Pointwise.lean
theorem Nonempty.zero_div (hs : s.Nonempty) : 0 / s = 0
-- Mathlib/Algebra/Module/Zlattice/Basic.lean
theorem exist_unique_vadd_mem_fundamentalDomain [Finite ι] (x : E) :
    ∃! v : span ℤ (Set.range b), v +ᵥ x ∈ fundamentalDomain b
-- Mathlib/MeasureTheory/Constructions/BorelSpace/Order.lean
theorem Dense.borel_eq_generateFrom_Ioc_mem_aux {α : Type*} [TopologicalSpace α] [LinearOrder α]
    [OrderTopology α] [SecondCountableTopology α] {s : Set α} (hd : Dense s)
    (hbot : ∀ x, IsTop x → x ∈ s) (hIoo : ∀ x y : α, x < y → Ioo x y = ∅ → x ∈ s) :
    borel α = .generateFrom { S : Set α | ∃ l ∈ s, ∃ u ∈ s, l < u ∧ Ioc l u = S }
-- Mathlib/RingTheory/RootsOfUnity/Basic.lean
/-- If there is an `n`-th primitive root of unity in `R` and `b` divides `n`,
then there is a `b`-th primitive root of unity in `R`. -/
theorem pow {n : ℕ} {a b : ℕ} (hn : 0 < n) (h : IsPrimitiveRoot ζ n) (hprod : n = a * b) :
    IsPrimitiveRoot (ζ ^ a) b
-- Mathlib/Data/Int/Interval.lean
@[simp]
theorem card_Ico : (Ico a b).card = (b - a).toNat
-- Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean
@[simp]
theorem boundedBy_top : boundedBy (⊤ : Set α → ℝ≥0∞) = ⊤
-- Mathlib/Algebra/Order/Module/Pointwise.lean
lemma smul_upperBounds_subset_lowerBounds_smul (ha : a ≤ 0) :
    a • upperBounds s ⊆ lowerBounds (a • s)
-- Mathlib/Geometry/Manifold/BumpFunction.lean
theorem rOut_pos : 0 < f.rOut
-- Mathlib/Tactic/NormNum/Basic.lean
theorem isNat_eq_true [AddMonoidWithOne α] : {a b : α} → {c : ℕ} →
    IsNat a c → IsNat b c → a = b
-- Mathlib/Algebra/Order/Hom/Monoid.lean
@[to_additive (attr := simp)]
theorem coe_one : ⇑(1 : α →*o β) = 1
-- Mathlib/Data/List/Basic.lean
theorem replicate_left_injective (a : α) : Injective (replicate · a)
-- .lake/packages/lean4/src/lean/Init/Data/Nat/Basic.lean
protected theorem max_def {n m : Nat} : max n m = if n ≤ m then m else n
-- Mathlib/Algebra/GroupWithZero/Action/Prod.lean
theorem smul_mk_zero {β : Type*} [Monoid M] [AddMonoid β] [DistribMulAction M β] (a : M) (b : α) :
    a • (b, (0 : β)) = (a • b, 0)
-- Mathlib/Topology/UniformSpace/Cauchy.lean
theorem Filter.HasBasis.totallyBounded_iff {ι} {p : ι → Prop} {U : ι → Set (α × α)}
    (H : (𝓤 α).HasBasis p U) {s : Set α} :
    TotallyBounded s ↔ ∀ i, p i → ∃ t : Set α, Set.Finite t ∧ s ⊆ ⋃ y ∈ t, { x | (x, y) ∈ U i }
-- Mathlib/Combinatorics/SimpleGraph/Subgraph.lean
@[simp]
theorem edgeSet_sup {H₁ H₂ : Subgraph G} : (H₁ ⊔ H₂).edgeSet = H₁.edgeSet ∪ H₂.edgeSet
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
theorem mem_zpowers_iff {g h : G} : h ∈ zpowers g ↔ ∃ k : ℤ, g ^ k = h
-- Mathlib/MeasureTheory/Integral/FundThmCalculus.lean
/-- Change of variables, most common version. If `f` has continuous derivative `f'` on `[a, b]`,
and `g` is continuous, then we can substitute `u = f x` to get
`∫ x in a..b, f' x • (g ∘ f) x = ∫ u in f a..f b, g u`.
-/
theorem integral_comp_smul_deriv {f f' : ℝ → ℝ} {g : ℝ → G}
    (h : ∀ x ∈ uIcc a b, HasDerivAt f (f' x) x) (h' : ContinuousOn f' (uIcc a b))
    (hg : Continuous g) : (∫ x in a..b, f' x • (g ∘ f) x) = ∫ x in f a..f b, g x
-- Mathlib/RingTheory/Coalgebra/Hom.lean
@[simp]
theorem one_apply (x : A) : (1 : A →ₗc[R] A) x = x
-- Mathlib/Analysis/Normed/Group/Basic.lean
@[to_additive existing]
theorem norm_prod_le (s : Finset ι) (f : ι → E) : ‖∏ i ∈ s, f i‖ ≤ ∑ i ∈ s, ‖f i‖
-- Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean
theorem mul_inv_eq_iff_eq_mul_of_invertible (A B C : Matrix n n α) [Invertible A] :
    B * A⁻¹ = C ↔ B = C * A
-- Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unital.lean
lemma cfc_smul {S : Type*} [SMul S R] [ContinuousConstSMul S R]
    [SMulZeroClass S A] [IsScalarTower S R A] [IsScalarTower S R (R → R)]
    (s : S) (f : R → R) (a : A) (hf : ContinuousOn f (spectrum R a) := by cfc_cont_tac) :
    cfc (fun x ↦ s • f x) a = s • cfc f a
-- Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean
@[simp]
theorem toComplex_re (x y : ℤ) : ((⟨x, y⟩ : ℤ[i]) : ℂ).re = x
-- Mathlib/LinearAlgebra/BilinearForm/Basic.lean
@[ext]
theorem ext (H : ∀ x y : M, B x y = D x y) : B = D
-- Mathlib/Analysis/Convolution.lean
/-- The convolution `g * f` 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_left_with_param [μ.IsAddLeftInvariant] [μ.IsNegInvariant]
    (L : E' →L[𝕜] E →L[𝕜] F) {f : G → E} {n : ℕ∞} {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 => (g q.1 ⋆[L, μ] f) q.2) (s ×ˢ univ)
-- Mathlib/Order/Max.lean
theorem IsMax.prod_mk (ha : IsMax a) (hb : IsMax b) : IsMax (a, b)
-- Mathlib/Topology/Category/CompHausLike/Basic.lean
/-- Construct an isomorphism from a homeomorphism. -/
@[simps!]
def isoOfHomeo {X Y : CompHausLike.{u} P} (f : X ≃ₜ Y) : X ≅ Y
-- Mathlib/Algebra/Group/AddChar.lean
@[simp] lemma toAddMonoidHomEquiv_symm_apply (ψ : A →+ Additive M) (a : A) :
    toAddMonoidHomEquiv.symm ψ a = Additive.toMul (ψ a)
-- Mathlib/Algebra/Group/Subgroup/Basic.lean
@[simp]
theorem inclusion_inclusion {L : S} (hHK : H ≤ K) (hKL : K ≤ L) (x : H) :
    inclusion hKL (inclusion hHK x) = inclusion (hHK.trans hKL) x
-- Mathlib/LinearAlgebra/LinearIndependent.lean
theorem LinearIndependent.to_subtype_range {ι} {f : ι → M} (hf : LinearIndependent R f) :
    LinearIndependent R ((↑) : range f → M)
-- Mathlib/AlgebraicGeometry/Scheme.lean
@[simp]
theorem basicOpen_mul : X.basicOpen (f * g) = X.basicOpen f ⊓ X.basicOpen g
-- Mathlib/Algebra/Ring/Equiv.lean
@[simp]
theorem coe_mulEquiv_trans (e₁ : R ≃+* S) (e₂ : S ≃+* S') :
    (e₁.trans e₂ : R ≃* S') = (e₁ : R ≃* S).trans ↑e₂
-- Mathlib/Data/Set/Subsingleton.lean
theorem nontrivial_iff_exists_ne {x} (hx : x ∈ s) : s.Nontrivial ↔ ∃ y ∈ s, y ≠ x
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
theorem set_eq_of_length_le {l : List α} {n : Nat} (h : l.length ≤ n) {a : α} :
    l.set n a = l
-- Mathlib/Topology/Algebra/GroupCompletion.lean
/-- The map from a group to its completion as a group hom. -/
@[simps]
def toCompl : α →+ Completion α
-- Mathlib/MeasureTheory/Integral/IntervalIntegral.lean
theorem abs {f : ℝ → ℝ} (h : IntervalIntegrable f μ a b) :
    IntervalIntegrable (fun x => |f x|) μ a b
-- Mathlib/CategoryTheory/Limits/HasLimits.lean
@[simp]
theorem colimit.coconeMorphism_hom {F : J ⥤ C} [HasColimit F] (c : Cocone F) :
    (colimit.coconeMorphism c).hom = colimit.desc F c
-- Mathlib/Algebra/MvPolynomial/Basic.lean
theorem map_eval₂ (f : R →+* S₁) (g : S₂ → MvPolynomial S₃ R) (p : MvPolynomial S₂ R) :
    map f (eval₂ C g p) = eval₂ C (map f ∘ g) (map f p)
-- Mathlib/Data/List/Basic.lean
theorem infix_bind_of_mem {a : α} {as : List α} (h : a ∈ as) (f : α → List α) :
    f a <:+: as.bind f
-- Mathlib/Data/Set/Pointwise/SMul.lean
theorem iUnion_vsub (s : ι → Set β) (t : Set β) : (⋃ i, s i) -ᵥ t = ⋃ i, s i -ᵥ t
-- Mathlib/Data/Finset/Sups.lean
@[simp]
theorem empty_sups : ∅ ⊻ t = ∅
-- Mathlib/RingTheory/DedekindDomain/AdicValuation.lean
theorem coe_smul_adicCompletion (r : R) (x : K) :
    (↑(r • x) : v.adicCompletion K) = r • (↑x : v.adicCompletion K)
-- Mathlib/CategoryTheory/Monoidal/Bimod.lean
theorem hom_right_act_hom' :
    (P.tensorBimod (regular S)).actRight ≫ hom P = (hom P ▷ S.X) ≫ P.actRight
-- Mathlib/Data/Finset/Sups.lean
theorem sups_infs_subset_left : s ⊻ t ⊼ u ⊆ (s ⊻ t) ⊼ (s ⊻ u)
-- Mathlib/Data/Finset/Powerset.lean
@[simp]
theorem powerset_inj : powerset s = powerset t ↔ s = t
-- Mathlib/Algebra/Group/Subgroup/ZPowers.lean
@[simp]
theorem intCast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r
-- Mathlib/Topology/MetricSpace/Dilation.lean
/-- The `ratio` is equal to the distance ratio for any two points with nonzero finite distance.
`dist` and `nndist` versions below -/
theorem ratio_unique [DilationClass F α β] {f : F} {x y : α} {r : ℝ≥0} (h₀ : edist x y ≠ 0)
    (htop : edist x y ≠ ⊤) (hr : edist (f x) (f y) = r * edist x y) : r = ratio f
-- Mathlib/Tactic/CategoryTheory/Coherence.lean
lemma insert_id_rhs {C : Type*} [Category C] {X Y : C} (f g : X ⟶ Y) (w : f = g ≫ 𝟙 _) :
    f = g
-- Mathlib/Analysis/Convex/Gauge.lean
theorem gaugeSeminorm_lt_one_of_isOpen (hs : IsOpen s) {x : E} (hx : x ∈ s) :
    gaugeSeminorm hs₀ hs₁ hs₂ x < 1
-- Mathlib/Analysis/CstarAlgebra/Multiplier.lean
@[simp]
theorem norm_fst (a : 𝓜(𝕜, A)) : ‖a.fst‖ = ‖a‖
-- Mathlib/Topology/MetricSpace/DilationEquiv.lean
theorem symm_bijective : Function.Bijective (DilationEquiv.symm : (X ≃ᵈ Y) → Y ≃ᵈ X)
-- Mathlib/RingTheory/WittVector/Truncated.lean
theorem truncateFun_intCast (m : ℤ) : truncateFun n (m : 𝕎 R) = m
-- Mathlib/CategoryTheory/Sums/Basic.lean
@[simp]
theorem swap_map_inl {X Y : C} {f : inl X ⟶ inl Y} : (swap C D).map f = f
-- Mathlib/Algebra/Group/Invertible/Defs.lean
theorem mul_invOf_mul_self_cancel [Monoid α] (a b : α) [Invertible b] : a * ⅟ b * b = a
-- Mathlib/Analysis/SpecificLimits/Basic.lean
/-- A series whose terms are bounded by the terms of a converging geometric series converges. -/
theorem summable_one_div_pow_of_le {m : ℝ} {f : ℕ → ℕ} (hm : 1 < m) (fi : ∀ i, i ≤ f i) :
    Summable fun i ↦ 1 / m ^ f i
-- Mathlib/Topology/Sets/Compacts.lean
@[simp]
theorem coe_finset_sup {ι : Type*} {s : Finset ι} {f : ι → Compacts α} :
    (↑(s.sup f) : Set α) = s.sup fun i => ↑(f i)
-- Mathlib/CategoryTheory/EffectiveEpi/Preserves.lean
lemma effectiveEpiFamily_of_map (F : C ⥤ D) [ReflectsEffectiveEpiFamilies.{u} F]
    {α : Type u} {B : C} (X : α → C) (π : (a : α) → (X a ⟶ B))
    (h : EffectiveEpiFamily (fun a ↦ F.obj (X a)) (fun a  ↦ F.map (π a))) :
    EffectiveEpiFamily X π
-- Mathlib/Algebra/Order/Interval/Multiset.lean
lemma map_add_left_Ico (a b c : α) : (Ico a b).map (c + ·) = Ico (c + a) (c + b)
-- Mathlib/Data/Multiset/Sym.lean
theorem card_sym2 {m : Multiset α} :
    Multiset.card m.sym2 = Nat.choose (Multiset.card m + 1) 2
-- Mathlib/ModelTheory/Complexity.lean
theorem IsQF.not {φ : L.BoundedFormula α n} (h : IsQF φ) : IsQF φ.not
-- Mathlib/Analysis/Normed/Group/SemiNormedGrp.lean
theorem iso_isometry {V W : SemiNormedGrp₁} (i : V ≅ W) : Isometry i.hom
-- Mathlib/CategoryTheory/Localization/SmallHom.lean
@[simp]
lemma mkInv_comp_mk [HasSmallLocalizedHom.{w} W X X] [HasSmallLocalizedHom.{w} W X Y]
    [HasSmallLocalizedHom.{w} W Y X] (f : Y ⟶ X) (hf : W f) :
    (mkInv f hf).comp (mk W f) = mk W (𝟙 X)
-- Mathlib/Order/Filter/AtTopBot.lean
/-- If `r` is a positive constant, `fun x ↦ f x * r` tends to negative infinity along a filter
if and only if `f` tends to negative infinity along the same filter. -/
theorem tendsto_mul_const_atBot_of_pos (hr : 0 < r) :
    Tendsto (fun x => f x * r) l atBot ↔ Tendsto f l atBot
-- Mathlib/LinearAlgebra/Matrix/Transvection.lean
theorem toMatrix_sumInl (t : TransvectionStruct n R) :
    (t.sumInl p).toMatrix = fromBlocks t.toMatrix 0 0 1
-- Mathlib/Analysis/Convex/Deriv.lean
lemma slope_le_of_hasDerivWithinAt_Ioi (hfc : ConcaveOn ℝ S f)
    (hx : x ∈ S) (hy : y ∈ S) (hxy : x < y) (hf' : HasDerivWithinAt f f' (Ioi x) x) :
    slope f x y ≤ f'
-- Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean
theorem mdifferentiableAt_atlas_symm (h : e ∈ atlas H M) {x : H} (hx : x ∈ e.target) :
    MDifferentiableAt I I e.symm x
-- Mathlib/Data/Set/NAry.lean
@[simp]
theorem image2_empty_right : image2 f s ∅ = ∅
-- Mathlib/GroupTheory/FreeAbelianGroup.lean
@[simp]
theorem seq_neg (f : FreeAbelianGroup (α → β)) (x : FreeAbelianGroup α) : f <*> -x = -(f <*> x)
-- Mathlib/Algebra/Group/Submonoid/Operations.lean
/-- A submonoid is either the trivial submonoid or nontrivial. -/
@[to_additive "An additive submonoid is either the trivial additive submonoid or nontrivial."]
theorem bot_or_nontrivial (S : Submonoid M) : S = ⊥ ∨ Nontrivial S
-- Mathlib/RingTheory/Congruence/Basic.lean
/-- The infimum of two congruence relations equals the infimum of the underlying binary
operations. -/
@[simp, norm_cast]
theorem coe_inf {c d : RingCon R} : ⇑(c ⊓ d) = ⇑c ⊓ ⇑d
-- Mathlib/RingTheory/Coprime/Basic.lean
theorem neg_right_iff (x y : R) : IsCoprime x (-y) ↔ IsCoprime x y
-- Mathlib/Data/Finset/Lattice.lean
theorem sup'_eq_sup {s : Finset β} (H : s.Nonempty) (f : β → α) : s.sup' H f = s.sup f
-- Mathlib/RepresentationTheory/Maschke.lean
theorem sumOfConjugatesEquivariant_apply (v : W) :
    π.sumOfConjugatesEquivariant G v = ∑ g : G, π.conjugate g v
-- Mathlib/FieldTheory/Normal.lean
theorem Normal.minpoly_eq_iff_mem_orbit [h : Normal F E] {x y : E} :
    minpoly F x = minpoly F y ↔ x ∈ MulAction.orbit (E ≃ₐ[F] E) y
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
theorem sign_ofNat_of_nonzero {n : Nat} (hn : n ≠ 0) : Int.sign n = 1
-- Mathlib/Analysis/Matrix.lean
theorem frobenius_norm_mul (A : Matrix l m α) (B : Matrix m n α) : ‖A * B‖ ≤ ‖A‖ * ‖B‖
-- Mathlib/MeasureTheory/Function/L1Space.lean
theorem norm_toL1 (f : α → β) (hf : Integrable f μ) :
    ‖hf.toL1 f‖ = ENNReal.toReal (∫⁻ a, edist (f a) 0 ∂μ)
-- Mathlib/Data/Nat/Bitwise.lean
lemma two_pow_and (n i : ℕ) : 2 ^ i &&& n = 2 ^ i * (n.testBit i).toNat
-- Mathlib/MeasureTheory/Integral/LebesgueNormedSpace.lean
theorem aemeasurable_withDensity_iff {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    [SecondCountableTopology E] [MeasurableSpace E] [BorelSpace E] {f : α → ℝ≥0}
    (hf : Measurable f) {g : α → E} :
    AEMeasurable g (μ.withDensity fun x => (f x : ℝ≥0∞)) ↔
      AEMeasurable (fun x => (f x : ℝ) • g x) μ
-- Mathlib/Algebra/Group/TypeTags.lean
/-- Reinterpret `α →+ β` as `Multiplicative α →* Multiplicative β`. -/
@[simps]
def AddMonoidHom.toMultiplicative [AddZeroClass α] [AddZeroClass β] :
    (α →+ β) ≃ (Multiplicative α →* Multiplicative β)
-- Mathlib/Order/SuccPred/Basic.lean
theorem le_succ_bot_iff : a ≤ succ ⊥ ↔ a = ⊥ ∨ a = succ ⊥
-- Mathlib/Analysis/Convex/Topology.lean
theorem Real.convex_iff_isPreconnected {s : Set ℝ} : Convex ℝ s ↔ IsPreconnected s
-- Mathlib/Analysis/Calculus/FDeriv/Measurable.lean
theorem aestronglyMeasurable_derivWithin_Ici (μ : Measure ℝ) :
    AEStronglyMeasurable (fun x => derivWithin f (Ici x) x) μ
-- Mathlib/Analysis/Calculus/FDeriv/Mul.lean
@[fun_prop]
theorem HasFDerivAt.mul' (ha : HasFDerivAt a a' x) (hb : HasFDerivAt b b' x) :
    HasFDerivAt (fun y => a y * b y) (a x • b' + a'.smulRight (b x)) x
-- Mathlib/Topology/MetricSpace/Infsep.lean
theorem infsep_pos_iff_nontrivial_of_finite [Finite s] : 0 < s.infsep ↔ s.Nontrivial
-- Mathlib/Computability/TuringMachine.lean
@[simp]
theorem ListBlank.tail_map {Γ Γ'} [Inhabited Γ] [Inhabited Γ'] (f : PointedMap Γ Γ')
    (l : ListBlank Γ) : (l.map f).tail = l.tail.map f
-- Mathlib/Data/Rel.lean
theorem mem_image (y : β) (s : Set α) : y ∈ image r s ↔ ∃ x ∈ s, r x y
-- Mathlib/SetTheory/Game/PGame.lean
@[simp]
theorem neg_lt_neg_iff {x y : PGame} : -y < -x ↔ x < y
-- Mathlib/Topology/Algebra/InfiniteSum/Order.lean
@[to_additive]
theorem tprod_eq_one_iff (hf : Multipliable f) : ∏' i, f i = 1 ↔ ∀ x, f x = 1
-- Mathlib/Analysis/Complex/RealDeriv.lean
theorem HasDerivAt.complexToReal_fderiv {f : ℂ → ℂ} {f' x : ℂ} (h : HasDerivAt f f' x) :
    HasFDerivAt f (f' • (1 : ℂ →L[ℝ] ℂ)) x
-- Mathlib/Topology/Algebra/Module/Alternating/Basic.lean
@[simp]
theorem coe_zero : ⇑(0 : M [⋀^ι]→L[R] N) = 0
-- Mathlib/CategoryTheory/Comma/Arrow.lean
@[simp]
theorem mk_eq (f : Arrow T) : Arrow.mk f.hom = f
-- Mathlib/NumberTheory/KummerDedekind.lean
theorem conductor_eq_top_of_adjoin_eq_top (h : R<x> = ⊤) : conductor R x = ⊤
-- .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean
protected theorem lt_of_sub_pos {a b : Int} (h : 0 < a - b) : b < a
-- Mathlib/Topology/Filter.lean
theorem nhds_eq (l : Filter α) : 𝓝 l = l.lift' (Iic ∘ 𝓟)
-- Mathlib/Data/Finset/Sups.lean
theorem Nonempty.of_infs_left : (s ⊼ t).Nonempty → s.Nonempty
-- .lake/packages/lean4/src/lean/Init/Data/List/Lemmas.lean
@[simp] theorem length_reverse (as : List α) : (as.reverse).length = as.length
-- Mathlib/CategoryTheory/Bicategory/Functor/Prelax.lean
/-- Construct a prelax functor from a map on objects, and functors between the corresponding
hom types. -/
@[simps]
def mkOfHomFunctors (F : B → C) (F' : (a : B) → (b : B) → (a ⟶ b) ⥤ (F a ⟶ F b)) :
    PrelaxFunctor B C
-- Mathlib/Data/Nat/Fib/Zeckendorf.lean
@[simp] lemma zeckendorf_of_pos : ∀ {n}, 0 < n →
    zeckendorf n = greatestFib n :: zeckendorf (n - fib (greatestFib n))
-- Mathlib/Algebra/GeomSum.lean
@[simp]
theorem geom_sum_two {x : α} : ∑ i ∈ range 2, x ^ i = x + 1
-- Mathlib/Algebra/Associated/Basic.lean
theorem not_dvd_one : ¬p ∣ 1
-- Mathlib/Data/Matrix/Basic.lean
@[simp]
theorem conjTranspose_natCast [DecidableEq n] [Semiring α] [StarRing α] (d : ℕ) :
    (d : Matrix n n α)ᴴ = d
-- Mathlib/Data/List/Cycle.lean
@[simp]
theorem toFinset_toMultiset (s : Cycle α) : s.toMultiset.toFinset = s.toFinset
-- Mathlib/Analysis/Convex/Strict.lean
theorem strictConvex_Ico (r s : β) : StrictConvex 𝕜 (Ico r s)
-- Mathlib/Analysis/Calculus/ContDiff/Defs.lean
theorem hasFTaylorSeriesUpToOn_zero_iff :
    HasFTaylorSeriesUpToOn 0 f p s ↔ ContinuousOn f s ∧ ∀ x ∈ s, (p x 0).uncurry0 = f x
-- Mathlib/Algebra/Homology/ShortComplex/SnakeLemma.lean
@[simp, reassoc] lemma comp_f₀ : (f ≫ g).f₀ = f.f₀ ≫ g.f₀
-- Mathlib/Data/Nat/Defs.lean
@[simp] lemma dvd_div_iff_mul_dvd (hbc : c ∣ b) : a ∣ b / c ↔ c * a ∣ b
-- Mathlib/AlgebraicGeometry/ProjectiveSpectrum/Topology.lean
theorem sup_vanishingIdeal_le (t t' : Set (ProjectiveSpectrum 𝒜)) :
    vanishingIdeal t ⊔ vanishingIdeal t' ≤ vanishingIdeal (t ∩ t')
-- Mathlib/Data/Int/Bitwise.lean
@[simp]
theorem ldiff_bit (a m b n) : ldiff (bit a m) (bit b n) = bit (a && not b) (ldiff m n)
-- Mathlib/Data/Multiset/Basic.lean
theorem map_erase_of_mem [DecidableEq α] [DecidableEq β] (f : α → β)
    (s : Multiset α) {x : α} (h : x ∈ s) : (s.erase x).map f = (s.map f).erase (f x)
-- Mathlib/Order/Filter/Lift.lean
theorem lift_comm {g : Filter β} {h : Set α → Set β → Filter γ} :
    (f.lift fun s => g.lift (h s)) = g.lift fun t => f.lift fun s => h s t
-- Mathlib/SetTheory/ZFC/Basic.lean
@[simp]
theorem powerset_apply {A : Class.{u}} {x : ZFSet.{u}} : powerset A x ↔ ↑x ⊆ A
-- Mathlib/Algebra/Module/Torsion.lean
/-- The `a`-torsion submodule is an `a`-torsion module. -/
theorem torsionBy_isTorsionBy : IsTorsionBy R (torsionBy R M a) a
-- Mathlib/Algebra/Order/Floor.lean
@[gcongr]
theorem ceil_le_ceil : ∀ x y : α, x ≤ y → ⌈x⌉₊ ≤ ⌈y⌉₊
-- Mathlib/Algebra/Group/Invertible/Defs.lean
@[simp]
theorem invOf_mul_self' [Mul α] [One α] (a : α) {_ : Invertible a} : ⅟ a * a = 1
-- Mathlib/Topology/Homotopy/Contractible.lean
protected theorem Homeomorph.contractibleSpace [ContractibleSpace Y] (e : X ≃ₜ Y) :
    ContractibleSpace X
-- Mathlib/Analysis/Calculus/Deriv/Basic.lean
theorem derivWithin_Ioi_eq_Ici {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] (f : ℝ → E)
    (x : ℝ) : derivWithin f (Ioi x) x = derivWithin f (Ici x) x
-- Mathlib/Algebra/Polynomial/Degree/Definitions.lean
theorem zero_le_degree_iff : 0 ≤ degree p ↔ p ≠ 0
-- Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean
/-- Hölder's inequality, as an inequality on the `ℒp` seminorm of an elementwise operation
`fun x => b (f x) (g x)`. -/
theorem eLpNorm_le_eLpNorm_mul_eLpNorm_of_nnnorm {p q r : ℝ≥0∞}
    (hf : AEStronglyMeasurable f μ) (hg : AEStronglyMeasurable g μ) (b : E → F → G)
    (h : ∀ᵐ x ∂μ, ‖b (f x) (g x)‖₊ ≤ ‖f x‖₊ * ‖g x‖₊) (hpqr : 1 / p = 1 / q + 1 / r) :
    eLpNorm (fun x => b (f x) (g x)) p μ ≤ eLpNorm f q μ * eLpNorm g r μ
-- Mathlib/Topology/MetricSpace/Antilipschitz.lean
theorem restrict (hf : AntilipschitzWith K f) (s : Set α) : AntilipschitzWith K (s.restrict f)
-- Mathlib/LinearAlgebra/Lagrange.lean
@[simp]
theorem eval_basisDivisor_right : eval y (basisDivisor x y) = 0
-- Mathlib/CategoryTheory/Localization/HomEquiv.lean
lemma homEquiv_isoOfHom_inv (f : Y ⟶ X) (hf : W f) :
    homEquiv W L₁ L₂ (isoOfHom L₁ W f hf).inv = (isoOfHom L₂ W f hf).inv
-- Mathlib/Topology/Algebra/Order/LiminfLimsup.lean
/-- A continuous antitone function between (conditionally) complete linear ordered spaces sends a
`Filter.liminf` to the `Filter.limsup` of the images (if the filter is bounded from below and
frequently bounded from above). -/
theorem Antitone.map_liminf_of_continuousAt {f : R → S} (f_decr : Antitone f) (a : ι → R)
    (f_cont : ContinuousAt f (F.liminf a))
    (cobdd : F.IsCoboundedUnder (· ≥ ·) a := by isBoundedDefault)
    (bdd_below : F.IsBoundedUnder (· ≥ ·) a := by isBoundedDefault) :
    f (F.liminf a) = F.limsup (f ∘ a)
-- Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean
theorem measurableSet_range (hf : MeasurableEmbedding f) : MeasurableSet (range f)
-- Mathlib/Data/List/Intervals.lean
theorem filter_le_of_le_bot {n m l : ℕ} (hln : l ≤ n) :
    ((Ico n m).filter fun x => l ≤ x) = Ico n m
-- Mathlib/Data/NNReal/Basic.lean
lemma toNNReal_eq_iff_eq_coe {r : ℝ} {p : ℝ≥0} (hp : p ≠ 0) : r.toNNReal = p ↔ r = p
-- Mathlib/Order/Filter/Partial.lean
theorem tendsto_iff_rtendsto' (l₁ : Filter α) (l₂ : Filter β) (f : α → β) :
    Tendsto f l₁ l₂ ↔ RTendsto' (Function.graph f) l₁ l₂
-- .lake/packages/lean4/src/lean/Init/Data/List/Basic.lean
@[simp] theorem rotateLeft_nil : ([] : List α).rotateLeft n = []
-- Mathlib/Analysis/Complex/Circle.lean
theorem coe_inv_circle_eq_conj (z : circle) : ↑z⁻¹ = conj (z : ℂ)
-- Mathlib/Order/Bounds/Basic.lean
theorem isLUB_Ioo {a b : γ} (hab : a < b) : IsLUB (Ioo a b) b
-- Mathlib/CategoryTheory/Abelian/Pseudoelements.lean
/-- The zero morphism maps every pseudoelement to 0. -/
@[simp]
theorem zero_apply {P : C} (Q : C) (a : P) : (0 : P ⟶ Q) a = 0
-- Mathlib/Data/Nat/GCD/Basic.lean
@[simp]
theorem gcd_add_self_left (m n : ℕ) : gcd (m + n) n = gcd m n
-- Mathlib/SetTheory/Cardinal/Ordinal.lean
@[simp]
theorem aleph_zero : aleph 0 = ℵ₀
-- Mathlib/Order/Monotone/Basic.lean
theorem Monotone.strictMono_of_injective (h₁ : Monotone f) (h₂ : Injective f) : StrictMono f
-- Mathlib/Data/Finsupp/Defs.lean
theorem single_apply_ne_zero {a x : α} {b : M} : single a b x ≠ 0 ↔ x = a ∧ b ≠ 0
-- Mathlib/Data/DFinsupp/WellFounded.lean
theorem Lex.wellFounded' (hbot : ∀ ⦃i a⦄, ¬s i a 0) (hs : ∀ i, WellFounded (s i))
    [IsTrichotomous ι r] (hr : WellFounded (Function.swap r)) :
    WellFounded (DFinsupp.Lex r s)
-- Mathlib/Analysis/NormedSpace/HahnBanach/SeparatingDual.lean
protected theorem t1Space [T1Space R] : T1Space V
-- Mathlib/Analysis/Normed/Lp/lpSpace.lean
theorem _root_.natCast_memℓp_infty (n : ℕ) : Memℓp (n : ∀ i, B i) ∞
-- Mathlib/LinearAlgebra/RootSystem/RootPositive.lean
lemma pairing_zero_iff : P.pairing i j = 0 ↔ P.pairing j i = 0
-- Mathlib/Algebra/Ring/Basic.lean
@[simp]
theorem inv_neg' (a : α) : (-a)⁻¹ = -a⁻¹
-- Mathlib/LinearAlgebra/Basis.lean
@[simp]
theorem prod_repr_inr (x) (i) : (b.prod b').repr x (Sum.inr i) = b'.repr x.2 i
-- Mathlib/Data/Ordmap/Ordset.lean
theorem Sized.rotateR {l x r} (hl : @Sized α l) (hr : Sized r) : Sized (rotateR l x r)
-- Mathlib/Probability/Kernel/Disintegration/Integral.lean
lemma setLIntegral_condKernel (hf : Measurable f) {s : Set β}
    (hs : MeasurableSet s) {t : Set Ω} (ht : MeasurableSet t) :
    ∫⁻ b in s, ∫⁻ ω in t, f (b, ω) ∂(ρ.condKernel b) ∂ρ.fst
      = ∫⁻ x in s ×ˢ t, f x ∂ρ
-- Mathlib/Algebra/CharP/Defs.lean
lemma cast_eq_zero_iff (a : ℕ) : (a : R) = 0 ↔ p ∣ a