name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Tactic.GRewrite.Core.0.Lean.MVarId.grewrite.match_6 | Mathlib.Tactic.GRewrite.Core | (motive : (Option (Lean.Expr × Lean.Expr) × Mathlib.Tactic.GRewrite.State✝) × Mathlib.Tactic.GCongr.State → Sort u_1) →
(__do_lift : (Option (Lean.Expr × Lean.Expr) × Mathlib.Tactic.GRewrite.State✝) × Mathlib.Tactic.GCongr.State) →
((eNew impProof : Lean.Expr) →
(cache : Std.HashSet (Option Lean.Expr × Le... | null | false |
Matrix.replicateRow_add | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} [inst : Add α] (v w : m → α),
Matrix.replicateRow ι (v + w) = Matrix.replicateRow ι v + Matrix.replicateRow ι w | null | true |
IsRelUpperSet.iUnion₂ | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} {P : α → Prop} [inst : LE α] {f : (i : ι) → κ i → Set α},
(∀ (i : ι) (j : κ i), IsRelUpperSet (f i j) P) → IsRelUpperSet (⋃ i, ⋃ j, f i j) P | null | true |
Std.Internal.UV.System.availableMemory | Std.Internal.UV.System | IO UInt64 | Returns the available memory for allocation in bytes.
| true |
SmoothBumpFunction.ball_inter_range_eq_ball_inter_target | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M}
(f : SmoothBumpFunction I c),
Metric.ball (↑(extChartAt I c) c) f.rOut ∩ Set.range ↑I =
... | null | true |
_private.Mathlib.Algebra.Order.Group.Finset.0.Multiset.toFinset_nsmul.match_1_1 | Mathlib.Algebra.Order.Group.Finset | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (h : 0 ≠ 0), motive 0 h) → (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | null | false |
SetSemiring.down_add | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} (s t : SetSemiring α), SetSemiring.down (s + t) = SetSemiring.down s ∪ SetSemiring.down t | null | true |
Mathlib.Tactic.Abel.evalSMul._f | Mathlib.Tactic.Abel | Lean.Expr × ℤ →
(x : Mathlib.Tactic.Abel.NormalExpr) →
Mathlib.Tactic.Abel.NormalExpr.below x → Mathlib.Tactic.Abel.M (Mathlib.Tactic.Abel.NormalExpr × Lean.Expr) | null | false |
Std.ExtTreeMap.getElem?_erase | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α},
(t.erase k)[a]? = if cmp k a = Ordering.eq then none else t[a]? | null | true |
isOpenMap_smul₀ | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {G₀ : Type u_4} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀] [inst_2 : MulAction G₀ α]
[ContinuousConstSMul G₀ α] {c : G₀}, c ≠ 0 → IsOpenMap fun x => c • x | null | true |
MulSemiringActionHom.recOn | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
[inst : Monoid M] →
{N : Type u_2} →
[inst_1 : Monoid N] →
{φ : M →* N} →
{R : Type u_10} →
[inst_2 : Semiring R] →
[inst_3 : MulSemiringAction M R] →
{S : Type u_12} →
[inst_4 : Semiring S] →
... | null | false |
_private.Mathlib.Algebra.EuclideanDomain.Basic.0.EuclideanDomain.«_aux_Mathlib_Algebra_EuclideanDomain_Basic___macroRules__private_Mathlib_Algebra_EuclideanDomain_Basic_0_EuclideanDomain_term_≺__1» | Mathlib.Algebra.EuclideanDomain.Basic | Lean.Macro | null | false |
groupHomology.H0Iso | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] → (A : Rep.{u, u, u} k G) → groupHomology.H0 A ≅ (Rep.coinvariantsFunctor k G).obj A | The 0th group homology of `A`, defined as the 0th homology of the complex of inhomogeneous
chains, is isomorphic to the invariants of the representation on `A`. | true |
Std.ExtTreeMap.maxKey?_le_maxKey?_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {km kmi : α}, t.maxKey? = some km → (t.insert k v).maxKey?.get ⋯ = kmi → (cmp km kmi).isLE = true | null | true |
Positive.addLeftCancelSemigroup._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {M : Type u_1} [inst : AddLeftCancelMonoid M] [inst_1 : Preorder M] [inst_2 : AddLeftStrictMono M],
IsLeftCancelAdd { x // 0 < x } | null | false |
CategoryTheory.Functor.copyObj._proof_4 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) (obj : C → D)
(e : (X : C) → F.obj X ≅ obj X) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (e X).inv
(CategoryTheory.Categ... | null | false |
AddAut.instAddGroup._proof_9 | Mathlib.Algebra.Group.End | ∀ (M : Type u_1) [inst : Add M] (x : AddAut M), x + 0 = x + 0 | null | false |
CompactCoherentification.t2space | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {X : Type u_1} [inst : TopologicalSpace X] [t : T2Space X], T2Space (CompactCoherentification X) | null | true |
_private.Init.Data.List.Lemmas.0.List.dropLast_append_of_ne_nil.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (motive : List α → l ≠ [] → Prop) (x : List α) (x_1 : l ≠ []),
(∀ (x : l ≠ []), motive [] x) → (∀ (a : α) (l' : List α) (h : l ≠ []), motive (a :: l') h) → motive x x_1 | null | false |
ProbabilityTheory.indepSet_iff_measure_inter_eq_mul | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {s t : Set Ω},
MeasurableSet s →
MeasurableSet t →
∀ (μ : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.indepSet_iff_measure_inter_eq_mul._auto_1)
[MeasureTheory.IsZeroOrProbabilityMeasure μ], ProbabilityTheory.IndepSet s t μ ↔ μ (s ∩ t) = μ s * μ t | null | true |
FreeSemigroup.mk._flat_ctor | Mathlib.Algebra.Free | {α : Type u} → α → List α → FreeSemigroup α | null | false |
Set.image_sigmaMk_preimage_sigmaMap_subset | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} {β : ι' → Type u_4} (f : ι → ι') (g : (i : ι) → α i → β (f i))
(i : ι) (s : Set (β (f i))), Sigma.mk i '' g i ⁻¹' s ⊆ Sigma.map f g ⁻¹' Sigma.mk (f i) '' s | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.coeff_weierstrassPExceptSeries._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
exists_zsmul_surjective | Mathlib.Algebra.Group.DivInvMonoid | ∀ (G : Type u_2) [inst : SMul ℤ G] [IsAddCyclic G], ∃ g, Function.Surjective fun x => x • g | null | true |
Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convRepeat__1 | Init.Conv | Lean.Macro | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.realizeValue.realizeAndReport | Lean.Meta.Basic | Lean.MetaM Dynamic → Lean.Core.Context → Lean.Environment → Lean.Options → BaseIO Dynamic | null | true |
Subgroup.comap_upperCentralSeries_quotient_center | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] (n : ℕ),
Subgroup.comap (QuotientGroup.mk' (Subgroup.center G)) (Subgroup.upperCentralSeries (G ⧸ Subgroup.center G) n) =
Subgroup.upperCentralSeries G n.succ | null | true |
CategoryTheory.Functor.PullbackObjObj.ofIsTerminal | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
(G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)) →
{... | A `Functor.PullbackObjObj` structure for a functor `G : C₁ᵒᵖ ⥤ C₃ ⥤ C₂` and
morphisms `f₁ : X₁ ⟶ Y₁` and `f₃ : X₃ ⟶ Y₃` when `Y₃` is terminal and both
`G.obj X₁` and `G.obj Y₁` preserve the terminal object. | true |
Equiv.Perm.support_eq_empty_iff | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {σ : Equiv.Perm α}, σ.support = ∅ ↔ σ = 1 | null | true |
Rat.isFractionRing | Mathlib.RingTheory.Localization.FractionRing | IsFractionRing ℤ ℚ | The cast from `Int` to `Rat` as a `FractionRing`. | true |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.interpolate._simp_2 | Mathlib.LinearAlgebra.Lagrange | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] {f g : ι → M},
∑ x ∈ s, f x + ∑ x ∈ s, g x = ∑ x ∈ s, (f x + g x) | null | false |
Subgroup.adjoinNegOne_eq_self_iff._simp_1 | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {R : Type u_2} [inst_2 : Ring R] {𝒢 : Subgroup (GL n R)},
(𝒢.adjoinNegOne = 𝒢) = (-1 ∈ 𝒢) | null | false |
BotHom.instSemilatticeInf._proof_2 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Bot α] [inst_1 : SemilatticeInf β] [inst_2 : OrderBot β] {x y : BotHom α β},
⇑y ≤ ⇑x ↔ ⇑y ≤ ⇑x | null | false |
Quiver.Path.isChain_toList_nonempty._f | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a : V} (x : V) (x_1 : Quiver.Path a x) (f : Quiver.Path.below x_1),
List.IsChain (fun x y => Nonempty (y ⟶ x)) x_1.toList | null | false |
isMIntegralCurveAt_eventuallyEq_of_contMDiffAt_boundaryless | Mathlib.Geometry.Manifold.IntegralCurve.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : IsManifold I 1 M] {γ γ' : ℝ → M} {v : (x : M) → TangentSpace I x} {t₀ : ℝ} [Boundaryl... | null | true |
ContinuousLinearMap.integrableAtFilter_comp | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {l : Filter α} {E : Type u_6} {H : Type u_7}
{𝕜 : Type u_8} {𝕜' : Type u_9} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜' E] [inst_4 : NormedAddCommGroup H... | null | true |
OpenPartialHomeomorph.isOpen_symm_image_iff_of_subset_target | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {t : Set Y}, t ⊆ e.target → (IsOpen (↑e.symm '' t) ↔ IsOpen t) | null | true |
OnePoint.nhdsNE_infty_neBot | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [NoncompactSpace X], (nhdsWithin OnePoint.infty {OnePoint.infty}ᶜ).NeBot | If `X` is a non-compact space, then `∞` is not an isolated point of `OnePoint X`. | true |
controlled_prod_of_mem_closure_range | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} {F : Type u_5} [inst : SeminormedCommGroup E] [inst_1 : SeminormedCommGroup F] {j : E →* F} {b : F},
b ∈ closure ↑j.range →
∀ {f : ℕ → ℝ},
(∀ (n : ℕ), 0 < f n) →
∃ a,
Filter.Tendsto (fun n => ∏ i ∈ Finset.range (n + 1), j (a i)) Filter.atTop (nhds b) ∧
‖(j (a 0... | null | true |
MeasureTheory.Lp.fourierTransformₗᵢ._proof_11 | Mathlib.Analysis.Fourier.LpSpace | ∀ (E : Type u_1) (F : Type u_2) [inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [inst_2 : BorelSpace E]
[inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace ℝ E] [inst_5 : FiniteDimensional ℝ E],
AddSubmonoidClass (AddSubgroup (E →ₘ[MeasureTheory.volume] F)) (E →ₘ[MeasureTheory.volume] F) | null | false |
Set.cardinalMk_Ici | Mathlib.Order.Interval.Set.Card | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] (a : α),
Cardinal.mk ↑(Set.Ici a) = ↑(Finset.Ici a).card | null | true |
_private.Mathlib.RingTheory.Nilpotent.Defs.0.isReduced_mulOpposite_iff._simp_1_1 | Mathlib.RingTheory.Nilpotent.Defs | ∀ (R : Type u_5) [inst : Zero R] [inst_1 : Pow R ℕ], IsReduced R = ∀ (x : R), IsNilpotent x → x = 0 | null | false |
groupHomology.mapCycles₂_comp | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u} [inst : CommRing k] {G H K : Type u} [inst_1 : Group G] [inst_2 : Group H] [inst_3 : Group K]
{A : Rep.{u, u, u} k G} {B : Rep.{u, u, u} k H} {C : Rep.{u, u, u} k K} (f : G →* H) (g : H →* K)
(φ : A ⟶ Rep.res f B) (ψ : B ⟶ Rep.res g C),
groupHomology.mapCycles₂ (g.comp f) (CategoryTheory.CategorySt... | null | true |
Lean.Syntax.eqWithInfo | Lean.Syntax | Lean.Syntax → Lean.Syntax → Bool | Full comparison of syntax structures and source infos. | true |
PrimeMultiset.ofNatList.eq_1 | Mathlib.Data.PNat.Factors | ∀ (l : List ℕ) (h : ∀ p ∈ l, Nat.Prime p), PrimeMultiset.ofNatList l h = PrimeMultiset.ofNatMultiset (↑l) h | null | true |
CategoryTheory.WalkingIso | Mathlib.AlgebraicTopology.SimplicialSet.CoherentIso | Type w | This is the free-living isomorphism as the codiscrete category on `Bool`. | true |
CategoryTheory.Triangulated.AbelianSubcategory.hasCokernel | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_1} {A : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C]... | null | true |
CategoryTheory.Sieve.instCompleteLattice._proof_9 | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x x_1 : CategoryTheory.Sieve X) (x_2 : C)
(x_3 : x_2 ⟶ X), x.arrows x_3 ∧ x_1.arrows x_3 → x_1.arrows x_3 | null | false |
Complex.real_lt_real._simp_1 | Mathlib.Analysis.Complex.Order | ∀ {x y : ℝ}, (↑x < ↑y) = (x < y) | null | false |
SubStarSemigroup.toSubsemigroup | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} → [inst : Mul M] → [inst_1 : Star M] → SubStarSemigroup M → Subsemigroup M | Reinterpret a `SubStarSemigroup` as a `Subsemigroup`. | true |
CategoryTheory.AB5OfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', v, u} C] →
{motive : CategoryTheory.AB5OfSize.{w, w', v, u} C → Sort u_1} →
((ofShape :
∀ (J : Type w') [inst_2 : CategoryTheory.Category.{w, w'} J] [inst_3 : Ca... | null | false |
Ordnode.findLtAux._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → α → α | null | false |
SetLike.isCoatom_iff | Mathlib.Order.Atoms | ∀ {A : Type u_4} {B : Type u_5} [inst : PartialOrder A] [inst_1 : SetLike A B] [IsConcreteLE A B] [inst_3 : OrderTop A]
{K : A}, IsCoatom K ↔ K ≠ ⊤ ∧ ∀ (H : A) (g : B), K ≤ H → g ∉ K → g ∈ H → H = ⊤ | null | true |
_private.Init.Data.String.Extra.0.String.findLeadingSpacesSize.consumeSpaces._mutual._proof_3 | Init.Data.String.Extra | ∀ {s : String} (it : s.Pos) (curr min : ℕ) (h : ¬it.IsAtEnd),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun it curr => PSigma.casesOn curr fun curr min => it) fun _x =>
PSigma.casesOn _x fun it min => it)
String.Pos.instWellFoundedRelation).1
(PSum.inr ⟨... | null | false |
ListSlice | Init.Data.Slice.List.Basic | Type u → Type u | A region of some underlying list. List slices can be used to avoid copying or allocating space,
while being more convenient than tracking the bounds by hand.
A list slice only stores the suffix of the underlying list, starting from the range's lower bound
so that the cost of operations on the slice does not depend on ... | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_4 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u} [inst : Monoid α] {a b : αˣ}, (a = b) = (↑a = ↑b) | null | false |
Std.DTreeMap.Internal.Impl.ExplorationStep.noConfusionType | Std.Data.DTreeMap.Internal.Model | Sort u_1 →
{α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
Std.DTreeMap.Internal.Impl.ExplorationStep α β k →
{α' : Type u} →
{β' : α' → Type v} →
[inst' : Ord α'] → {k' : α' → Ordering} → Std.DTreeMap.Internal.Impl.Explorat... | null | false |
FreeAddMagmaAssocQuotientEquiv.eq_1 | Mathlib.Algebra.Free | ∀ (α : Type u),
FreeAddMagmaAssocQuotientEquiv α =
(AddMagma.FreeAddSemigroup.lift FreeAddMagma.toFreeAddSemigroup).toAddEquiv
(FreeAddSemigroup.lift (⇑AddMagma.FreeAddSemigroup.of ∘ FreeAddMagma.of)) ⋯ ⋯ | null | true |
Std.Tactic.BVDecide.BVBinOp.mul.elim | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVBinOp → Sort u} →
(t : Std.Tactic.BVDecide.BVBinOp) → t.ctorIdx = 4 → motive Std.Tactic.BVDecide.BVBinOp.mul → motive t | null | false |
Lean.Elab.Command.State.traceState | Lean.Elab.Command | Lean.Elab.Command.State → Lean.TraceState | null | true |
Std.DTreeMap.Raw.contains_modify | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {k k' : α} {f : β k → β k}, (t.modify k f).contains k' = t.contains k' | null | true |
IsGreatest.nnnorm_cfcₙ_nnreal._auto_5 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
Bundle.Trivialization.restrictPreimage'._proof_7 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) (s : Set B)
[inst_3 : Nonempty (↑s → F → ↑(proj ⁻¹' s))], IsOpen (e.toPretrivialization.restrictPreimage' s).baseSet | null | false |
UInt8.toUInt32_toUInt16 | Init.Data.UInt.Lemmas | ∀ (n : UInt8), n.toUInt16.toUInt32 = n.toUInt32 | null | true |
_private.Mathlib.Algebra.Star.Unitary.0.Unitary.instNegSubtypeMemSubmonoidUnitary._simp_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | null | false |
CategoryTheory.Localization.Monoidal.functorCoreMonoidalOfComp._simp_4 | Mathlib.CategoryTheory.Localization.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.isExpensiveConstantValueBoxing._sparseCasesOn_8 | Lean.Compiler.LCNF.ExplicitBoxing | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
EquivLike.surjective | Mathlib.Basic.FunLike.Equiv | ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [inst : EquivLike E α β] (e : E), Function.Surjective ⇑e | null | true |
Set.Nonempty.intrinsicClosure | Mathlib.Analysis.Convex.Intrinsic | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] {s : Set P}, s.Nonempty → (intrinsicClosure 𝕜 s).Nonempty | **Alias** of the reverse direction of `intrinsicClosure_nonempty`. | true |
Std.Rii.toList_eq_nil_iff | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : LT α] [DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α] [inst : Std.Rxi.IsAlwaysFinite α],
r.toList = [] ↔... | null | true |
VitaliFamily.measure_le_mul_of_subset_limRatioMeas_lt | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) [inst_1 : SecondCountableTopology α] [inst_2 : BorelSpace α]
[inst_3 : MeasureTheory.IsLocallyFiniteMeasure μ] {ρ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsLocallyFiniteMeasure ρ] (... | If, for all `x` in a set `s`, one has frequently `ρ a / μ a < p`, then `ρ s ≤ p * μ s`, as
proved in `measure_le_of_frequently_le`. Since `ρ a / μ a` tends almost everywhere to
`v.limRatioMeas hρ x`, the same property holds for sets `s` on which `v.limRatioMeas hρ < p`. | true |
_private.Mathlib.Algebra.Group.Submonoid.Support.0.AddSubmonoid.support_map.match_1_1 | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_2} [inst : AddGroup G] {H : Type u_1} [inst_1 : AddGroup H] {f : G →+ H} {M : AddSubmonoid G} (x : H)
(motive : x ∈ (AddSubmonoid.map f M).support → Prop) (x_1 : x ∈ (AddSubmonoid.map f M).support),
(∀ (a : G) (h : a ∈ ↑M ∧ f a = x) (b : G) (hb₁ : b ∈ ↑M) (right : f b = -x), motive ⋯) → motive x_1 | null | false |
Finset.left_mem_Icc | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α], a ∈ Finset.Icc a b ↔ a ≤ b | null | true |
MonadSaveCtx.mk._flat_ctor | ProofWidgets.Util | {m : Type → Type} → {n : outParam (Type → Type)} → ({α : Type} → m α → m (n α)) → MonadSaveCtx m n | null | false |
MeasureTheory.MemLp.enorm_rpow | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} {ε : Type u_6}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] {f : α → ε},
MeasureTheory.MemLp f p μ → p ≠ 0 → p ≠ ⊤ → MeasureTheory.MemLp (fun x => ‖f x‖ₑ ^ p.toReal) 1 μ | null | true |
Equiv.trans_refl | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), e.trans (Equiv.refl β) = e | null | true |
CategoryTheory.Limits.MultispanIndex.inj_sndSigmaMapOfIsColimit | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left}
(d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) (i : J.L),
CategoryTheory.CategoryStruct.co... | null | true |
Rack.PreEnvelGroupRel'.trans.injEq | Mathlib.Algebra.Quandle | ∀ {R : Type u} [inst : Rack R] {a b c : Rack.PreEnvelGroup R} (hab : Rack.PreEnvelGroupRel' R a b)
(hbc : Rack.PreEnvelGroupRel' R b c) (b_1 : Rack.PreEnvelGroup R) (hab_1 : Rack.PreEnvelGroupRel' R a b_1)
(hbc_1 : Rack.PreEnvelGroupRel' R b_1 c), (hab.trans hbc = hab_1.trans hbc_1) = (b = b_1 ∧ hab ≍ hab_1 ∧ hbc ≍... | null | true |
CategoryTheory.Limits.IsLimit.mk | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cone F} →
(lift : (s : CategoryTheory.Limits.Cone F) → s.pt ⟶ t.pt) →
autoPa... | null | true |
TopHom.mk.sizeOf_spec | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_6} {β : Type u_7} [inst : Top α] [inst_1 : Top β] [inst_2 : SizeOf α] [inst_3 : SizeOf β] (toFun : α → β)
(map_top' : toFun ⊤ = ⊤), sizeOf { toFun := toFun, map_top' := map_top' } = 1 + sizeOf map_top' | null | true |
CochainComplex.HomComplex.Cocycle.diff | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → (K : CochainComplex C ℤ) → CochainComplex.HomComplex.Cocycle K K 1 | The `1`-cocycle given by the differential on a cochain complex. | true |
AlgebraicGeometry.Scheme.AffineZariskiSite.isColimitCocone._proof_2 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ (X : AlgebraicGeometry.Scheme),
CategoryTheory.Limits.HasColimit (AlgebraicGeometry.Scheme.AffineZariskiSite.relativeGluingData ⋯).functor | null | false |
AddSubgroup.fg_iff | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : AddGroup G] (P : AddSubgroup G), P.FG ↔ ∃ S, AddSubgroup.closure S = P ∧ S.Finite | An equivalent expression of `AddSubgroup.fg` in terms of `Set.Finite` instead of
`Finset`. | true |
ProbabilityTheory.charFunDual_map_add_prod_eq_mul | Mathlib.Probability.Independence.CharacteristicFunction | ∀ {E : Type u_2} {mE : MeasurableSpace E} [inst : NormedAddCommGroup E] [BorelSpace E] [SecondCountableTopology E]
[inst_3 : NormedSpace ℝ E] {μ ν : MeasureTheory.Measure E} [MeasureTheory.IsProbabilityMeasure μ]
[MeasureTheory.IsProbabilityMeasure ν],
MeasureTheory.charFunDual (MeasureTheory.Measure.map (fun p =... | null | true |
SSet.anodyneExtensions_eq_retracts_transfiniteCompositions | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic | SSet.anodyneExtensions =
(CategoryTheory.MorphismProperty.transfiniteCompositions.{u, u, u + 1}
(CategoryTheory.MorphismProperty.coproducts.{u, u, u + 1} SSet.modelCategoryQuillen.J).pushouts).retracts | null | true |
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator.mk | Lean.PrettyPrinter.Delaborator.SubExpr | ℕ → ℕ → Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator | null | true |
_private.Mathlib.CategoryTheory.Preadditive.Schur.0.CategoryTheory.fieldEndOfFiniteDimensional._simp_3 | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {α : Type u_9} {β : Type u_10} {inst : Semigroup α} [self : SemigroupAction α β] (x y : α) (b : β),
x • y • b = (x * y) • b | null | false |
_private.Init.Data.Slice.List.Lemmas.0.List.toArray_mkSlice_roc._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.toArray xs = (Std.Slice.toList xs).toArray | null | false |
Topology.IsScott.isUpperSet_of_isOpen | Mathlib.Topology.Order.ScottTopology | ∀ {α : Type u_1} {D : Set (Set α)} [inst : Preorder α] [inst_1 : TopologicalSpace α] {s : Set α} [Topology.IsScott α D],
IsOpen s → IsUpperSet s | null | true |
Polynomial.coeff_modByMonic_mem_pow_natDegree_mul | Mathlib.Algebra.Polynomial.CoeffMem | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (p q : Polynomial S)
(Mp : Submodule R S),
(∀ (i : ℕ), p.coeff i ∈ Mp) →
1 ∈ Mp →
∀ (Mq : Submodule R S), (∀ (i : ℕ), q.coeff i ∈ Mq) → 1 ∈ Mq → ∀ (i : ℕ), (p %ₘ q).coeff i ∈ Mq ^ p.natDegree * Mp | For polynomials `p q : R[X]`, the coefficients of `p %ₘ q` can be written as sums of products of
coefficients of `p` and `q`.
Precisely, each summand needs at most one coefficient of `p` and `deg p` coefficients of `q`. | true |
MDifferentiableWithinAt.sum | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Basic.0.iteratedFDeriv_const_of_ne._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : 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 : ℕ}, iteratedFDeriv 𝕜 n f = iteratedFDerivWithin 𝕜 n f Set.univ | null | false |
Dynamics.IsDynNetIn.monotone_subset | Mathlib.Dynamics.TopologicalEntropy.Subset | ∀ {X : Type u_1} {T : X → X} {F G s : Set X} {U : SetRel X X} {n : ℕ},
F ⊆ G → Dynamics.IsDynNetIn T F U n s → Dynamics.IsDynNetIn T G U n s | null | true |
Batteries.BinomialHeap.Imp.HeapNode.foldTreeM | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.BinomialHeap.Imp.HeapNode α → m β | `O(n)`. Fold a monadic function over the tree structure to accumulate a value. | true |
Std.Http.Header.Host.mk.inj | Std.Http.Data.Headers.Basic | ∀ {host : Std.Http.URI.Host} {port : Std.Http.URI.Port} {host_1 : Std.Http.URI.Host} {port_1 : Std.Http.URI.Port},
{ host := host, port := port } = { host := host_1, port := port_1 } → host = host_1 ∧ port = port_1 | null | true |
String.Pos.Raw.instLinearOrderPackage._proof_4 | Init.Data.String.OrderInstances | ∀ (a b : String.Pos.Raw), a ≤ b ∨ b ≤ a | null | false |
_private.Mathlib.Topology.Baire.Lemmas.0.IsGδ.baireSpace_of_dense._proof_1_3 | Mathlib.Topology.Baire.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (f : ℕ → Set ↑s) (V : ℕ → Set X)
(hV : (∀ (n : ℕ), IsOpen (V n)) ∧ s = ⋂ n, V n) (g : ℕ → Set X) (x : X),
(∀ (n : ℕ), Subtype.val ⁻¹' g n = f n) →
((∀ (i : ℕ), x ∈ g i ∧ x ∈ V i) ↔ ∃ (x_1 : ∀ (i : ℕ), x ∈ V i), ∀ (i : ℕ), ⟨x, ⋯⟩ ∈ f i) | null | false |
MaxTropical.instAddCommMonoidOfOrderBot._proof_5 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : OrderBot R] (x : MaxTropical R), x + 0 = x | null | false |
WittVector._sizeOf_1 | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} → {R : Type u_1} → [SizeOf R] → WittVector p R → ℕ | null | false |
String.Legacy.instSizeOfIterator | Init.Data.String.Iterator | SizeOf String.Legacy.Iterator | The size of a string iterator is the number of bytes remaining.
Recursive functions that iterate towards the end of a string will typically decrease this measure.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.