name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric.0.ordinaryHypergeometric_radius_top_of_neg_nat₁._proof_1_2 | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {k : ℕ} (n : ℕ), k < n + (1 + k) | null | false |
fourierCoeffOn_of_hasDeriv_right | Mathlib.Analysis.Fourier.AddCircle | ∀ {a b : ℝ} (hab : a < b) {f f' : ℝ → ℂ} {n : ℤ},
n ≠ 0 →
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Set.Ioi x) x) →
IntervalIntegrable f' MeasureTheory.volume a b →
fourierCoeffOn hab f n =
1 / (-2 * ↑Real.pi * Complex.I * ↑n... | Express Fourier coefficients of `f` on an interval in terms of those of its derivative. | true |
_private.Mathlib.RingTheory.MvPolynomial.MonomialOrder.0.MonomialOrder.sPolynomial_decomposition._simp_1_2 | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (p : MvPolynomial σ R) (a : R), MvPolynomial.C a * p = a • p | null | false |
Set.EquicontinuousWithinAt | Mathlib.Topology.UniformSpace.Equicontinuity | {X : Type u_3} → {α : Type u_6} → [tX : TopologicalSpace X] → [uα : UniformSpace α] → Set (X → α) → Set X → X → Prop | We say that a set `H : Set (X → α)` of functions is equicontinuous at a point within a subset
if the family `(↑) : ↥H → (X → α)` is equicontinuous at that point within that same subset. | true |
CategoryTheory.ObjectProperty.IsSeparating.isSeparator_coproduct | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {β : Type w}
{f : β → C} [inst_2 : CategoryTheory.Limits.HasCoproduct f],
(CategoryTheory.ObjectProperty.ofObj f).IsSeparating → CategoryTheory.IsSeparator (∐ f) | null | true |
Algebra.Presentation.instCommRingCore._proof_41 | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] {P : Algebra.Presentation R S ι σ},
autoParam (∀ (n : ℕ) (a : P.Core), Int.negSucc n • a = -(↑n.succ • a)) SubNegMonoid.zsmul_neg'._autoParam | null | false |
Aesop.instMonadParentDeclStateRefT'_aesop | Aesop.Util.Basic | {m : Type → Type} → {ω σ : Type} → [Lean.Elab.MonadParentDecl m] → Lean.Elab.MonadParentDecl (StateRefT' ω σ m) | null | true |
Filter.Realizer.bind._proof_16 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_2} {β : Type u_1} {f : Filter α} {m : α → Filter β} (F : f.Realizer) (G : (i : α) → (m i).Realizer)
(x : Set β),
x ∈
{
f := fun x =>
match x with
| ⟨s, f_1⟩ => ⋃ i, ⋃ (h : i ∈ F.F.f s), (G i).F.f (f_1 i h),
pt := ⟨F.F.pt, fun i x => (G i).F.pt⟩... | null | false |
CategoryTheory.NormalEpi.regularEpi | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(f : X ⟶ Y) → [I : CategoryTheory.NormalEpi f] → CategoryTheory.RegularEpi f | Every normal epimorphism is a regular epimorphism. | true |
WellFoundedLT.min_le | Mathlib.Order.WellFounded | ∀ {β : Type u_2} [inst : LinearOrder β] [inst_1 : WellFoundedLT β] {x : β} {s : Set β} (hx : x ∈ s),
WellFoundedLT.min s ⋯ ≤ x | null | true |
Filter.NeBot.one_le_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Group α] {f : Filter α}, f.NeBot → 1 ≤ f / f | null | true |
Std.ExtDTreeMap.keys_filter.match_1 | Std.Data.ExtDTreeMap.Lemmas | {α : Type u_1} →
{β : α → Type u_2} →
{cmp : α → α → Ordering} →
{t : Std.ExtDTreeMap α β cmp} →
[inst : Std.TransCmp cmp] →
(motive : { x // x ∈ t.keys } → Sort u_3) →
(x : { x // x ∈ t.keys }) → ((x : α) → (h' : x ∈ t.keys) → motive ⟨x, h'⟩) → motive x | null | false |
LinearEquiv.mem_transvections._simp_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {f : Module.Dual R V}
{v : V} (hfv : f v = 0), (LinearEquiv.transvection hfv ∈ LinearEquiv.transvections R V) = True | null | false |
Combinatorics.Line.ColorFocused.recOn | Mathlib.Combinatorics.HalesJewett | {α : Type u_5} →
{ι : Type u_6} →
{κ : Type u_7} →
{C : (ι → Option α) → κ} →
{motive : Combinatorics.Line.ColorFocused C → Sort u} →
(t : Combinatorics.Line.ColorFocused C) →
((lines : Multiset (Combinatorics.Line.AlmostMono C)) →
(focus : ι → Option α) →
... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.StronglyRegular.0.SimpleGraph.IsSRGWith.card_commonNeighbors_eq_of_adj_compl._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
Batteries.Tactic.GeneralizeProofs.AState._sizeOf_1 | Batteries.Tactic.GeneralizeProofs | Batteries.Tactic.GeneralizeProofs.AState → ℕ | null | false |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.finMulAntidiag_eq_piFinset_divisors_filter.match_1_4 | Mathlib.Algebra.Order.Antidiag.Nat | ∀ {d m n : ℕ} (f : Fin d → ℕ) (motive : (∀ (a : Fin d), f a ∣ n ∧ ¬n = 0) ∧ ∏ i, f i = m → Prop)
(x : (∀ (a : Fin d), f a ∣ n ∧ ¬n = 0) ∧ ∏ i, f i = m),
(∀ (left : ∀ (a : Fin d), f a ∣ n ∧ ¬n = 0) (hprod : ∏ i, f i = m), motive ⋯) → motive x | null | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException.rec | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm | {motive : Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException → Sort u} →
motive Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException.infeasible →
(t : Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmException) → motive t | null | false |
_private.Mathlib.RingTheory.Ideal.Prime.0.Ideal.not_isPrime_iff.match_1_8 | Mathlib.RingTheory.Ideal.Prime | ∀ {α : Type u_1} [inst : Semiring α] {I : Ideal α} (motive : (∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I) → Prop)
(x : ∃ x, ∃ (_ : x ∉ I), ∃ y, ∃ (_ : y ∉ I), x * y ∈ I),
(∀ (x : α) (hx : x ∉ I) (y : α) (hy : y ∉ I) (hxy : x * y ∈ I), motive ⋯) → motive x | null | false |
CategoryTheory.Abelian.extFunctor._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) {X₁ X₂ : Cᵒᵖ} (f : X₁ ⟶ X₂) {Y₁ Y₂ : C} (g : Y₁ ⟶ Y₂),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Abelian.extFunctorObj (Opposite.unop X₁) n).map g)
(AddCommGr... | null | false |
linter.tacticAnalysis.rwaSuggestion | Mathlib.Tactic.TacticAnalysis.Declarations | Lean.Option Bool | Suggest `rwa` for `rw` followed by `assumption`. | true |
MeasureTheory.Measure.dirac_real_apply_of_mem | Mathlib.MeasureTheory.Measure.Dirac.Def | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set α} {a : α}, a ∈ s → (MeasureTheory.Measure.dirac a).real s = 1 | null | true |
_private.Mathlib.AlgebraicTopology.DoldKan.Faces.0.AlgebraicTopology.DoldKan.HigherFacesVanish.comp_Hσ_eq._proof_1_8 | Mathlib.AlgebraicTopology.DoldKan.Faces | ∀ {a : ℕ} (k : ℕ), a + 2 + k = a + k + 1 + 1 | null | false |
InfTopHom.instMin.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Top α] [inst_2 : SemilatticeInf β] [inst_3 : OrderTop β],
InfTopHom.instMin =
{
min := fun f g =>
have __src := f.toTopHom ⊓ g.toTopHom;
let __SupHom := f.toInfHom ⊓ g.toInfHom;
{ toInfHom := __SupHom, map_top' := ⋯ } } | null | true |
Std.DHashMap.Const.Equiv.beq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [inst : BEq β]
[EquivBEq α] [LawfulHashable α] [ReflBEq β], m₁.Equiv m₂ → Std.DHashMap.Const.beq m₁ m₂ = true | null | true |
Monoid.CoprodI.NeWord.singleton | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{M : ι → Type u_2} → [inst : (i : ι) → Monoid (M i)] → {i : ι} → (x : M i) → x ≠ 1 → Monoid.CoprodI.NeWord M i i | null | true |
EuclideanGeometry.Sphere.isTangentAt_iff_dist_sq_eq_power | Mathlib.Geometry.Euclidean.Sphere.Power | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {P : Type u_2} [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {t p : P} {s : EuclideanGeometry.Sphere P},
t ∈ s → (s.IsTangentAt t line[ℝ, p, t] ↔ dist p t ^ 2 = s.power p) | A line through a point on a sphere is tangent if and only if the squared distance
from the external point to the tangent point equals the power of the point. | true |
CartanMatrix.Realisation.mk_mem_idx | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {n : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype n] [inst_1 : DecidableEq n]
[inst_2 : CommRing R] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : AddCommGroup N] [inst_6 : Module R N]
(rl : CartanMatrix.Realisation n R M N) {w : (M ≃ₗ[R] M) × N ≃ₗ[R] N},
w ∈ rl.weylGroup → ... | null | true |
_private.Mathlib.Algebra.Order.Monoid.Canonical.Basic.0.exists_lt_add_iff_lt_left._simp_1_1 | Mathlib.Algebra.Order.Monoid.Canonical.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α} [inst_1 : Add α] [CanonicallyOrderedAdd α] [AddLeftReflectLT α]
[IsLeftCancelAdd α], (a < b + c) = (a < b ∨ ∃ d < c, a = b + d) | null | false |
Filter.EventuallyEq.gradient | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {x : F} {f₁ : F → 𝕜}, f₁ =ᶠ[nhds x] f → gradient f₁ =ᶠ[nhds x] gradient f | null | true |
FormalMultilinearSeries.rightInv._proof_33 | Mathlib.Analysis.Analytic.Inverse | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | null | false |
spectrum.of_subsingleton | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] [Subsingleton A] (a : A),
spectrum R a = ∅ | null | true |
_private.Lean.Compiler.LCNF.PullFunDecls.0.Lean.Compiler.LCNF.PullFunDecls.attach.match_3 | Lean.Compiler.LCNF.PullFunDecls | (motive : Id (Unit × Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure × Array Bool) → Sort u_1) →
(x : Id (Unit × Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure × Array Bool)) →
((fst : Unit) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → (snd : Array Bool) → motive (fst, k... | null | false |
Finset.subset_image_iff | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {s : Finset α} {t : Finset β} {f : α → β},
t ⊆ Finset.image f s ↔ ∃ s' ⊆ s, Finset.image f s' = t | If a finset `t` is a subset of the image of another finset `s` under `f`, then it is equal to the
image of a subset of `s`.
For the version where `s` is a set, see `subset_set_image_iff`.
| true |
LinearEquiv.ofFinrankEq.congr_simp | Mathlib.RingTheory.LinearDisjoint | ∀ {R : Type u} (M : Type v) (M' : Type v') [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [inst_4 : AddCommMonoid M'] [inst_5 : Module R M'] [inst_6 : Module.Free R M']
[inst_7 : StrongRankCondition R] [inst_8 : Module.Finite R M] [inst_9 : Module.Finite R M']
(con... | null | true |
Array.getElem?_setIfInBounds_self | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {a : α}, (xs.setIfInBounds i a)[i]? = if i < xs.size then some a else none | null | true |
_private.Std.Data.ByteSlice.0.ByteSlice.size_le_size_byteArray._simp_1_4 | Std.Data.ByteSlice | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
RestrictedProduct.instCommGroupCoeOfSubgroupClass._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_3} (R : ι → Type u_2) {S : ι → Type u_1} [inst : (i : ι) → SetLike (S i) (R i)]
[inst_1 : (i : ι) → CommGroup (R i)] [∀ (i : ι), SubgroupClass (S i) (R i)] (i : ι), MulMemClass (S i) (R i) | null | false |
AlgebraicGeometry.IsOpenImmersion.lift_fac | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [H : AlgebraicGeometry.IsOpenImmersion f]
(H' : Set.range ⇑g ⊆ Set.range ⇑f),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsOpenImmersion.lift f g H') f = g | null | true |
setOf_gauge_lt_eq' | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E},
Absorbent ℝ s → ∀ (a : ℝ), {x | gauge s x < a} = ⋃ r, ⋃ (_ : 0 < r), ⋃ (_ : r < a), r • s | **Alias** of `setOfPred_gauge_lt_eq'`. | true |
CategoryTheory.Limits.Trident.IsLimit.homIso._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C)
(x :
{ h // ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp h (f j₁) = CategoryTheory.CategoryStr... | null | false |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.reverse_balLeft._proof_1_4 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (v : α) (r l' a : RBTree.RBNode α) (x : α) (b : RBTree.RBNode α),
l' = (RBTree.RBNode.node RBTree.RBColor.red a x b).reverse →
∀ (a_1 : RBTree.RBNode α) (x_1 : α) (b_1 : RBTree.RBNode α),
(∀ (a : RBTree.RBNode α) (x : α) (b : RBTree.RBNode α),
l' = RBTree.RBNode.node RBTree.RBColo... | null | false |
Std.DTreeMap.getKeyLED | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → α → α → α | Tries to retrieve the largest key that is less than or equal to the
given key, returning `fallback` if no such key exists.
| true |
Filter.EventuallyEq.iInter | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Sort x} {l : Filter α} [Finite ι] {s t : ι → Set α},
(∀ (i : ι), s i =ᶠ[l] t i) → ⋂ i, s i =ᶠ[l] ⋂ i, t i | **Alias** of `Filter.EventuallyEqSet.iInter`. | true |
IntermediateField.restrictScalars_eq_top_iff._simp_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type u_3}
[inst_3 : Field K] [inst_4 : Algebra K E] [inst_5 : Algebra K F] [inst_6 : IsScalarTower K F E]
{L : IntermediateField F E}, (IntermediateField.restrictScalars K L = ⊤) = (L = ⊤) | null | false |
AddSubmonoid.toSubmonoid_closure | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {A : Type u_4} [inst : AddZeroClass A] (S : Set A),
AddSubmonoid.toSubmonoid (AddSubmonoid.closure S) = Submonoid.closure (⇑Multiplicative.toAdd ⁻¹' S) | null | true |
CategoryTheory.ObjectProperty.epiModSerre | Mathlib.CategoryTheory.Abelian.SerreClass.MorphismProperty | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
(P : CategoryTheory.ObjectProperty C) → [P.IsSerreClass] → CategoryTheory.MorphismProperty C | The class of epimorphisms modulo a Serre class: given a
Serre class `P : ObjectProperty C`, this is the class of morphisms `f`
such that `cokernel f` satisfies `P`. | true |
_private.Lake.Util.Version.0.PSigma.casesOn._arg_pusher | Lake.Util.Version | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
Hypergraph.rec | Mathlib.Combinatorics.Hypergraph.Basic | {α : Type u_4} →
{motive : Hypergraph α → Sort u} →
((vertexSet : Set α) →
(edgeSet : Set (Set α)) →
(subset_vertexSet_of_mem_edgeSet' : ∀ ⦃e : Set α⦄, e ∈ edgeSet → e ⊆ vertexSet) →
motive
{ vertexSet := vertexSet, edgeSet := edgeSet,
subset_vertexSet_o... | null | false |
SelfAdjointDecompose.mk._flat_ctor | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_3} [inst : AddGroup R] [inst_1 : Star R] [inst_2 : PartialOrder R],
(∀ {a : R}, IsSelfAdjoint a → ∃ b c, 0 ≤ b ∧ 0 ≤ c ∧ a = b - c) → SelfAdjointDecompose R | null | false |
PolynomialModule.comp_eval | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Polynomial R)
(q : PolynomialModule R M) (r : R),
(PolynomialModule.eval r) ((PolynomialModule.comp p) q) = (PolynomialModule.eval (Polynomial.eval r p)) q | null | true |
Turing.TM2to1.trStAct | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
[DecidableEq K] →
{k : K} →
Turing.TM1.Stmt (Turing.TM2to1.Γ' K Γ) (Turing.TM2to1.Λ' K Γ Λ σ) σ →
Turing.TM2to1.StAct K Γ σ k → Turing.TM1.Stmt (Turing.TM2to1.Γ' K Γ) (Turing.TM2to1.Λ' K Γ Λ σ... | The program corresponding to state transitions at the end of a stack. Here we start out just
after the top of the stack, and should end just after the new top of the stack. | true |
Cardinal.aleph0_le_mul_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (Cardinal.aleph0 ≤ a ∨ Cardinal.aleph0 ≤ b) | See also `Cardinal.aleph0_le_mul_iff`. | true |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensor._proof_1 | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g),
CategoryTheory.Limits.HasPushout
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.residueFieldCongr ⋯).inv
(AlgebraicGeometry.Scheme.Hom.residueFieldMap f T.x))
(CategoryTheory.... | null | false |
Lake.CheckExists.ctorIdx | Lake.Build.Trace | {i : Type u} → Lake.CheckExists i → ℕ | null | false |
AddSubmonoid.multiples_fg | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : AddMonoid M] (r : M), (AddSubmonoid.multiples r).FG | null | true |
Lean.Meta.Grind.ParentSet.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.ParentSet → Sort u} →
(t : Lean.Meta.Grind.ParentSet) → ((parents : List Lean.Expr) → motive { parents := parents }) → motive t | null | false |
_private.Mathlib.Analysis.Calculus.LocalExtr.Rolle.0.exists_hasDerivAt_eq_zero.match_1_1 | Mathlib.Analysis.Calculus.LocalExtr.Rolle | ∀ {f : ℝ → ℝ} {a b : ℝ} (motive : (∃ c ∈ Set.Ioo a b, IsLocalExtr f c) → Prop) (x : ∃ c ∈ Set.Ioo a b, IsLocalExtr f c),
(∀ (c : ℝ) (cmem : c ∈ Set.Ioo a b) (hc : IsLocalExtr f c), motive ⋯) → motive x | null | false |
Mathlib.Tactic.GCongr.GCongrKey._sizeOf_1 | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrKey → ℕ | null | false |
tensorIteratedFDerivTwo | Mathlib.Analysis.InnerProductSpace.Laplacian | (𝕜 : Type u_1) →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : NormedAddCommGroup F] → [inst_4 : NormedSpace 𝕜 F] → (E → F) → E → TensorProduct 𝕜 E E →ₗ[𝕜] F | Convenience reformulation of the second iterated derivative, as a map from `E` to linear maps
`E ⊗[𝕜] E →ₗ[𝕜] F`.
| true |
String.containsSubstr | Batteries.Data.String.Matcher | String → Substring.Raw → Bool | Returns true iff `pattern` occurs as a substring of `s`.
| true |
retractionOfSectionOfKerSqZero._proof_2 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : Algebra R P], SMulCommClass R P P | null | false |
AddValuation.map_le_sum | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{ι : Type u_6} {s : Finset ι} {f : ι → R} {g : Γ₀}, (∀ i ∈ s, g ≤ v (f i)) → g ≤ v (∑ i ∈ s, f i) | null | true |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.ev_app | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalClosed V] →
... | Given `ℌ : DayConvolutionInternalHom F H`, if we think of `H.obj G`
as the internal hom `[F, G]`, then this is the transformation
corresponding to the component at `G` of the "evaluation" natural morphism
`F ⊛ [F, _] ⟶ 𝟭`. | true |
Filter.subsingleton_bot | Mathlib.Order.Filter.Subsingleton | ∀ {α : Type u_1}, ⊥.Subsingleton | null | true |
CategoryTheory.PrelaxFunctor.map₂_inv_hom_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.PrelaxFunctor B C) {a b : B} {f g : a ⟶ b} (η : f ≅ g) {Z : F.obj a ⟶ F.obj b} (h : F.map g ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map₂ η.inv) (CategoryTheory.CategoryStruct.comp (F.map... | null | true |
RingCat.Colimits.quot_zero | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat),
Quot.mk (⇑(RingCat.Colimits.colimitSetoid F)) RingCat.Colimits.Prequotient.zero = 0 | null | true |
CategoryTheory.Limits.biproduct.isLimitFromSubtype._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) (i : J)
[inst_2 : CategoryTheory.Limits.HasBiproduct f]
[inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)]
(s : CategoryTheory.Limits.For... | null | false |
_private.Mathlib.Algebra.Homology.TotalComplexShift.0.HomologicalComplex₂.totalShift₁XIso._proof_3 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ (x n n' : ℤ), n + x = n' → ∀ (p q : ℤ), p + q = n' → p - x + q = n | null | false |
Int.add_mul_modulus_modEq_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a + b * n ≡ c [ZMOD n] ↔ a ≡ c [ZMOD n] | null | true |
Lean.MonadLog.recOn | Lean.Log | {m : Type → Type} →
{motive : Lean.MonadLog m → Sort u} →
(t : Lean.MonadLog m) →
([toMonadFileMap : Lean.MonadFileMap m] →
(getRef : m Lean.Syntax) →
(getFileName : m String) →
(hasErrors : m Bool) →
(logMessage : Lean.Message → m Unit) →
... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema.0.Polynomial.Chebyshev.abs_eval_T_real_eq_one_iff._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.isUniformInducing_ofLp_aux | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : (i : ι) → PseudoEMetricSpace (β i)]
[inst_2 : Fintype ι], IsUniformInducing WithLp.ofLp | null | true |
CategoryTheory.Bicategory.rec | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
{motive : CategoryTheory.Bicategory B → Sort u_1} →
([toCategoryStruct : CategoryTheory.CategoryStruct.{v, u} B] →
(homCategory : (a b : B) → CategoryTheory.Category.{w, v} (a ⟶ b)) →
(whiskerLeft :
{a b c : B} →
(f : a ⟶ b) →
{g h :... | null | false |
ContinuousLinearMap.norm_iteratedFDerivWithin_comp_left | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (L : F →L[𝕜] G) {f : E → F} {s : Set E}... | null | true |
Std.DTreeMap.Internal.Impl.balanceₘ._proof_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.leaf.size > Std.DTreeMap.Internal.delta * l.size → False | null | false |
Set.PartiallyWellOrderedOn.subsetProdLex | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] {s : Set (Lex (α × β))},
((fun x => (ofLex x).1) '' s).IsPWO → (∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO) → s.IsPWO | null | true |
ProbabilityTheory.IsRatCondKernelCDFAux.integrable | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α × β → ℚ → ℝ}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν →
∀ (a : α) (q : ℚ), MeasureTheory.Integrable (fun c => f (a, c) q) (ν a) | null | true |
HomologicalComplex.pOpcyclesIso | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{ι : Type u_2} →
{c : ComplexShape ι} →
(K : HomologicalComplex C c) →
(i j : ι) → c.prev j = i → K.d i j = 0 → [inst_2 : K.HasHomology j] → K.X j ≅ K.opcycles... | The canonical isomorphism `K.X j ≅ K.opCycles j` when the differential to `j` is zero. | true |
NonUnitalStarSubalgebra.toStarSubalgebra._proof_1 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : StarRing A]
[inst_3 : Algebra R A] (S : NonUnitalStarSubalgebra R A) {a b : A}, a ∈ S.carrier → b ∈ S.carrier → a * b ∈ S.carrier | null | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.hausdorffDist_zero_iff_closure_eq_closure._simp_1_3 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ (x : ENNReal), (x.toReal = 0) = (x = 0 ∨ x = ⊤) | null | false |
List.sum_toFinset | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_5} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] (f : ι → M) {l : List ι},
l.Nodup → l.toFinset.sum f = (List.map f l).sum | null | true |
decidable_of_decidable_of_eq | Init.Core | {p q : Prop} → [Decidable p] → p = q → Decidable q | Transfer a decidability proof across an equality of propositions. | true |
YoungDiagram.exists_notMem_col | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ : YoungDiagram) (j : ℕ), ∃ i, (i, j) ∉ μ.cells | null | true |
ModuleCat.instModuleCarrierMkOfSMul'._proof_2 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] {A : AddCommGrpCat} (φ : R →+* CategoryTheory.End A) (b : ↑(ModuleCat.mkOfSMul' φ)),
1 • b = b | null | false |
Int.gcd_eq_zero_iff | Init.Data.Int.Gcd | ∀ {a b : ℤ}, a.gcd b = 0 ↔ a = 0 ∧ b = 0 | null | true |
IO.Promise.isResolved | Init.System.Promise | {α : Type} → IO.Promise α → BaseIO Bool | Checks whether the promise has already been resolved, i.e. whether access to `result*` will return
immediately.
| true |
Std.CancellationToken.Consumer.normal.injEq | Std.Sync.CancellationToken | ∀ (promise promise_1 : IO.Promise Unit),
(Std.CancellationToken.Consumer.normal promise = Std.CancellationToken.Consumer.normal promise_1) =
(promise = promise_1) | null | true |
Std.ExtTreeSet.isSome_max?_of_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.contains k = true → t.max?.isSome = true | null | true |
Inclusion.IntervalBool.false.sizeOf_spec | Mathlib.Tactic.Inclusion.Core.ToSet | sizeOf Inclusion.IntervalBool.false = 1 | null | true |
Aesop.SimpResult.solved | Aesop.Search.Expansion.Simp | Lean.Meta.Simp.UsedSimps → Aesop.SimpResult | null | true |
Vector.push_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} {size : xs.size = n} (x : α), (xs.push x).size = n + 1 | null | false |
StrictAntiOn.add_const | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] [inst_1 : Preorder α] [inst_2 : Preorder β] {f : β → α} {s : Set β}
[AddRightStrictMono α], StrictAntiOn f s → ∀ (c : α), StrictAntiOn (fun x => f x + c) s | null | true |
ULift.isAddRegular_up._simp_1 | Mathlib.Algebra.Regular.ULift | ∀ {R : Type v} [inst : Add R] {a : R}, IsAddRegular { down := a } = IsAddRegular a | null | false |
_private.Init.Data.String.Iterate.0.String.Slice.RevPosIterator.finitenessRelation._simp_2 | Init.Data.String.Iterate | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
_private.Lean.Compiler.LCNF.ToMono.0.Lean.Compiler.LCNF.LetValue.toMono.match_10 | Lean.Compiler.LCNF.ToMono | (motive : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure) →
(Unit → motive Lean.Compiler.LCNF.LetValue.erased) →
((value : Lean.Compiler.LCNF.LitValue) → motive (Lean.Compiler.LCNF.LetValue.lit value)) →
((decl... | null | false |
lpInftySubalgebra | Mathlib.Analysis.Normed.Lp.lpSpace | (𝕜 : Type u_1) →
{I : Type u_5} →
(B : I → Type u_6) →
[inst : NormedField 𝕜] →
[inst_1 : (i : I) → NormedRing (B i)] →
[inst_2 : (i : I) → NormedAlgebra 𝕜 (B i)] → [∀ (i : I), NormOneClass (B i)] → Subalgebra 𝕜 (PreLp B) | The `𝕜`-subalgebra of elements of `∀ i : α, B i` whose `lp` norm is finite. This is `lp E ∞`,
with extra structure. | true |
AddSubgroup.isAddQuotientCoveringMap | Mathlib.Topology.Covering.Quotient | ∀ {G : Type u_4} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] (S : AddSubgroup G),
IsDiscrete ↑S → IsAddQuotientCoveringMap QuotientAddGroup.mk ↥S.op | null | true |
Std.ExtTreeSet.getLED | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → α → α → α | Tries to retrieve the largest element that is less than or equal to the
given element, returning `fallback` if no such element exists.
| true |
MeasureTheory.integrable_neg_iff | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
{f : α → β}, MeasureTheory.Integrable (-f) μ ↔ MeasureTheory.Integrable f μ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.