name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Filter.EventuallyLE.measure_le | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, s ≤ᵐ[μ] t → μ s ≤ μ t | **Alias** of `Filter.EventuallySubset.measure_le`.
---
**Alias** of `MeasureTheory.measure_mono_ae`.
---
If `s ⊆ t` modulo a set of measure `0`, then `μ s ≤ μ t`. | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.mk.sizeOf_spec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | ∀ (f fType : Lean.Expr) (args mvars : Array Lean.Expr) (bInfos : Array Lean.BinderInfo) (forceRegularApp : Bool),
sizeOf
{ f := f, fType := fType, args := args, mvars := mvars, bInfos := bInfos, forceRegularApp := forceRegularApp } =
1 + sizeOf f + sizeOf fType + sizeOf args + sizeOf mvars + sizeOf bInfos +... | null | true |
Padic.coe_one | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)], ↑1 = 1 | null | true |
LocallyConstant.comapRingHom._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_1}
[inst_2 : Semiring Z] (f : C(X, Y)), (↑(LocallyConstant.comapAddMonoidHom f)).toFun 0 = 0 | null | false |
AlgebraicGeometry.Scheme.LocalRepresentability.yonedaGluedToSheaf_app_toGlued | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u)} {ι : Type u}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.obj}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) {i : ι},
(CategoryTheory.ConcreteCategory.hom
((Algebrai... | null | true |
fderivPolarCoordSymm._proof_8 | Mathlib.Analysis.SpecialFunctions.PolarCoord | Module.Finite ℝ (ℝ × ℝ) | null | false |
RingEquiv.nonUnitalSubringCongr | Mathlib.RingTheory.NonUnitalSubring.Basic | {R : Type u} → [inst : NonUnitalRing R] → {s t : NonUnitalSubring R} → s = t → ↥s ≃+* ↥t | Makes the identity isomorphism from a proof two `NonUnitalSubring`s of a multiplicative
monoid are equal. | true |
UniqueFactorizationMonoid.radical_mul | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a b : M},
IsRelPrime a b →
UniqueFactorizationMonoid.radical (a * b) =
UniqueFactorizationMonoid.radical a * UniqueFactorizationMonoid.radical b | Radical is multiplicative for relatively prime elements. | true |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe.eq_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X) (hs : Nonempty ↥s),
s.openPartialHomeomorphSubtypeCoe hs = Topology.IsOpenEmbedding.toOpenPartialHomeomorph Subtype.val ⋯ | null | true |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_10 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) | null | false |
Lean.PrettyPrinter.Delaborator.OmissionReason.noConfusionType | Lean.PrettyPrinter.Delaborator.Basic | Sort u → Lean.PrettyPrinter.Delaborator.OmissionReason → Lean.PrettyPrinter.Delaborator.OmissionReason → Sort u | null | false |
FinsetFamily._aux_Mathlib_Combinatorics_SetFamily_Compression_UV___unexpand_UV_compression_1 | Mathlib.Combinatorics.SetFamily.Compression.UV | Lean.PrettyPrinter.Unexpander | null | false |
Std.ExtDTreeMap.Const.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
{l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
k ∉ t →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l →
k ∈ l → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKeyD k' ... | null | true |
RatFunc.instAlgebraOfPolynomial | Mathlib.FieldTheory.RatFunc.Basic | (K : Type u) →
[inst : CommRing K] →
[inst_1 : IsDomain K] →
(R : Type u_1) → [inst_2 : CommSemiring R] → [Algebra R (Polynomial K)] → Algebra R (RatFunc K) | null | true |
CategoryTheory.ShortComplex.hasLeftHomology_of_epi_of_isIso_of_mono' | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [S₂.HasLeftHomology] [CategoryTheory.Epi φ.τ₁]
[CategoryTheory.IsIso φ.τ₂] [CategoryTheory.Mono φ.τ₃], S₁.HasLeftHomology | null | true |
CategoryTheory.Limits.BinaryBicone.ofLimitCone._proof_6 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.BinaryFan.IsLimit.lift ht 0 (Cate... | null | false |
_private.Mathlib.LinearAlgebra.Transvection.Generation.0.LinearEquiv.exists_dual_of_fixedReduce_ne_smul._simp_1_3 | Mathlib.LinearAlgebra.Transvection.Generation | ∀ {α : Type u_9} {β : Type u_10} {inst : Semigroup α} [self : SemigroupAction α β] (x y : α) (b : β),
x • y • b = (x * y) • b | null | false |
AddAction.prodOfVAddCommClass.eq_1 | Mathlib.Algebra.Group.Action.Prod | ∀ (M : Type u_1) (N : Type u_2) (α : Type u_4) [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddAction M α]
[inst_3 : AddAction N α] [inst_4 : VAddCommClass M N α],
AddAction.prodOfVAddCommClass M N α = { vadd := fun mn a => mn.1 +ᵥ mn.2 +ᵥ a, add_vadd := ⋯, zero_vadd := ⋯ } | null | true |
Finpartition.empty._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ (α : Type u_1) [inst : Lattice α] [inst_1 : OrderBot α], ∅.SupIndep id | null | false |
IsFractionRing.ringEquivOfRingEquiv_algebraMap | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_8} {K : Type u_9} {B : Type u_10} {L : Type u_11} [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : CommRing K] [inst_3 : CommRing L] [inst_4 : Algebra A K] [inst_5 : IsFractionRing A K]
[inst_6 : Algebra B L] [inst_7 : IsFractionRing B L] (h : A ≃+* B) (a : A),
(IsFractionRing.ringEquivOfRingEqui... | null | true |
Matrix.nonAssocSemiring | Mathlib.Data.Matrix.Mul | {n : Type u_3} → {α : Type v} → [NonAssocSemiring α] → [Fintype n] → [DecidableEq n] → NonAssocSemiring (Matrix n n α) | null | true |
Mathlib.Tactic.Ring.ExProd.evalIntCast._f | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{v : Lean.Level} →
{β : Q(Type v)} →
(sβ : Q(CommSemiring «$β»)) →
(rα : Q(CommRing «$α»)) →
{a : Q(ℤ)} →
(va : Mathlib.Tactic.Ring.ExProd sβ a) →
Mathlib.Tactic.R... | null | false |
_private.Mathlib.Topology.Semicontinuity.Basic.0.upperSemiContinuous_inv_iff._simp_1_1 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β},
UpperSemicontinuous f = UpperSemicontinuousOn f Set.univ | null | false |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_nhds._simp_1_4 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b : Prop}, (¬a → b) = (¬b → a) | null | false |
Lean.Lsp.instToJsonCompletionClientCapabilities.toJson | Lean.Data.Lsp.Capabilities | Lean.Lsp.CompletionClientCapabilities → Lean.Json | null | true |
measurableSet_le' | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] {mα : MeasurableSpace α} [OpensMeasurableSpace α] [inst_2 : PartialOrder α]
[OrderClosedTopology α] [SecondCountableTopology α], MeasurableSet {p | p.1 ≤ p.2} | null | true |
Std.TreeMap.Raw.Equiv.getElem_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp] {k : α}
{hk : k ∈ t₁} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂), t₁[k] = t₂[k] | null | true |
CategoryTheory.SmallObject.functorMapSrc._proof_1 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I → C} (f : (i : I) → A i ⟶ B i)
{S T X Y : C} {πX : X ⟶ S} {πY : Y ⟶ T} (τ : CategoryTheory.Arrow.mk πX ⟶ CategoryTheory.Arrow.mk πY)
(x : CategoryTheory.SmallObject.FunctorObjIndex f πX),
CategoryTheory.CategoryStruct.comp (Cat... | null | false |
dif_eq_if | Init.ByCases | ∀ (c : Prop) {h : Decidable c} {α : Sort u} (t e : α), (if x : c then t else e) = if c then t else e | null | true |
List.forall_getElem | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {p : α → Prop}, (∀ (i : ℕ) (h : i < l.length), p l[i]) ↔ ∀ a ∈ l, p a | null | true |
AlgebraicGeometry.Etale.instFormallyUnramified | Mathlib.AlgebraicGeometry.Morphisms.Etale | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.Etale f], AlgebraicGeometry.FormallyUnramified f | null | true |
Std.HashSet.Raw.get?_union | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∪ m₂).get? k = (m₂.get? k).or (m₁.get? k) | null | true |
List.mkSlice_ric_eq_mkSlice_rio | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {hi : ℕ}, Std.Ric.Sliceable.mkSlice xs *...=hi = Std.Rio.Sliceable.mkSlice xs *...hi + 1 | null | true |
AddCommGrpCat.Hom.hom.eq_1 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddCommGrpCat} (f : X.Hom Y), f.hom = CategoryTheory.ConcreteCategory.hom f | null | true |
Lean.Data.AC.EvalInformation.arbitrary | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β | null | true |
_private.Init.PropLemmas.0.and_right_comm.match_1_1 | Init.PropLemmas | ∀ {a b c : Prop} (motive : (a ∧ b) ∧ c → Prop) (x : (a ∧ b) ∧ c), (∀ (ha : a) (hb : b) (hc : c), motive ⋯) → motive x | null | false |
CommRingCat.Colimits.Prequotient.recOn | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J CommRingCat} →
{motive : CommRingCat.Colimits.Prequotient F → Sort u} →
(t : CommRingCat.Colimits.Prequotient F) →
((j : J) → (x : ↑(F.obj j)) → motive (CommRingCat.Colimits.Prequotient.of j x)) →
... | null | false |
MonoidAlgebra.comapDistribMulActionSelf._proof_4 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {S : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Semiring S] (this : DistribMulAction G (G →₀ S)) (a : G)
(x y : MonoidAlgebra S G), a • (x + y) = a • x + a • y | null | false |
ZNum.zero.sizeOf_spec | Mathlib.Data.Num.Basic | sizeOf ZNum.zero = 1 | null | true |
Filter.Germ.instAddMonoidWithOne._proof_4 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {l : Filter α} {M : Type u_1} [inst : AddMonoidWithOne M] (x : ℕ), ↑↑(x + 1) = ↑fun x_1 => ↑x x_1 + 1 | null | false |
Polynomial.smul_divByMonic | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} [inst : CommRing R] {q : Polynomial R} (c : R) (p : Polynomial R), c • p /ₘ q = c • (p /ₘ q) | null | true |
Pi.borelSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {ι : Type u_6} {X : ι → Type u_7} [Countable ι] [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → MeasurableSpace (X i)] [∀ (i : ι), SecondCountableTopology (X i)] [∀ (i : ι), BorelSpace (X i)],
BorelSpace ((i : ι) → X i) | null | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Basic.0.IntermediateField.exists_finset_of_mem_adjoin._simp_1_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] (s : Set β) (f : β → α), ⨆ t ∈ s, f t = ⨆ i, f ↑i | null | false |
ENorm | Mathlib.Analysis.Normed.Group.Defs | Type u_4 → Type u_4 | Auxiliary class, endowing a type `α` with a function `enorm : α → ℝ≥0∞` with notation `‖x‖ₑ`. | true |
MvPowerSeries.hasSum_eval₂ | Mathlib.RingTheory.MvPowerSeries.Evaluation | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : UniformSpace R] {S : Type u_3} [inst_2 : CommRing S]
[inst_3 : UniformSpace S] {φ : R →+* S} {a : σ → S} [IsTopologicalSemiring R] [IsUniformAddGroup R]
[IsUniformAddGroup S] [CompleteSpace S] [T2Space S] [IsTopologicalRing S] [IsLinearTopology S S],
C... | null | true |
Lean.Meta.InductionSubgoal.mk | Lean.Meta.Tactic.Induction | Lean.MVarId → Array Lean.Expr → Lean.Meta.FVarSubst → Lean.Meta.InductionSubgoal | null | true |
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.evalCodeActionProviderUnsafe | Lean.Server.CodeActions.Basic | {M : Type → Type} →
[Lean.MonadEnv M] →
[Lean.MonadOptions M] → [Lean.MonadError M] → [Monad M] → Lean.Name → M Lean.Server.CodeActionProvider | null | true |
_private.Init.Data.Range.Polymorphic.Iterators.0.Std.Rio.Internal.isPlausibleIndirectOutput_iter_iff._simp_1_1 | Init.Data.Range.Polymorphic.Iterators | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b | null | false |
Subalgebra.LinearDisjoint.rank_inf_eq_one_of_commute_of_flat_right_of_inj | Mathlib.RingTheory.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {A B : Subalgebra R S},
A.LinearDisjoint B →
∀ [Module.Flat R ↥B],
(∀ (a b : ↥(A ⊓ B)), Commute ↑a ↑b) → Function.Injective ⇑(algebraMap R S) → Module.rank R ↥(A ⊓ B) = 1 | null | true |
Subalgebra.toSubmoduleEquiv | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Algebra R A] → (S : Subalgebra R A) → ↥(Subalgebra.toSubmodule S) ≃ₗ[R] ↥S | Linear equivalence between `S : Submodule R A` and `S`. Though these types are equal,
we define it as a `LinearEquiv` to avoid type equalities. | true |
ENat.coe_sSup | Mathlib.Data.ENat.Lattice | ∀ {s : Set ℕ}, BddAbove s → ↑(sSup s) = ⨆ a ∈ s, ↑a | **Alias** of `ENat.natCast_sSup`. | true |
_private.Aesop.Util.UnorderedArraySet.0.Aesop.UnorderedArraySet.mk.inj | Aesop.Util.UnorderedArraySet | ∀ {α : Type u_1} {inst : BEq α} {rep rep_1 : Array α}, { rep := rep } = { rep := rep_1 } → rep = rep_1 | null | true |
StandardEtalePresentation._sizeOf_inst | Mathlib.RingTheory.Etale.StandardEtale | (R : Type u_4) →
(S : Type u_5) →
{inst : CommRing R} →
{inst_1 : CommRing S} → {inst_2 : Algebra R S} → [SizeOf R] → [SizeOf S] → SizeOf (StandardEtalePresentation R S) | null | false |
List.findFinIdx?_eq_bind_find?_finIdxOf? | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs : List α} {p : α → Bool},
List.findFinIdx? p xs = (List.find? p xs).bind fun a => List.finIdxOf? a xs | null | true |
Equiv.Perm.extendDomain_apply_subtype | Mathlib.Logic.Equiv.Basic | ∀ {α' : Type u_8} {β' : Type u_9} (e : Equiv.Perm α') {p : β' → Prop} [inst : DecidablePred p] (f : α' ≃ Subtype p)
{b : β'} (h : p b), (e.extendDomain f) b = ↑(f (e (f.symm ⟨b, h⟩))) | null | true |
Nat.ModEq.add_iff_left._simp_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b c d : ℕ}, a ≡ b [MOD n] → (a + c ≡ b + d [MOD n]) = (c ≡ d [MOD n]) | null | false |
Int8.toInt32_neg_of_ne | Init.Data.SInt.Lemmas | ∀ {x : Int8}, x ≠ -128 → (-x).toInt32 = -x.toInt32 | null | true |
Ideal.mem_prod | Mathlib.RingTheory.Ideal.Prod | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (I : Ideal R) (J : Ideal S) {x : R × S},
x ∈ I.prod J ↔ x.1 ∈ I ∧ x.2 ∈ J | null | true |
MeasurableEquiv.coe_mulLeft | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableMul G] (g : G),
⇑(MeasurableEquiv.mulLeft g) = fun x => g * x | null | true |
MeasureTheory.toOuterMeasure_eq_inducedOuterMeasure | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α},
μ.toOuterMeasure = MeasureTheory.inducedOuterMeasure (fun s x => μ s) ⋯ ⋯ | null | true |
ProofWidgets.Penrose.DiagramBuilderM.addEmbed | ProofWidgets.Component.PenroseDiagram | String → String → ProofWidgets.Html → ProofWidgets.Penrose.DiagramBuilderM Unit | Add an object `nm` of Penrose type `tp`,
labelled by `h`, to the substance program. | true |
String.Pos.Raw.Valid.mk | Batteries.Data.String.Lemmas | ∀ (cs cs' : List Char) {p : String.Pos.Raw},
p.byteIdx = String.utf8Len cs → String.Pos.Raw.Valid (String.ofList (cs ++ cs')) p | A string position is valid if it is equal to the UTF-8 length of an initial substring of `s`.
| true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.lintegral_withDensity_eq_lintegral_mul₀'._simp_1_2 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.Cartan.0.ValueDistribution.eventuallyEq_log_trailingCoeff_of_meromorphicOrderAt_eq_zero | Mathlib.Analysis.Complex.ValueDistribution.Cartan | ∀ {f : ℂ → ℂ},
MeromorphicAt f 0 →
meromorphicOrderAt f 0 = 0 →
(fun x => Real.log ‖meromorphicTrailingCoeffAt f 0 - x‖) =ᶠ[Filter.codiscreteWithin (Metric.sphere 0 |1|)]
fun a => Real.log ‖meromorphicTrailingCoeffAt (fun x => f x - a) 0‖ | null | true |
ProbabilityTheory.condVar_of_sigmaFinite | Mathlib.Probability.CondVar | ∀ {Ω : Type u_1} {m₀ m : MeasurableSpace Ω} {hm : m ≤ m₀} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω}
[inst : MeasureTheory.SigmaFinite (μ.trim hm)],
ProbabilityTheory.condVar m X μ =
if MeasureTheory.Integrable (fun ω => (X ω - μ[X | m] ω) ^ 2) μ then
if MeasureTheory.StronglyMeasurable fun ω => (X ω - μ[X... | null | true |
Std.DTreeMap.Internal.Impl.foldrM.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type u_1} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(init : δ), Std.DTreeMap.Internal.Impl.foldrM f init Std.DTreeMap.Internal.Impl.leaf = pure init | null | true |
OrderDual.instLocallyFiniteOrderTop | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrderBot α] → LocallyFiniteOrderTop αᵒᵈ | Note we define `Ici (toDual a)` as `Iic a` (which has type `Finset α` not `Finset αᵒᵈ`!)
instead of `(Iic a).map toDual.toEmbedding` as this means the following is defeq:
```
lemma this : (Ici (toDual (toDual a)) :) = (Ici a :) := rfl
```
| true |
ContractingWith.edist_efixedPoint_lt_top | Mathlib.Topology.MetricSpace.Contracting | ∀ {α : Type u_1} [inst : EMetricSpace α] {K : NNReal} {f : α → α} [inst_1 : CompleteSpace α] (hf : ContractingWith K f)
{x : α} (hx : edist x (f x) ≠ ⊤), edist x (ContractingWith.efixedPoint f hf x hx) < ⊤ | null | true |
CategoryTheory.LocallyDiscrete.mkPseudofunctor._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {B₀ : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_5, u_4} B₀] [inst_1 : CategoryTheory.Bicategory C]
(obj : B₀ → C) (map : {b b' : B₀} → (b ⟶ b') → (obj b ⟶ obj b')) {b₀ b₁ b₂ b₃ : CategoryTheory.LocallyDiscrete B₀}
(x : b₀ ⟶ b₁) (x_1 : b₁ ⟶ b₂) (x_2 : b₂ ⟶ b₃),
map (CategoryTheory.CategoryStruc... | null | false |
CategoryTheory.Grothendieck.forget | Mathlib.CategoryTheory.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor C CategoryTheory.Cat) → CategoryTheory.Functor (CategoryTheory.Grothendieck F) C | The forgetful functor from `Grothendieck F` to the source category. | true |
Std.Http.Response.Builder.line._default | Std.Http.Data.Response | Std.Http.Response.Head | null | false |
ContinuousAffineEquiv.affineSubspaceMap._proof_2 | Mathlib.Topology.Algebra.AffineSubspace | ∀ {R : Type u_3} {V : Type u_5} {P : Type u_2} {W : Type u_4} {Q : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (e : P ≃ᴬ[R] Q) (... | null | false |
Lean.Lsp.ParameterInformationLabel.range.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.ParameterInformationLabel → Sort u} →
(t : Lean.Lsp.ParameterInformationLabel) →
t.ctorIdx = 1 →
((startUtf16Offset endUtf16Offset : ℕ) →
motive (Lean.Lsp.ParameterInformationLabel.range startUtf16Offset endUtf16Offset)) →
motive t | null | false |
ENat.one_epow | Mathlib.Data.ENat.Pow | ∀ {y : ℕ∞}, 1 ^ y = 1 | null | true |
AlgebraicGeometry.Scheme.OpenCover.ext_elem | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (f g : ↑(X.presheaf.obj (Opposite.op U))) (𝒰 : X.OpenCover),
(∀ (i : 𝒰.I₀),
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.app (𝒰.f i) U)) f =
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.app (𝒰.f i) U)) g) →
... | If two global sections agree after restriction to each member of an open cover, then
they agree globally. | true |
CompHausLike.coproductIsColimit._proof_6 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) (s : CategoryTheory.Limits.BinaryCofan X Y),
CompHausLike.HasProp P ↑s.1.toTop | null | false |
Std.Internal.List.containsKey_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l l' : List ((a : α) × β a)} {k : α},
l.Perm l' → Std.Internal.List.containsKey k l = Std.Internal.List.containsKey k l' | null | true |
tendsto_inv_atTop_nhds_zero_nat | Mathlib.Analysis.SpecificLimits.Basic | ∀ {𝕜 : Type u_4} [inst : DivisionSemiring 𝕜] [inst_1 : CharZero 𝕜] [inst_2 : TopologicalSpace 𝕜] [ContinuousSMul ℚ≥0 𝕜],
Filter.Tendsto (fun n => (↑n)⁻¹) Filter.atTop (nhds 0) | null | true |
SimpleGraph.Iso.map._proof_3 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_2} {W : Type u_1} (f : V ≃ W) (G : SimpleGraph V) {a b : V},
(SimpleGraph.map (⇑f) G).Adj (f a) (f b) ↔ G.Adj a b | null | false |
_private.Mathlib.NumberTheory.DiophantineApproximation.Basic.0.Real.invariant._simp_1_3 | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.declaration.formatter_207 | Lean.Parser.Command | IO Unit | null | false |
CommGroupWithZero.zpow._inherited_default | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → G₀ → (G₀ → G₀ → G₀) → (G₀ → G₀) → ℤ → G₀ → G₀ | null | false |
MvPolynomial.renameEquiv_trans | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {α : Type u_3} (R : Type u_4) [inst : CommSemiring R] (e : σ ≃ τ) (f : τ ≃ α),
(MvPolynomial.renameEquiv R e).trans (MvPolynomial.renameEquiv R f) = MvPolynomial.renameEquiv R (e.trans f) | null | true |
Units.instMulDistribMulAction._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Units | ∀ {M : Type u_1} {α : Type u_2} [inst : Monoid M] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction M α] (m : Mˣ),
↑m • 1 = 1 | null | false |
Polynomial.isOpenMap_comap_C | Mathlib.RingTheory.Spectrum.Prime.Polynomial | ∀ {R : Type u_1} [inst : CommRing R], IsOpenMap (PrimeSpectrum.comap Polynomial.C) | null | true |
Lean.Elab.Command.addModuleLinter | Lean.Elab.Command | Lean.Elab.Command.ModuleLinter → IO Unit | null | true |
_private.Mathlib.Data.Fintype.EquivFin.0.Function.Embedding.exists_of_card_eq_finset._simp_1_1 | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = (↑s₁ ⊆ ↑s₂) | null | false |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_11 | Lean.Elab.Tactic.Simp | (motive : Lean.Elab.Tactic.ElabSimpArgResult → Sort u_1) →
(arg : Lean.Elab.Tactic.ElabSimpArgResult) →
((entries : Array Lean.Meta.SimpEntry) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addEntries entries)) →
((fvarId : Lean.FVarId) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addLetToUnfold fvarId)) →
... | null | false |
Module.Presentation.cokernelRelations_R | Mathlib.Algebra.Module.Presentation.Cokernel | ∀ {A : Type u} [inst : Ring A] {M₁ : Type v₁} {M₂ : Type v₂} [inst_1 : AddCommGroup M₁] [inst_2 : Module A M₁]
[inst_3 : AddCommGroup M₂] [inst_4 : Module A M₂] (pres₂ : Module.Presentation A M₂) {f : M₁ →ₗ[A] M₂} {ι : Type w₁}
{g₁ : ι → M₁} (data : pres₂.CokernelData f g₁), (pres₂.cokernelRelations data).R = (pres... | null | true |
ValuativeRel._aux_Mathlib_RingTheory_Valuation_ValuativeRel_Basic___unexpand_ValuativeRel_vlt_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | Lean.PrettyPrinter.Unexpander | null | false |
BooleanAlgebra.toHImp | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} → [self : BooleanAlgebra α] → HImp α | null | true |
QuotientAddGroup.circularPreorder._proof_7 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} [hp' : Fact (0 < p)] {x₁ x₂ x₃ : α ⧸ AddSubgroup.zmultiples p}, btw x₁ x₂ x₃ → btw x₂ x₃ x₁ | null | false |
DiscreteQuotient.map_continuous | Mathlib.Topology.DiscreteQuotient | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{A : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B),
Continuous (DiscreteQuotient.map f cond) | null | true |
instIsCancelVAdd | Mathlib.Algebra.Group.Action.Defs | ∀ (G : Type u_9) [inst : AddCancelMonoid G], IsCancelVAdd G G | null | true |
AddCommMonCat.Hom.recOn | Mathlib.Algebra.Category.MonCat.Basic | {A B : AddCommMonCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →+ ↑B) → motive { hom' := hom' }) → motive t | null | false |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.le_singleton._simp_1_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (a : α), {a} = ↑[a] | null | false |
Lean.Syntax.topDown | Lean.Syntax | Lean.Syntax → optParam Bool false → Lean.Syntax.TopDown | `for _ in stx.topDown` iterates through each node and leaf in `stx` top-down, left-to-right.
If `firstChoiceOnly` is `true`, only visit the first argument of each choice node.
| true |
MultilinearMap.uncurry_curryRight | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂),
f.curryRight.uncurryRight = f | null | true |
Lean.Grind.IntModule.OfNatModule.r | Init.Grind.Module.Envelope | (α : Type u) → [Lean.Grind.NatModule α] → α × α → α × α → Prop | null | true |
SeparationQuotient.surjective_mk | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X], Function.Surjective SeparationQuotient.mk | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.