name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.Term.Do.ToTerm.returnToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Elab.Term.Do.ToTerm.M Lean.Syntax | null | true |
MeasureTheory.FiniteMeasure.normalize_eq_inv_mass_smul_of_nonzero | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : Nonempty Ω] {m0 : MeasurableSpace Ω} (μ : MeasureTheory.FiniteMeasure Ω),
μ ≠ 0 → μ.normalize.toFiniteMeasure = μ.mass⁻¹ • μ | null | true |
Lean.PrettyPrinter.Formatter.Context | Lean.PrettyPrinter.Formatter | Type | null | true |
List.SortedLE.of_map_toDual | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, l.SortedLE → (List.map (⇑OrderDual.toDual) l).SortedGE | **Alias** of the reverse direction of `List.sortedGE_map_toDual`. | true |
Finset.sum_singleton | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] (f : ι → M) (a : ι), ∑ x ∈ {a}, f x = f a | null | true |
Nat.mul_le_add_right | Init.Data.Nat.Lemmas | ∀ {m k n : ℕ}, k * m ≤ m + n ↔ (k - 1) * m ≤ n | null | true |
Std.DTreeMap.get?_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, (t₁ ∩ t₂).get? k = if k ∈ t₂ then t₁.get? k else none | null | true |
MeasureTheory.StronglyAdapted.integrable_upcrossingsBefore | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {a b : ℝ} {f : ℕ → Ω → ℝ} {N : ℕ}
{ℱ : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.StronglyAdapted ℱ f →
a < b → MeasureTheory.Integrable (fun ω => ↑(MeasureTheory.upcrossingsBefore a b f N ω)) μ | null | true |
Lean.Lsp.DocumentSymbol.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{sym sym' : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol} →
Lean.Lsp.DocumentSymbol.mk sym = Lean.Lsp.DocumentSymbol.mk sym' → (sym = sym' → P) → P | null | false |
Fin.reverseInduction._proof_3 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (i : Fin (n + 1)), ↑i ≤ 0 → ¬↑i = 0 → False | null | false |
Filter.isBoundedUnder_const | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} [Std.Refl r] {l : Filter β} {a : α},
Filter.IsBoundedUnder r l fun x => a | null | true |
CategoryTheory.Localization.Monoidal.instLiftingLocalizedMonoidalToMonoidalCategoryCompTensorRightObjFunctorFlipTensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 ... | null | true |
WithTop.Ioc_coe_top | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderTop α] [inst_2 : LocallyFiniteOrder α] (a : α),
Finset.Ioc ↑a ⊤ = Finset.insertNone (Finset.Ioi a) | null | true |
Std.Internal.UV.System.PasswdInfo._sizeOf_1 | Std.Internal.UV.System | Std.Internal.UV.System.PasswdInfo → ℕ | null | false |
CStarMatrix.conjTranspose_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Star A] (M : CStarMatrix m n A) (i : n) (j : m),
M.conjTranspose i j = star (M j i) | null | true |
CategoryTheory.MonoidalOpposite.unmopEquiv_functor_map | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᴹᵒᵖ} (f : X ⟶ Y),
(CategoryTheory.MonoidalOpposite.unmopEquiv C).functor.map f = f.unmop | null | true |
CategoryTheory.Iso.retract | Mathlib.CategoryTheory.Retract | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (X ≅ Y) → CategoryTheory.Retract X Y | If `X` is isomorphic to `Y`, then `X` is a retract of `Y`. | true |
Lean.instInhabitedNoConfusionInfo.default | Lean.AuxRecursor | Lean.NoConfusionInfo | null | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Operations.0.ContDiff.div._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : WithTop ℕ∞}, ContDiff 𝕜 n f = ∀ (x : E), ContDiffAt 𝕜 n f x | null | false |
_private.Mathlib.Topology.DiscreteSubset.0.Disjoint.eventually_nhdsWithin_specializes._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x ⤳ y = (y ∈ closure {x}) | null | false |
MulAction.smul_zpow_movedBy_eq_of_commute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {g h : G},
Commute g h → ∀ (j : ℤ), h ^ j • (MulAction.fixedBy α g)ᶜ = (MulAction.fixedBy α g)ᶜ | If `g` and `h` commute, then `g` moves `h ^ j • x` iff `g` moves `x`.
| true |
_private.Mathlib.Algebra.Group.Submonoid.Operations.0.Submonoid.pi_empty._simp_1_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {ι : Type u_4} {M : ι → Type u_5} [inst : (i : ι) → MulOneClass (M i)] (I : Set ι) {S : (i : ι) → Submonoid (M i)}
{p : (i : ι) → M i}, (p ∈ Submonoid.pi I S) = ∀ i ∈ I, p i ∈ S i | null | false |
Std.HashMap.ofList_cons | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {k : α} {v : β} {tl : List (α × β)},
Std.HashMap.ofList ((k, v) :: tl) = (∅.insert k v).insertMany tl | null | true |
Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac.sizeOf_spec | Lean.Meta.Tactic.Grind.AC.Types | ∀ (lhs : Bool) (s : Lean.Grind.AC.Seq) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (c₂ : Lean.Meta.Grind.AC.DiseqCnstr),
sizeOf (Lean.Meta.Grind.AC.DiseqCnstrProof.simp_ac lhs s c₁ c₂) = 1 + sizeOf lhs + sizeOf s + sizeOf c₁ + sizeOf c₂ | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.atLeastTwo_eq_halfAdder | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add | ∀ (lhsBit rhsBit carry : Bool), lhsBit.atLeastTwo rhsBit carry = ((lhsBit ^^ rhsBit) && carry || lhsBit && rhsBit) | null | true |
BoundedContinuousFunction.mem_charPoly | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {V : Type u_1} {W : Type u_2} [inst : AddCommGroup V] [inst_1 : Module ℝ V] [inst_2 : TopologicalSpace V]
[inst_3 : AddCommGroup W] [inst_4 : Module ℝ W] [inst_5 : TopologicalSpace W] {e : AddChar ℝ Circle}
{L : V →ₗ[ℝ] W →ₗ[ℝ] ℝ} {he : Continuous ⇑e} {hL : Continuous fun p => (L p.1) p.2}
(f : BoundedContinuou... | null | true |
OreLocalization.instSemiring._proof_2 | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] (n : ℕ),
(n + 1).unaryCast = n.unaryCast + 1 | null | false |
_private.Mathlib.Topology.Connected.Clopen.0.isPreconnected_iff_subset_of_disjoint._simp_1_1 | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} {s t : Set α}, (¬s ⊆ t) = ∃ a ∈ s, a ∉ t | null | false |
MeasureTheory.Measure.pi_Ioc_ae_eq_pi_Icc | 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)]
[inst_3 : (i : ι) → PartialOrder (α i)] [∀ (i : ι), MeasureTheory.NullSingletonClass (μ i)] {s : Set ι}
{f g : (i : ι) → α i},
... | null | true |
Lean.AsyncList.instCoeList | Lean.Server.AsyncList | {α : Type u_1} → {ε : Type u_2} → Coe (List α) (Lean.AsyncList ε α) | null | true |
Lean.Meta.Grind.instBEqCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → Lean.Meta.Grind.CongrKey enodeMap → Bool | null | false |
ContinuousAffineEquiv.symm_apply_eq | Mathlib.Topology.Algebra.ContinuousAffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : Module k V₁] [inst_3 : AddTorsor V₁ P₁] [inst_4 : TopologicalSpace P₁]
[inst_5 : AddCommGroup V₂] [inst_6 : Module k V₂] [inst_7 : AddTorsor V₂ P₂] [inst_8 : TopologicalSpace P₂]
(... | null | true |
_private.Std.Data.HashSet.RawLemmas.0.Std.HashSet.Raw.Equiv.symm.match_1_1 | Std.Data.HashSet.RawLemmas | ∀ {α : Type u_1} {m₁ m₂ : Std.HashSet.Raw α} (motive : m₁.Equiv m₂ → Prop) (x : m₁.Equiv m₂),
(∀ (h : m₁.inner.Equiv m₂.inner), motive ⋯) → motive x | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn_eq_zero_iff._simp_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | null | false |
Quiver.Path.vertices_comp_get_length_eq._auto_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | Lean.Syntax | null | false |
Std.HashSet.Equiv.inter_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α} [EquivBEq α] [LawfulHashable α],
m₂.Equiv m₃ → (m₁ ∩ m₂).Equiv (m₁ ∩ m₃) | null | true |
DirectLimit.instAddGroup._proof_12 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → AddGroup (G i... | null | false |
Ordinal.type_pUnit | Mathlib.SetTheory.Ordinal.Basic | Ordinal.type emptyRelation = 1 | null | true |
_private.Lean.Compiler.LCNF.CompatibleTypes.0.Lean.Compiler.LCNF.InferType.Pure.compatibleTypesFull._sparseCasesOn_6 | Lean.Compiler.LCNF.CompatibleTypes | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr))... | null | false |
Equicontinuous | Mathlib.Topology.UniformSpace.Equicontinuity | {ι : Type u_1} →
{X : Type u_3} → {α : Type u_6} → [tX : TopologicalSpace X] → [uα : UniformSpace α] → (ι → X → α) → Prop | A family `F : ι → X → α` of functions from a topological space to a uniform space is
*equicontinuous* on all of `X` if it is equicontinuous at each point of `X`. | true |
SimpleGraph.binomialRandom_one | Mathlib.Probability.Combinatorics.BinomialRandomGraph.Defs | ∀ (V : Type u_1) [Countable V], SimpleGraph.binomialRandom V 1 = MeasureTheory.Measure.dirac ⊤ | null | true |
CommRing.directSumGCommRing | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) → {R : Type u_2} → [inst : AddCommMonoid ι] → [inst_1 : CommRing R] → DirectSum.GCommRing fun x => R | A direct sum of copies of a `CommRing` inherits the commutative multiplication structure. | true |
Std.Packages.LinearOrderOfOrdArgs.min_eq | Init.Data.Order.PackageFactories | ∀ {α : Type u} (self : Std.Packages.LinearOrderOfOrdArgs α),
let this := self.ord;
let this_1 := self.le;
let this_2 := self.min;
have this_3 := ⋯;
∀ (a b : α), a ⊓ b = if (compare a b).isLE = true then a else b | null | true |
CategoryTheory.MorphismProperty.Comma.mapRightEq_hom_app_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | true |
CochainComplex.HomComplex.Cocycle.coe_sub | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} {n : ℤ} (z₁ z₂ : CochainComplex.HomComplex.Cocycle F G n), ↑(z₁ - z₂) = ↑z₁ - ↑z₂ | null | true |
Perfection.quotientMulEquiv._proof_5 | Mathlib.RingTheory.Teichmuller | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommRing R] (I : Ideal R) [inst_2 : CharP (R ⧸ I) p]
[inst_3 : IsAdicComplete I R],
(Perfection.liftMonoidHom p (Perfection (R ⧸ I) p) (R ⧸ I)).symm
((Perfection.mapMonoidHom p ↑(Ideal.Quotient.mk I)).comp
((Perfection.liftMonoidHom p (Per... | null | false |
toPrev.eq_1 | Mathlib.Algebra.Homology.BifunctorHomotopy | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {C D : HomologicalComplex V c} (j : ι), toPrev j = AddMonoidHom.mk' (fun f => f j (c.prev j)) ⋯ | null | true |
CategoryTheory.instCategoryObjOppositeSimplexCategoryNerve._aux_5 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
{Δ : SimplexCategoryᵒᵖ} → {X Y Z : (CategoryTheory.nerve C).obj Δ} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
cauchy_davenport_of_isMulTorsionFree | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {G : Type u_1} [inst : DecidableEq G] [inst_1 : Group G] [IsMulTorsionFree G] {s t : Finset G},
s.Nonempty → t.Nonempty → s.card + t.card - 1 ≤ (s * t).card | The **Cauchy-Davenport Theorem** for torsion-free groups. The size of `s * t` is lower-bounded
by `|s| + |t| - 1`. | true |
Std.HashMap.Raw.beq | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → [BEq β] → Std.HashMap.Raw α β → Std.HashMap.Raw α β → Bool | Compares two hash maps using Boolean equality on keys and values.
Returns `true` if the maps contain the same key-value pairs, `false` otherwise.
| true |
HEq.ndrecOn | Init.Core | {α : Sort u2} → {a : α} → {motive : {β : Sort u2} → β → Sort u1} → {β : Sort u2} → {b : β} → a ≍ b → motive a → motive b | `HEq.ndrec` variant | true |
Finset.Nontrivial.ne_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, s.Nontrivial → s ≠ {a} | null | true |
CategoryTheory.Bicategory.associatorNatIsoRightCat_inv_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c) (d : B) (X : c ⟶ d),
(CategoryTheory.Bicategory.associatorNatIsoRightCat f g d).inv.toNatTrans.app X =
(CategoryTheory.Bicategory.associator f g X).inv | null | true |
conjneg_ne_one | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 1 ↔ f ≠ 1 | null | true |
lTensor.inverse_of_rightInverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | true |
CategoryTheory.cartesianClosedOfReflective'._proof_3 | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (i : CategoryTheory.Functor D C)
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.Reflective i]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] (B : D) ... | null | false |
Lean.Lsp.DiagnosticSeverity.error.sizeOf_spec | Lean.Data.Lsp.Diagnostics | sizeOf Lean.Lsp.DiagnosticSeverity.error = 1 | null | true |
LTSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (p : LTSeries α) (f : α → β)
(hf : StrictMono f), RelSeries.last (p.map f hf) = f (RelSeries.last p) | null | true |
Lean.Meta.Match.Extension.Entry.mk | Lean.Meta.Match.MatcherInfo | Lean.Name → Lean.Meta.MatcherInfo → Lean.Meta.Match.Extension.Entry | null | true |
NonUnitalStarSubalgebra.prod | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : StarRing A] →
[inst_3 : Module R A] →
[inst_4 : NonUnitalSemiring B] →
[inst_5 : StarRing B] →
[inst_6 : Module R B]... | The product of two non-unital star subalgebras is a non-unital star subalgebra. | true |
NonUnitalCommCStarAlgebra.toIsScalarTower | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [self : NonUnitalCommCStarAlgebra A], IsScalarTower ℂ A A | null | true |
SimpleGraph.maximumIndepSet_exists | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_3} {G : SimpleGraph α} [inst : Finite α], ∃ s, G.IsMaximumIndepSet s | null | true |
CategoryTheory.Functor.instAdditiveObjPostcompose₂ | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : CategoryTheory.Preadditive E] {E' : Type u_4}
[inst_5 : CategoryTheory.Cate... | null | true |
VitaliFamily.ae_eventually_measure_zero_of_singular | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) [SecondCountableTopology α] [BorelSpace α] [MeasureTheory.IsLocallyFiniteMeasure μ]
{ρ : MeasureTheory.Measure α} [MeasureTheory.IsLocallyFiniteMeasure ρ],
ρ.MutuallySingular μ → ∀ᵐ (x : α) ∂μ... | If a measure `ρ` is singular with respect to `μ`, then for `μ` almost every `x`, the ratio
`ρ a / μ a` tends to zero when `a` shrinks to `x` along the Vitali family. This makes sense
as `μ a` is eventually positive by `ae_eventually_measure_pos`. | true |
PosMulReflectLE.toPosMulStrictMono | Mathlib.Algebra.Order.GroupWithZero.Defs | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [inst_2 : LinearOrder α] [PosMulReflectLE α], PosMulStrictMono α | null | true |
Int16.or_self | Init.Data.SInt.Bitwise | ∀ {a : Int16}, a ||| a = a | null | true |
List.zip_eq_nil_iff._simp_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {l₁ : List α} {l₂ : List β}, (l₁.zip l₂ = []) = (l₁ = [] ∨ l₂ = []) | null | false |
Set.OrdConnected.predOrder._proof_10 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Set α} [inst_1 : PredOrder α] (x : α) (hx : x ∈ s),
(if h : Order.pred ↑⟨x, hx⟩ ∈ s then ⟨Order.pred ↑⟨x, hx⟩, h⟩ else ⟨x, hx⟩) ≤ ⟨x, hx⟩ | null | false |
Nat.factorial_coe_dvd_prod | Mathlib.Data.Nat.Factorial.BigOperators | ∀ (k : ℕ) (n : ℤ), ↑k.factorial ∣ ∏ i ∈ Finset.range k, (n + ↑i) | `k!` divides the product of any `k` consecutive integers. | true |
Finset.coe_insert | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (s : Finset α), ↑(insert a s) = insert a ↑s | null | true |
_private.Mathlib.Data.List.SplitBy.0.List.getLast?.match_1.eq_2 | Mathlib.Data.List.SplitBy | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as | null | true |
ContinuousMap.notMem_idealOfSet | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {s : Set X} {f : C(X, R)}, f ∉ ContinuousMap.idealOfSet R s ↔ ∃ x ∈ sᶜ, f x ≠ 0 | null | true |
List.dropSlice.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (x x_1 : ℕ), List.dropSlice x x_1 [] = [] | null | true |
_private.Mathlib.Logic.Equiv.List.0.Encodable.encodeList.match_1.splitter | Mathlib.Logic.Equiv.List | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (l : List α) → motive (a :: l)) → motive x | null | true |
Std.Sat.AIG.Decl.relabel.match_1 | Std.Sat.AIG.Relabel | {α : Type} →
(motive : Std.Sat.AIG.Decl α → Sort u_1) →
(decl : Std.Sat.AIG.Decl α) →
(Unit → motive Std.Sat.AIG.Decl.false) →
((a : α) → motive (Std.Sat.AIG.Decl.atom a)) →
((lhs rhs : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate lhs rhs)) → motive decl | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_34 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls_1 lls : ℕ)
(l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ) (lrl lrr : Std.DTreeMap.Internal.Impl α β),
3 * (ll.size + 1 + lr.size) < l.size + 1 + r.size + 1 + (lrl.size + 1 + lrr.size) →
ll.Balanced ∧
lr.Balanced ... | null | false |
CategoryTheory.enrichedFunctorTypeEquivFunctor._proof_2 | Mathlib.CategoryTheory.Enriched.Basic | ∀ {C : Type u_2} [𝒞 : CategoryTheory.EnrichedCategory (Type u_1) C] {D : Type u_3}
[𝒟 : CategoryTheory.EnrichedCategory (Type u_1) D] (F : CategoryTheory.Functor C D) (X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eComp (Type u_1) X Y Z) (TypeCat.ofHom fun f => F.map f) =
CategoryTheory.Categ... | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase.match_3.eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond (Std... | null | true |
Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convIntro____1 | Init.Conv | Lean.Macro | `intro` traverses into binders. Synonym for `ext`. | false |
AlgebraicGeometry.Scheme.Cover.RelativeGluingData.glued | Mathlib.AlgebraicGeometry.RelativeGluing | {S : AlgebraicGeometry.Scheme} →
{𝒰 : S.OpenCover} →
[inst : CategoryTheory.Category.{u_2, u_1} 𝒰.I₀] →
[inst_1 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰] →
AlgebraicGeometry.Scheme.Cover.RelativeGluingData 𝒰 →
[Small.{u, u_1} 𝒰.I₀] → [Quiver.IsThin 𝒰.I₀] → AlgebraicGeometry... | The glued scheme of a relative gluing datum is the colimit over the `Xᵢ`. For the
structure map, see `AlgebraicGeometry.Scheme.Cover.RelativeGluingData.toBase` and the isomorphisms
with the preimages `AlgebraicGeometry.Scheme.Cover.RelativeGluingData.isPullback_natTrans_ι_toBase`.
| true |
ArchimedeanClass.liftOrderHom_mk | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {α : Type u_2}
[inst_3 : PartialOrder α] (f : M → α) (h : ∀ (a b : M), ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b → f a ≤ f b)
(a : M), (ArchimedeanClass.liftOrderHom f h) (ArchimedeanClass.mk a) = f a | null | true |
CategoryTheory.GrothendieckTopology.diagramPullback._proof_1 | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
{D : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTh... | null | false |
Subsemiring.closure_singleton_one | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} [inst : NonAssocSemiring R], Subsemiring.closure {1} = ⊥ | null | true |
Std.ExtHashMap.getD_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β},
(m₁ ∩ m₂).getD k fallback = if k ∈ m₂ then m₁.getD k fallback else fallback | null | true |
Submonoid.LocalizationMap.map_surjective_of_surjOn | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} {T : Submonoid P} (hy : ∀ (y : ↥S), g ↑y ∈ T)
{Q : Type u_4} [inst_3 : CommMonoid Q] {k : T.LocalizationMap Q},
Set.SurjOn ⇑g ↑S ↑T → Functi... | null | true |
Lean.Meta.Grind.AC.EqCnstrProof.ctorIdx | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.EqCnstrProof → ℕ | null | false |
Lean.Compiler.LCNF.FloatLetIn.BaseFloatContext.mk | Lean.Compiler.LCNF.FloatLetIn | List (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) → Lean.Compiler.LCNF.FloatLetIn.BaseFloatContext | null | true |
Subfield.rank_comap | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A : Subfield E) {L : Type v} [inst_1 : Field L] (f : L →+* E),
Module.rank (↥(Subfield.comap f A)) L = A.relrank f.fieldRange | null | true |
ContinuousLinearMap.ebound | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f : ... | null | true |
List.rotate_eq_nil_iff | Mathlib.Data.List.Rotate | ∀ {α : Type u} {l : List α} {n : ℕ}, l.rotate n = [] ↔ l = [] | null | true |
SubMulAction.ofFixingSubgroup_equivariantMap.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_1) {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] (s : Set α),
SubMulAction.ofFixingSubgroup_equivariantMap M s = { toFun := fun x => ↑x, map_smul' := ⋯ } | null | true |
Ideal.comap._proof_6 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
(f : F) [RingHomClass F R S] (I : Ideal S) (c x : R), x ∈ ⇑f ⁻¹' ↑I → c • x ∈ ⇑f ⁻¹' ↑I | null | false |
Int64.toInt_maxValue | Init.Data.SInt.Lemmas | Int64.maxValue.toInt = 2 ^ 63 - 1 | null | true |
hardyZ._proof_1 | Mathlib.NumberTheory.LSeries.HardyZ | (1 + 1).AtLeastTwo | null | false |
CategoryTheory.IsFilteredOrEmpty | Mathlib.CategoryTheory.Filtered.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | A category `IsFilteredOrEmpty` if
1. for every pair of objects there exists another object "to the right", and
2. for every pair of parallel morphisms there exists a morphism to the right so the compositions
are equal.
| true |
Std.TreeMap.isEmpty_inter_iff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
(t₁ ∩ t₂).isEmpty = true ↔ ∀ k ∈ t₁, k ∉ t₂ | null | true |
_private.Init.Meta.Defs.0.Lean.Name.hasNum._sunfold | Init.Meta.Defs | Lean.Name → Bool | null | false |
ZeroHom.zero_comp | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : Zero M] [inst_1 : Zero N] [inst_2 : Zero P] (f : ZeroHom M N),
ZeroHom.comp 0 f = 0 | null | true |
ImportGraph.System.FilePath.Modules.forInAux | ImportGraph.Util.Modules | {m : Type → Type u_1} →
[Monad m] →
[MonadLiftT IO m] →
{β : Type} →
System.FilePath → Lean.Name → β → (Lean.Name × IO.FS.DirEntry → β → m (ForInStep β)) → m (ForInStep β) | null | true |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_5 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor C (Type u_3)) {X : C}
(x : F.obj X) (X_1 : (CategoryTheory.FunctorToTypes.fromOverFunctor F x).Elements),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.Elements.homMk (CategoryTheory.Over.Hom.left (Category... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.