name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.Kernel.rnDeriv_pos | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η : ProbabilityTheory.Kernel α γ}
[hαγ : MeasurableSpace.CountableOrCountablyGenerated α γ] [ProbabilityTheory.IsFiniteKernel κ]
[ProbabilityTheory.IsFiniteKernel η] {a : α}, (κ a).AbsolutelyContinuous (η a) → ∀ᵐ (x : γ) ∂κ a, 0 < ... | null | true |
ProbabilityTheory.gaussianPDF | Mathlib.Probability.Distributions.Gaussian.Real | ℝ → NNReal → ℝ → ENNReal | The pdf of a Gaussian distribution on ℝ with mean `μ` and variance `v`. | true |
Pi.nonUnitalNormedRing._proof_1 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NonUnitalNormedRing (R i)]
{x y : (i : ι) → R i}, dist x y = 0 → x = y | null | false |
Subgroup.commutator_eq_self | Mathlib.GroupTheory.IsPerfect | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [hH : Group.IsPerfect ↥H], ⁅H, H⁆ = H | null | true |
FirstOrder.Language.BoundedFormula.equal.elim | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} →
{motive : (a : ℕ) → L.BoundedFormula α a → Sort u_1} →
{a : ℕ} →
(t : L.BoundedFormula α a) →
t.ctorIdx = 1 →
({n : ℕ} → (t₁ t₂ : L.Term (α ⊕ Fin n)) → motive n (FirstOrder.Language.BoundedFormula.equal t₁ t₂)) →
motive ... | null | false |
instAddInt64 | Init.Data.SInt.Basic | Add Int64 | null | true |
ProbabilityTheory.integrable_rpow_abs_of_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω},
0 ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => |X ω| ^ p) μ | If 0 belongs to the interior of the interval `integrableExpSet X μ`,
then `|X| ^ n` is integrable for all nonnegative `p : ℝ`. | true |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.solveSomeLocalFVarIdCnstr?.go._unsafe_rec | Lean.Meta.Match.Match | Lean.Meta.Match.Alt →
List (Lean.Expr × Lean.Expr) → Lean.MetaM (Option (Lean.FVarId × Lean.Expr) × List (Lean.Expr × Lean.Expr)) | null | false |
CategoryTheory.mop_whiskerLeft | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y Z : C} (f : Y ⟶ Z),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).mop =
CategoryTheory.MonoidalCategoryStruct.whiskerRight f.mop { unmop := X } | null | true |
Std.Internal.UV.Signal.cancel | Std.Internal.UV.Signal | Std.Internal.UV.Signal → IO Unit | This function has different behavior depending on the state of the `Signal`:
- If it is initial or finished this is a no-op.
- If it's running then it drops the accept promise and if it's not repeatable it sets
the signal handler to the initial state.
| true |
UInt16.toUInt32_ofNatClamp_of_lt | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < UInt16.size), (UInt16.ofNatClamp n).toUInt32 = UInt32.ofNatLT n ⋯ | null | true |
MvPolynomial.pderiv._proof_1 | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommSemiring R], IsScalarTower R (MvPolynomial σ R) (MvPolynomial σ R) | null | false |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.evalTactic.match_9 | Lean.Elab.Tactic.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive ex | null | false |
List.zipWith_eq_nil_iff | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {l : List α} {l' : List β},
List.zipWith f l l' = [] ↔ l = [] ∨ l' = [] | null | true |
CategoryTheory.Limits.widePushoutShapeOp | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | (J : Type w) →
CategoryTheory.Functor (CategoryTheory.Limits.WidePushoutShape J) (CategoryTheory.Limits.WidePullbackShape J)ᵒᵖ | The obvious functor `WidePushoutShape J ⥤ (WidePullbackShape J)ᵒᵖ` | true |
_private.Init.Data.OfScientific.0.Float.ofScientific._proof_2 | Init.Data.OfScientific | ∀ (m e : ℕ), m < 2 ^ 53 ∧ e ≤ 22 → ¬e < 23 → False | null | false |
PresheafOfModules.presheaf._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R) (X : Cᵒᵖ),
AddCommGrpCat.ofHom
(AddMonoidHom.mk' ⇑(CategoryTheory.ConcreteCategory.hom (M.map (CategoryTheory.CategoryStruct.id X))) ⋯) =
CategoryTheory.CategoryStruct.id ((Cat... | null | false |
CompletelyDistribLattice.MinimalAxioms.mk | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : CompleteLattice α],
(∀ {ι : Type u} {κ : ι → Type u} (f : (a : ι) → κ a → α), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)) →
CompletelyDistribLattice.MinimalAxioms α | null | true |
Lean.instForInMVarIdSetMVarIdOfMonad | Lean.Expr | {m : Type u_1 → Type u_2} → [Monad m] → ForIn m Lean.MVarIdSet Lean.MVarId | null | true |
_private.Mathlib.Order.Sublocale.0.Sublocale.giAux._proof_3 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (S : Sublocale X) (x : ↥S), x ≤ Sublocale.restrictAux✝ S ↑x | null | false |
CategoryTheory.Functor.map_braiding_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
(F : CategoryThe... | null | true |
Lean.Parser.anyOfFn._unsafe_rec | Lean.Parser.Basic | List Lean.Parser.Parser → Lean.Parser.ParserFn | null | false |
Subring.range_snd | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S], (RingHom.snd R S).rangeS = ⊤ | null | true |
Lean.Level.PP.Context.recOn | Lean.Level | {motive : Lean.Level.PP.Context → Sort u} →
(t : Lean.Level.PP.Context) →
((mvars : Bool) → (lIndex? : Lean.LMVarId → Option ℕ) → motive { mvars := mvars, lIndex? := lIndex? }) → motive t | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.loop | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Array Lean.Expr →
List Lean.FVarId →
Lean.Expr →
ℕ → ℕ → List Lean.Meta.RefinedDiscrTree.StackEntry → Lean.MetaM (List Lean.Meta.RefinedDiscrTree.StackEntry) | The main loop of `getStackEntries` | true |
Std.DHashMap.Internal.Raw₀.Const.isEmpty_filter_eq_false_iff | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] {f : α → β → Bool},
(↑m).WF →
((↑(Std.DHashMap.Internal.Raw₀.filter f m)).isEmpty = false ↔
∃ k, ∃ (h : m.contains k = true), f (m.getKey k h) (Std.DHashMap.Intern... | null | true |
Dyadic.toRat_le_toRat_iff._simp_1 | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, (x.toRat ≤ y.toRat) = (x ≤ y) | null | false |
MeasureTheory.Measure.pi_noAtoms | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] (i : ι)
[MeasureTheory.NullSingletonClass (μ i)], MeasureTheory.NullSingletonClass (MeasureTheory.Measure.pi μ) | **Alias** of `MeasureTheory.Measure.pi_nullSingletonClass`.
---
If one of the measures `μ i` has value zero on singeltons, them `Measure.pi µ`
has value zero on singletons. The instance below assumes that all `μ i` have value zero on
singletons. | true |
InnerProductSpace.bounded_harmonic_on_complex_plane_is_constant | Mathlib.Analysis.Complex.Harmonic.Liouville | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (f : ℂ → E),
InnerProductSpace.HarmonicOnNhd f Set.univ → Bornology.IsBounded (Set.range f) → ∀ (z w : ℂ), f z = f w | **Liouville's theorem for harmonic functions on the complex plane** A bounded harmonic function on
the complex plane is constant.
| true |
CategoryTheory.Oplax.OplaxTrans.OplaxFunctor.bicategory | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Oplax | (B : Type u₁) →
[inst : CategoryTheory.Bicategory B] →
(C : Type u₂) → [inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.Bicategory (CategoryTheory.OplaxFunctor B C) | A bicategory structure on the oplax functors between bicategories. | true |
OrderDual.instModule' | Mathlib.Algebra.Order.Module.Synonym | {α : Type u_1} → {β : Type u_2} → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α βᵒᵈ | null | true |
CStarMatrix.instAddCommGroupWithOne._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : DecidableEq n] [inst_1 : AddCommGroupWithOne A],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
CategoryTheory.ShortComplex.Splitting.unop_r | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.Splitting), h.unop.r = h.s.unop | null | true |
Std.ExtTreeMap.maxKey?_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {km : α},
t.maxKey? = some km → km ∈ t | null | true |
instance_wanted | Batteries.Util.ProofWanted | Lean.Parser.Parser | This typeclass instance would be a welcome contribution to the library!
The syntax mirrors `instance` (the name is optional, auto-generated from the class head if
absent) and the payload must be a typeclass. The placeholder is recorded as
`DefWanted (TheClass …)` like `def_wanted`, but additionally the declared name i... | true |
DiscreteConvolution.ringConvolution._proof_1 | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R], SMulCommClass ℕ R R | null | false |
Lean.Doc.Syntax.metadataContents | Lean.DocString.Syntax | Lean.Parser.Parser | null | true |
Monoid.exponent_multiplicative | Mathlib.GroupTheory.Exponent | ∀ {G : Type u_1} [inst : AddMonoid G], Monoid.exponent (Multiplicative G) = AddMonoid.exponent G | null | true |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atTop_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g | null | false |
Array.forall_mem_ne' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (∀ a' ∈ xs, ¬a' = a) ↔ a ∉ xs | null | true |
Std.HashMap.keys | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List α | Returns a list of all keys present in the hash map in some order. | true |
Std.Net.IPAddr.family.match_1 | Std.Net.Addr | (motive : Std.Net.IPAddr → Sort u_1) →
(x : Std.Net.IPAddr) →
((addr : Std.Net.IPv4Addr) → motive (Std.Net.IPAddr.v4 addr)) →
((addr : Std.Net.IPv6Addr) → motive (Std.Net.IPAddr.v6 addr)) → motive x | null | false |
DirichletCharacter.convolution_twist_vonMangoldt | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N),
(LSeries.convolution ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) fun n => χ ↑n) =
(fun n => χ ↑n) * fun n => Complex.log ↑n | A twisted version of the relation `Λ * ↑ζ = log` in terms of complex sequences. | true |
Lean.Language.Lean.HeaderParsedSnapshot.mk | Lean.Language.Lean.Types | Lean.Language.Snapshot →
Lean.Language.SnapshotTask Lean.Language.SnapshotLeaf →
Lean.Parser.InputContext →
Lean.Syntax → Option Lean.Language.Lean.HeaderParsedState → Lean.Language.Lean.HeaderParsedSnapshot | null | true |
LocallyFinite.Realizer.recOn | Mathlib.Data.Analysis.Topology | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
{F : Ctop.Realizer α} →
{f : β → Set α} →
{motive : LocallyFinite.Realizer F f → Sort u} →
(t : LocallyFinite.Realizer F f) →
((bas : (a : α) → { s // a ∈ F.F.f s }) →
(sets : (x : α... | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Tactic.open._regBuiltin.Lean.Parser.Tactic.open.parenthesizer_13 | Lean.Parser.Command | IO Unit | null | false |
AlgebraicGeometry.structurePresheafInModuleCat | Mathlib.AlgebraicGeometry.StructureSheaf | (R M : Type u) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [Module R M] → TopCat.Presheaf (ModuleCat R) (AlgebraicGeometry.PrimeSpectrum.Top R) | The structure presheaf, valued in `ModuleCat`, constructed by dressing up the `Type`-valued
structure presheaf. | true |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'.match_1_11 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {R : Type u_2} {S : Type u_1} [inst : Ring R] [inst_1 : StarMul R] [inst_2 : CommRing S] [inst_3 : Algebra S R]
(u v : ↥(unitary R)) (motive : (∃ y, y • 1 = star ↑v * ↑u) → Prop) (x : ∃ y, y • 1 = star ↑v * ↑u),
(∀ (y : S) (h : y • 1 = star ↑v * ↑u), motive ⋯) → motive x | null | false |
Monoid.CoprodI.Word.equivPair._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] (i : ι) (w : Monoid.CoprodI.Word M),
Monoid.CoprodI.Word.rcons ↑(Monoid.CoprodI.Word.equivPairAux✝ i w) = w | null | false |
Inclusion._aux_Mathlib_Tactic_Inclusion_Core_Elab___elabRules_Inclusion_inclusion?_1 | Mathlib.Tactic.Inclusion.Core.Elab | Lean.Elab.Tactic.Tactic | `inclusion? [fam₁, ...]` is a proof writing aid that quickly checks if
`inclusion [fam₁, ...]` would close the goal, without doing the expensive kernel computation that
actually closes the goal. | false |
CategoryTheory.Bicategory.rightUnitorNatIsoCat_hom_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (a b : B) (X : a ⟶ b),
(CategoryTheory.Bicategory.rightUnitorNatIsoCat a b).hom.toNatTrans.app X =
(CategoryTheory.Bicategory.rightUnitor X).hom | null | true |
Lean.Lsp.ShowMessageParams.mk._flat_ctor | Lean.Data.Lsp.Window | Lean.Lsp.MessageType → String → Lean.Lsp.ShowMessageParams | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.iteratedDerivWithin_tsum_exp_aux_eq._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) | null | false |
_private.Mathlib.Logic.Relation.0.Relation.map_map._proof_1_1 | Mathlib.Logic.Relation | ∀ {α : Type u_5} {β : Type u_6} {γ : Type u_3} {δ : Type u_4} {ε : Type u_1} {ζ : Type u_2} (r : α → β → Prop)
(f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ),
Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) | null | false |
Configuration.Nondegenerate.exists_line | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.Nondegenerate P L] (p : P), ∃ l, p ∉ l | null | true |
ContMDiffMap.restrictMonoidHom._proof_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_3}
[inst_5 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {H' : Type u_6} [inst_6 : Topologi... | null | false |
mellinConvergent_of_isBigO_rpow_exp | Mathlib.Analysis.MellinTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ},
0 < a →
∀ {f : ℝ → E} {s : ℂ},
MeasureTheory.LocallyIntegrableOn f (Set.Ioi 0) MeasureTheory.volume →
(f =O[Filter.atTop] fun t => Real.exp (-a * t)) →
(f =O[nhdsWithin 0 (Set.Ioi 0)] fun x => x ^ (-b)) → ... | If `f` is locally integrable, decays exponentially at infinity, and is `O(x ^ (-b))` at 0, then
its Mellin transform converges for `b < s.re`. | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.w_spec | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ),
FermatLastTheoremForThreeGen.Solution'.c✝ (FermatLastTheoremForThreeGen.Solution.toSolution'✝ S) =
(hζ.toInteger - 1) ^ FermatLastTheoremForThreeGen.Solution.multiplicity✝ S *
FermatLastTheo... | null | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.Consumer.ctorIdx | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded.Consumer✝ α → ℕ | null | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.casesExpand.match_19 | Batteries.CodeAction.Misc | (motive : Option (Array (Lean.Name × Array Lean.Name)) → Sort u_1) →
(__x : Option (Array (Lean.Name × Array Lean.Name))) →
((ctors : Array (Lean.Name × Array Lean.Name)) → motive (some ctors)) →
((x : Option (Array (Lean.Name × Array Lean.Name))) → motive x) → motive __x | null | false |
AddAction.stabilizerEquivStabilizer_trans | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h k : G} {a b c : α} (hg : b = g +ᵥ a)
(hh : c = h +ᵥ b) (hk : c = k +ᵥ a),
k = h + g →
(AddAction.stabilizerEquivStabilizer hg).trans (AddAction.stabilizerEquivStabilizer hh) =
AddAction.stabilizerEquivStabilizer hk | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.SetIntegral.0.MeasureTheory.VectorMeasure.Integrable.tendsto_setIntegral_nhds_zero._simp_1_3 | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {α : Type u_2} {f : Filter α} {m : α → NNReal} {x : NNReal},
Filter.Tendsto (fun a => ↑(m a)) f (nhds ↑x) = Filter.Tendsto m f (nhds x) | null | false |
Lean.Meta.Grind.SymbolPriorityEntry.mk.noConfusion | Lean.Meta.Tactic.Grind.EMatchTheorem | {P : Sort u} →
{declName : Lean.Name} →
{prio : ℕ} →
{declName' : Lean.Name} →
{prio' : ℕ} →
{ declName := declName, prio := prio } = { declName := declName', prio := prio' } →
(declName = declName' → prio = prio' → P) → P | null | false |
BoundedOrderHomClass.toBotHomClass | Mathlib.Order.Hom.Bounded | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : LE α] [inst_2 : LE β]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [BoundedOrderHomClass F α β], BotHomClass F α β | null | true |
SSet.Edge.InvStruct.map._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X Y : SSet} {x₀ : X.obj (Opposite.op { len := 0 })} (f : X ⟶ Y),
((SSet.Edge.id x₀).map f).edge =
(SSet.Edge.id ((CategoryTheory.ConcreteCategory.hom (f.app (Opposite.op { len := 0 }))) x₀)).edge | null | false |
_private.Mathlib.Topology.UniformSpace.Defs.0.UniformSpace.hasBasis_nhds._simp_1_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Std.Iterators.Types.Zip.instFinite₂ | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type w → Type w'} {α₁ β₁ : Type w} [inst : Std.Iterator α₁ m β₁] {α₂ β₂ : Type w} [inst_1 : Std.Iterator α₂ m β₂]
[inst_2 : Monad m] [Std.Iterators.Productive α₁ m] [Std.Iterators.Finite α₂ m],
Std.Iterators.Finite (Std.Iterators.Types.Zip α₁ m α₂ β₂) m | null | true |
Std.TransCmp.lt_of_eq_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.lt → cmp a c = Ordering.lt | null | true |
List.insert_of_not_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, a ∉ l → List.insert a l = a :: l | null | true |
Real.denselyNormedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (x x_1 : ℝ), 0 ≤ x → x < x_1 → ∃ a, x < ‖a‖ ∧ ‖a‖ < x_1 | null | false |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.pendingConsumer | Std.Http.Data.Body.Stream | Std.Http.Body.Channel.State✝ → Option Std.Http.Body.Channel.Consumer✝ | A single blocked consumer waiting for a producer.
| true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.at_least_as_long_as_coind._simp_1_8 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s : Stream'.Seq α), (s = Stream'.Seq.nil) = (s.length' = 0) | null | false |
StrictMonoOn.mapsTo_Ioc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : PartialOrder α] [inst_1 : Preorder β] {a b : α},
StrictMonoOn f (Set.Icc a b) → Set.MapsTo f (Set.Ioc a b) (Set.Ioc (f a) (f b)) | null | true |
_private.Init.Data.String.Iterate.0.String.Slice.ByteIterator.finitenessRelation._proof_2 | Init.Data.String.Iterate | ∀ {m : Type → Type u_1},
WellFounded
(InvImage WellFoundedRelation.rel fun it => it.internalState.s.utf8ByteSize - it.internalState.offset.byteIdx) | null | false |
Std.Time.Week.OfYear.instDecidableLeOrdinal | Std.Time.Date.Unit.Week | {x y : Std.Time.Week.OfYear.Ordinal} → Decidable (x ≤ y) | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKeyD k fallback = fallback | null | true |
AddSubgroup.card_dvd_of_injective | Mathlib.GroupTheory.Coset.Card | ∀ {α : Type u_1} [inst : AddGroup α] {H : Type u_2} [inst_1 : AddGroup H] (f : α →+ H),
Function.Injective ⇑f → Nat.card α ∣ Nat.card H | null | true |
OrderHom.apply | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → α → (α →o β) →o β | Function application `fun f => f a` (for fixed `a`) is a monotone function from the
monotone function space `α →o β` to `β`. See also `Pi.evalOrderHom`. | true |
Manifold.«_aux_Mathlib_Geometry_Manifold_Instances_Real___macroRules_Manifold_term𝓡∂__1» | Mathlib.Geometry.Manifold.Instances.Real | Lean.Macro | null | false |
CompleteDistribLattice.toHNot | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} → [self : CompleteDistribLattice α] → HNot α | null | true |
MeasurableEquiv.piFinSuccAbove_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_8) [inst : (i : Fin (n + 1)) → MeasurableSpace (α i)] (i : Fin (n + 1)),
⇑(MeasurableEquiv.piFinSuccAbove α i) = ⇑(Fin.insertNthEquiv α i).symm | null | true |
LieAlgebra.radical_eq_top_of_isSolvable | Mathlib.Algebra.Lie.Solvable | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[LieAlgebra.IsSolvable L], LieAlgebra.radical R L = ⊤ | null | true |
String.all_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (p : Char → Bool), String.Legacy.all s p = true ↔ ∀ c ∈ s.toList, p c = true | null | true |
Substring.Raw.toString | Init.Data.String.Substring | Substring.Raw → String | {}
Copies the region of the underlying string pointed to by a substring into a fresh string.
| true |
Lean.Parser.antiquotExpr | Lean.Parser.Basic | Lean.Parser.Parser | null | true |
ZFSet.vonNeumann_subset_vonNeumann_iff | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, ZFSet.vonNeumann a ⊆ ZFSet.vonNeumann b ↔ a ≤ b | null | true |
Finpartition.ofSubset._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a) {parts : Finset α},
parts ⊆ P.parts → ⊥ ∈ parts → False | null | false |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.asymptoticCone_union._simp_1_2 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] {v : V} {s : Set P},
(v ∈ asymptoticCone k s) = ∃ᶠ (p : P) in AffineSpace.asymptoticNhds k P v, p ∈ s | null | false |
Finsupp.instNonUnitalRing._proof_4 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalRing β] (g₁ g₂ : α →₀ β), ⇑(g₁ * g₂) = ⇑g₁ * ⇑g₂ | null | false |
KaehlerDifferential.map_D | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A : Type u_2)
(B : Type u_3) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra A B]
[inst_7 : Algebra S B] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTower R... | null | true |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.Module.Basis.parallelepiped._simp_5 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
Option.toArray_eq_empty_iff._simp_1 | Init.Data.Option.Array | ∀ {α : Type u_1} {o : Option α}, (o.toArray = #[]) = (o = none) | null | false |
_private.Lean.Meta.InferType.0.Lean.Meta.typeFormerTypeLevel.go.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((l : Lean.Level) → motive (Lean.Expr.sort l)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((x : Lean.Ex... | null | false |
CategoryTheory.MorphismProperty.exists_isPushout_of_isFiltered | Mathlib.CategoryTheory.MorphismProperty.Ind | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.MorphismProperty C}
[self : P.PreIndSpreads] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J]
{D : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone D} (x : CategoryTheory.Limits.IsColimit c)... | **Alias** of `CategoryTheory.MorphismProperty.PreIndSpreads.exists_isPushout`. | true |
PseudoMetricSpace.ofDistTopology._proof_3 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} [inst : TopologicalSpace α] (dist : α → α → ℝ) (dist_self : ∀ (x : α), dist x x = 0)
(dist_comm : ∀ (x y : α), dist x y = dist y x) (dist_triangle : ∀ (x y z : α), dist x z ≤ dist x y + dist y z)
(H : ∀ (s : Set α), IsOpen s ↔ ∀ x ∈ s, ∃ ε > 0, ∀ (y : α), dist x y < ε → y ∈ s), uniformity α = unifo... | null | false |
Stream'.Seq.set_cons_zero | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (hd' : α), (Stream'.Seq.cons hd tl).set 0 hd' = Stream'.Seq.cons hd' tl | null | true |
Int8.neg_sub | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, -(a - b) = b - a | null | true |
Matroid.loopyOn_isBasis_iff._simp_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, (Matroid.loopyOn E).IsBasis I X = (I = ∅ ∧ X ⊆ E) | null | false |
CategoryTheory.NatTrans.IsMonoidal.instHomFunctorAssociator | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E] {... | null | true |
AlgebraicGeometry.Scheme.Pullback.base_affine_hasPullback | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {C : CommRingCat} {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ AlgebraicGeometry.Spec C)
(g : Y ⟶ AlgebraicGeometry.Spec C), CategoryTheory.Limits.HasPullback f g | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.