name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
negPart_eq_neg_inf_zero | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddGroup α] [AddLeftMono α] [AddRightMono α] (a : α), a⁻ = -(a ⊓ 0) | null | true |
Lat.Hom._sizeOf_inst | Mathlib.Order.Category.Lat | (X Y : Lat) → SizeOf (X.Hom Y) | null | false |
IsPGroup.commGroupOfCardEqPrimeSq._proof_1 | Mathlib.GroupTheory.PGroup | ∀ {G : Type u_1} [inst : Group G], (QuotientGroup.mk' (Subgroup.center G)).ker ≤ Subgroup.center G | null | false |
Sep.sep | Init.Core | {α : outParam (Type u)} → {γ : Type v} → [self : Sep α γ] → (α → Prop) → γ → γ | Computes `{ a ∈ c | p a }`. | true |
CategoryTheory.Hom.instVAddHom | Mathlib.CategoryTheory.Monoidal.Cartesian.Mod | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{M : C} →
[inst_2 : CategoryTheory.AddMonObj M] →
{X : C} → [CategoryTheory.AddModObj M X] → (Y : C) → VAdd (Y ⟶ M) (Y ⟶ X) | Morphisms `Y ⟶ M` act on morphisms `Y ⟶ X` via the internal additive action. | true |
ProbabilityTheory.IndepFun.mul_hasPDF' | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {G : Type u_2} {mΩ : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω} [inst : Group G]
{mG : MeasurableSpace G} [MeasurableMul₂ G] [MeasurableInv G] {μ : MeasureTheory.Measure G} [μ.IsMulLeftInvariant]
{X Y : Ω → G} [MeasureTheory.SFinite μ] [MeasureTheory.HasPDF X ℙ μ] [MeasureTheory.HasPDF Y ℙ μ]... | null | true |
CategoryTheory.ProjectiveResolution.rec | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} →
{motive : CategoryTheory.ProjectiveResolution Z → Sort u_1} →
((complex : ChainComplex C ℕ) →
... | null | false |
Submodule.orthogonalDecomposition._proof_3 | Mathlib.Analysis.InnerProductSpace.ProdL2 | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomCompTriple (RingHom.id 𝕜) (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
_private.Mathlib.Basic.Real.Basic.0.Real.sup_def | Mathlib.Basic.Real.Basic | ∀ (x x_1 : ℝ),
Real.sup✝ x x_1 =
match x, x_1 with
| { cauchy := x }, { cauchy := y } => { cauchy := Quotient.map₂ (fun x1 x2 => x1 ⊔ x2) ⋯ x y } | null | true |
sub_le_sub_flip | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a b : α}, a - b ≤ b - a ↔ a ≤ b | null | true |
Lean.Lsp.WaitForDiagnosticsParams.noConfusionType | Lean.Data.Lsp.Extra | Sort u → Lean.Lsp.WaitForDiagnosticsParams → Lean.Lsp.WaitForDiagnosticsParams → Sort u | null | false |
RBTree.RBSet.mem_toList | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} {t : RBTree.RBSet α cmp}, x ∈ t.toList ↔ x ∈ ↑t | null | true |
CategoryTheory.Linear.instAlgebraEnd._proof_2 | Mathlib.CategoryTheory.Linear.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {R : Type u_3}
[inst_2 : CommSemiring R] [inst_3 : CategoryTheory.Linear R C] (X : C) (r : R) (x y : CategoryTheory.End X),
r • x * y = r • (x * y) | null | false |
MonoidAlgebra.toAdditive._proof_2 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) (M : Type u_2) [inst : Semiring R] (x : AddMonoidAlgebra R (Additive M)),
(fun x => AddMonoidAlgebra.ofCoeff (Finsupp.mapDomain (⇑Additive.ofMul) x.coeff))
((fun x => MonoidAlgebra.ofCoeff (Finsupp.mapDomain (⇑Additive.toMul) x.coeff)) x) =
x | null | false |
Set.encard_eq_top | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, s.Infinite → s.encard = ⊤ | **Alias** of the reverse direction of `Set.encard_eq_top_iff`. | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Pos.ofToSlice_prev._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p q : s.Pos}, (p = q) = (p.toSlice = q.toSlice) | null | false |
Std.Internal.List.getValueCast!.congr_simp | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] (a : α) [inst_2 : Inhabited (β a)]
(l l_1 : List ((a : α) × β a)), l = l_1 → Std.Internal.List.getValueCast! a l = Std.Internal.List.getValueCast! a l_1 | null | true |
_private.Mathlib.Order.BooleanAlgebra.Set.0.Set.insert_sdiff_of_mem._proof_1_1 | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {t : Set α} {a : α} (s : Set α), a ∈ t → insert a s \ t = s \ t | null | false |
String.Pos.Raw.byteIdx_dec | Init.Data.String.PosRaw | ∀ {p : String.Pos.Raw}, p.dec.byteIdx = p.byteIdx - 1 | null | true |
Int.bmod_add_bdiv' | Init.Data.Int.DivMod.Lemmas | ∀ (x : ℤ) (m : ℕ), x.bmod m + x.bdiv m * ↑m = x | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.summable_exp_nat_mul_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {x : ℝ}, (Real.exp x < 1) = (x < 0) | null | false |
CategoryTheory.Pseudofunctor.mkOfOplax' | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(F : CategoryTheory.OplaxFunctor B C) →
[∀ (a : B), CategoryTheory.IsIso (F.mapId a)] →
[∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g)] ... | Construct a pseudofunctor from an oplax functor whose `mapId` and `mapComp` are isomorphisms. | true |
Stream'.Seq.corec_cons | Mathlib.Data.Seq.Defs | ∀ {α : Type u} {β : Type v} {f : β → Option (α × β)} {b : β} {x : α} {s : β},
f b = some (x, s) → Stream'.Seq.corec f b = Stream'.Seq.cons x (Stream'.Seq.corec f s) | null | true |
NonUnitalStarAlgebra.gc | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A], GaloisConnection (NonUnitalStarAlgebra.adjoin R) SetLike.coe | null | true |
Polynomial.integralNormalization_aeval_smul | Mathlib.RingTheory.Polynomial.IntegralNormalization | ∀ {S : Type v} [inst : CommSemiring S] {R : Type u_2} [inst_1 : CommSemiring R] [inst_2 : Algebra R S]
{p : Polynomial R},
1 ≤ p.natDegree →
∀ (x : S),
(Polynomial.aeval (p.leadingCoeff • x)) p.integralNormalization =
p.leadingCoeff ^ (p.natDegree - 1) • (Polynomial.aeval x) p | null | true |
AlgebraicGeometry.Scheme.Modules.instAdditivePushforward | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y), (AlgebraicGeometry.Scheme.Modules.pushforward f).Additive | null | true |
CategoryTheory.MonoidalCategory.tensorMonoidal._proof_6 | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : C × C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.tensorδ X.1 X.2 Y.1 Y.2)
(CategoryTheory.MonoidalCategory.tensorμ X.1 X.2 Y... | null | false |
IsBaseChange.of_comp | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {M : Type v₁} {N : Type v₂} {S : Type v₃} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N]
[inst_2 : CommSemiring R] [inst_3 : CommSemiring S] [inst_4 : Algebra R S] [inst_5 : Module R M] [inst_6 : Module R N]
[inst_7 : Module S N] [inst_8 : IsScalarTower R S N] {T : Type u_4} {O : Type u_5} [in... | If `N` is the base change of `M` to `S` and `O` the base change of `M` to `T`, then
`O` is the base change of `N` to `T`. | true |
Matrix.symm_reindexAddEquiv | Mathlib.LinearAlgebra.Matrix.Reindex | ∀ {m : Type u_1} {n : Type u_2} {m' : Type u_4} {n' : Type u_5} (R : Type u_9) [inst : Add R] (eₘ : m ≃ m')
(eₙ : n ≃ n'), (Matrix.reindexAddEquiv R eₘ eₙ).symm = Matrix.reindexAddEquiv R eₘ.symm eₙ.symm | null | true |
Lean.Server.DirectImports.mk.injEq | Lean.Server.References | ∀ (ordered : Array Lean.Server.ModuleImport) (index : Lean.Server.ModuleImportIndex)
(ordered_1 : Array Lean.Server.ModuleImport) (index_1 : Lean.Server.ModuleImportIndex),
({ ordered := ordered, index := index } = { ordered := ordered_1, index := index_1 }) =
(ordered = ordered_1 ∧ index = index_1) | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated.0.CategoryTheory.Pretriangulated.Opposite.distinguished_cocone_triangle._simp_1_1 | Mathlib.CategoryTheory.Triangulated.Opposite.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(T : CategoryT... | null | false |
Aesop.ExtResult.mk.injEq | Aesop.Util.Tactic.Ext | ∀ (depth : ℕ) (commonFVarIds : Array Lean.FVarId) (goals : Array (Lean.MVarId × Array Lean.FVarId)) (depth_1 : ℕ)
(commonFVarIds_1 : Array Lean.FVarId) (goals_1 : Array (Lean.MVarId × Array Lean.FVarId)),
({ depth := depth, commonFVarIds := commonFVarIds, goals := goals } =
{ depth := depth_1, commonFVarIds :... | null | true |
OrderIso.isAtomic_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : OrderBot α]
[inst_3 : OrderBot β] (f : α ≃o β), IsAtomic α ↔ IsAtomic β | null | true |
CategoryTheory.WithInitial.incl._proof_1 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
CategoryTheory.CategoryStruct.id X = CategoryTheory.CategoryStruct.id (CategoryTheory.WithInitial.of X) | null | false |
Std.ExtHashSet.get? | Std.Data.ExtHashSet.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → [EquivBEq α] → [LawfulHashable α] → Std.ExtHashSet α → α → Option α | Checks if given key is contained and returns the key if it is, otherwise `none`.
The result in the `some` case is guaranteed to be pointer equal to the key in the set.
| true |
Lean.IR.Alt._sizeOf_3_eq | Lean.Compiler.IR.Basic | ∀ (x : Array Lean.IR.Alt), Lean.IR.Alt._sizeOf_3 x = sizeOf x | null | false |
ContinuousWithinAt.cfcₙ._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
Std.Internal.Parsec.Error | Std.Internal.Parsec.Basic | Type | Represents an error that can occur during parsing.
| true |
Manifold.LiftSourceTargetPropertyAt.localPresentationAt | Mathlib.Geometry.Manifold.LocalSourceTargetProperty | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_4} →
{H : Type u_6} →
{G : Type u_8} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 ... | A choice of charts witnessing the local property `P` of `f` at `x`. | true |
Filter.HasBasis.specializes_iff | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X} {ι : Sort u_7} {p : ι → Prop} {s : ι → Set X},
(nhds y).HasBasis p s → (x ⤳ y ↔ ∀ (i : ι), p i → x ∈ s i) | null | true |
Aesop.CompleteMatch.mk | Aesop.Forward.Match.Types | Array Aesop.Match → Aesop.CompleteMatch | null | true |
CategoryTheory.Arrow.LeftHomotopy.compLeftId | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{u v : CategoryTheory.Arrow V} →
{f : v ⟶ v} →
CategoryTheory.Arrow.LeftHomotopy f (CategoryTheory.CategoryStruct.id v) →
(g : u ⟶ v) → CategoryTheory.Arrow.LeftHomotopy (... | A variant of `LeftHomotopy.compLeft` useful for dealing with homotopy equivalences. | true |
Std.TreeMap.getElem!_ofList_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} [inst_2 : Inhabited β],
(List.map Prod.fst l).contains k = false → (Std.TreeMap.ofList l cmp)[k]! = default | null | true |
Std.Http.RequestTarget.authorityForm.elim | Std.Http.Data.URI.Basic | {motive : Std.Http.RequestTarget → Sort u} →
(t : Std.Http.RequestTarget) →
t.ctorIdx = 2 →
((authority : Std.Http.URI.Authority) → motive (Std.Http.RequestTarget.authorityForm authority)) → motive t | null | false |
CategoryTheory.NonemptyParallelPairPresentationAux.ι₁ | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} →
(f g : A ⟶ B) →
(P₁ : CategoryTheory.Limits.IndObjectPresentation A) →
(P₂ : CategoryTheory.Limits.IndObjectPresentation B) →
(CategoryTheory.NonemptyParallelPairPresent... | Implementation; see `nonempty_indParallelPairPresentation`. | true |
CategoryTheory.ShortComplex.isIso_homologyMap'_of_isIso | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [CategoryTheory.IsIso φ] (h₁ : S₁.HomologyData)
(h₂ : S₂.HomologyData), CategoryTheory.IsIso (CategoryTheory.ShortComplex.homologyMap' φ h₁ h₂) | null | true |
InverseSystem.PEquivOn.ctorIdx | Mathlib.Order.DirectedInverseSystem | {ι : Type u_6} →
{F : ι → Type u_7} →
{X : ι → Type u_8} →
{inst : LinearOrder ι} →
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} →
{inst_1 : SuccOrder ι} →
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} →
{s : Set ι} → InverseSystem.PEquivOn f equivSucc s ... | null | false |
Std.Time.Duration.instLT | Std.Time.Duration | LT Std.Time.Duration | null | true |
ProbabilityTheory.betaMeasure | Mathlib.Probability.Distributions.Beta | ℝ → ℝ → MeasureTheory.Measure ℝ | Measure defined by the beta distribution. | true |
OrderDual.instNonAssocSemiring | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [NonAssocSemiring R] → NonAssocSemiring Rᵒᵈ | null | true |
Std.Iterators.Types.TakeWhile.instProductive | Std.Data.Iterators.Combinators.Monadic.TakeWhile | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Monad m] [inst_1 : Std.Iterator α m β]
[Std.Iterators.Productive α m] {P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)},
Std.Iterators.Productive (Std.Iterators.Types.TakeWhile α m β P) m | null | true |
Profinite.IndexFunctor.π_app._proof_1 | Mathlib.Topology.Category.Profinite.Product | ∀ {ι : Type u_1} {X : ι → Type} [inst : (i : ι) → TopologicalSpace (X i)] (C : Set ((i : ι) → X i)) (J : ι → Prop),
Set.MapsTo (⇑(ContinuousMap.precomp Subtype.val)) C (⇑(ContinuousMap.precomp Subtype.val) '' C) | null | false |
CategoryTheory.instAbelianInd._proof_1 | Mathlib.CategoryTheory.Abelian.Indization | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.Limits.HasKernels (CategoryTheory.Ind C) | null | false |
ProbabilityTheory.covarianceOperator_apply | Mathlib.Probability.Moments.CovarianceBilin | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : MeasurableSpace E]
[inst_3 : BorelSpace E] {μ : MeasureTheory.Measure E} [inst_4 : CompleteSpace E],
MeasureTheory.MemLp id 2 μ → ∀ (x : E), (ProbabilityTheory.covarianceOperator μ) x = ∫ (y : E), inner ℝ x y • y ∂μ | null | true |
CategoryTheory.Bicategory.LeftExtension.whiskering._proof_4 | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : a ⟶ b} {g : a ⟶ c} {x : B} (h : c ⟶ x)
(X : CategoryTheory.Bicategory.LeftExtension f g),
CategoryTheory.Bicategory.LeftExtension.homMk
(CategoryTheory.Bicategory.whiskerRight
(CategoryTheory.StructuredArrow.Hom.right (CategoryTheo... | null | false |
ProperlyDiscontinuousSMul.recOn | Mathlib.Topology.Algebra.ConstMulAction | {Γ : Type u_4} →
{T : Type u_5} →
[inst : TopologicalSpace T] →
[inst_1 : SMul Γ T] →
{motive : ProperlyDiscontinuousSMul Γ T → Sort u} →
(t : ProperlyDiscontinuousSMul Γ T) →
((finite_disjoint_inter_image :
∀ {K L : Set T}, IsCompact K → IsCompact L → {γ | ((... | null | false |
Topology.CWComplex.Subcomplex.mk''_I | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] [inst : T2Space X] (C : Set X) [h : Topology.CWComplex C] (E : Set X)
(I : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)) [inst_1 : Topology.CWComplex E]
(union : ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = E) (n : ℕ),
(Topology.CWComplex.Subcomplex.mk'' C E I union)... | null | true |
Lean.Meta.SynthInstance.State.mk._flat_ctor | Lean.Meta.SynthInstance | Option Lean.Meta.AbstractMVarsResult →
Array Lean.Meta.SynthInstance.GeneratorNode →
Array (Lean.Meta.SynthInstance.ConsumerNode × Lean.Meta.SynthInstance.Answer) →
Std.HashMap Lean.Expr Lean.Meta.SynthInstance.TableEntry → Lean.Meta.SynthInstance.State | null | false |
Lean.Elab.Command.PreElabHeaderResult.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{view : Lean.Elab.Command.InductiveView} →
{levelNames : List Lean.Name} →
{numParams : ℕ} →
{type : Lean.Expr} →
{origParams : Array Lean.Expr} →
{view' : Lean.Elab.Command.InductiveView} →
{levelNames' : List Lean.Name} →
{numParam... | null | false |
_private.Mathlib.InformationTheory.KullbackLeibler.Basic.0.InformationTheory.klDiv_ne_top_iff._simp_1_1 | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
(InformationTheory.klDiv μ ν = ⊤) = (μ.AbsolutelyContinuous ν → ¬MeasureTheory.Integrable (MeasureTheory.llr μ ν) μ) | null | false |
Real.cosPartialEquiv._proof_6 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ x ∈ Set.Icc (-1) 1, Real.cos (Real.arccos x) = x | null | false |
CategoryTheory.Abelian.SpectralObject.cyclesIsoH.congr_simp | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ : ι} (f : i₀ ⟶ i₁) (n₀ n₁ n₁_1 : ℤ) (e_n₁ : n₁ = n₁_1)
(hn₁ : n₀ + 1 = n₁), X.cyclesIsoH f n₀ n₁ ... | null | true |
CuspForm.translate._proof_1 | Mathlib.NumberTheory.ModularForms.NormTrace | ∀ {𝒢 : Subgroup (GL (Fin 2) ℝ)} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {k : ℤ} (f : F) (g : GL (Fin 2) ℝ)
[inst_1 : CuspFormClass F 𝒢 k] {c : OnePoint ℝ},
IsCusp c (ConjAct.toConjAct g⁻¹ • 𝒢) →
∀ (γ : GL (Fin 2) ℝ),
γ • OnePoint.infty = c → UpperHalfPlane.IsZeroAtImInfty (SlashAction.map k ... | null | false |
Array.foldlM_congr | Init.Data.Array.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {start start' stop stop' : ℕ} {m : Type u_1 → Type u_3} [inst : Monad m]
{f g : β → α → m β} {b : β} {xs xs' : Array α},
xs = xs' →
(∀ (x : β) (y : α), f x y = g x y) →
start = start' → stop = stop' → Array.foldlM f b xs start stop = Array.foldlM g b xs' start' stop' | null | true |
HasDerivWithinAt.div_const | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {𝕜' : Type u_2} [inst_1 : NormedDivisionRing 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {c : 𝕜 → 𝕜'} {c' : 𝕜'},
HasDerivWithinAt c c' s x → ∀ (d : 𝕜'), HasDerivWithinAt (fun x => c x / d) (c' / d) s x | null | true |
FiniteGaloisIntermediateField.ctorIdx | Mathlib.FieldTheory.Galois.GaloisClosure | {k : Type u_1} →
{K : Type u_2} →
{inst : Field k} → {inst_1 : Field K} → {inst_2 : Algebra k K} → FiniteGaloisIntermediateField k K → ℕ | null | false |
Nat.iSup_of_not_bddAbove | Mathlib.Order.Lattice.Nat | ∀ {ι : Sort u_1} {f : ι → ℕ}, ¬BddAbove (Set.range f) → ⨆ i, f i = 0 | null | true |
CategoryTheory.Limits.hasColimit_inverse_equivalence_comp_iff | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor J C} (e : J ≌ K),
CategoryTheory.Limits.HasColimit (e.inverse.comp F) ↔ CategoryTheory.Limits.HasColimit F | null | true |
AlgebraicGeometry.openToLocalization._proof_4 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (U : TopologicalSpace.Opens ↑(ProjectiveSpectrum.top 𝒜)) (x : ↑(ProjectiveSpectrum.top 𝒜))
(hx : x ∈ U), ↑0 ⟨x, hx⟩ = ↑0 ⟨x, hx⟩ | null | false |
Module.flat_of_localized_span | Mathlib.RingTheory.Flat.Localization | ∀ (S : Type u_2) [inst : CommSemiring S] (M : Type u_3) [inst_1 : AddCommMonoid M] [inst_2 : Module S M] (s : Set S),
Ideal.span s = ⊤ → (∀ (r : ↑s), Module.Flat S (LocalizedModule.Away (↑r) M)) → Module.Flat S M | null | true |
MagmaCat.delabOf | Mathlib.Algebra.Category.Semigrp.Basic | Lean.PrettyPrinter.Delaborator.Delab | This prints `MagmaCat.of X` as `↧X`. | true |
joinedIn_univ._simp_1 | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, JoinedIn Set.univ x y = Joined x y | null | false |
ProofWidgets.ExprWithCtx.noConfusion | ProofWidgets.Compat | {P : Sort u} → {t t' : ProofWidgets.ExprWithCtx} → t = t' → ProofWidgets.ExprWithCtx.noConfusionType P t t' | null | false |
LieDerivation.instLinearMapClass | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M],
LinearMapClass (LieDerivation R L M) R L M | null | true |
RingHom.asBoolAlg_id | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α], (RingHom.id α).asBoolAlg = BoundedLatticeHom.id (AsBoolAlg α) | null | true |
_private.Mathlib.RingTheory.WittVector.IsPoly.0.WittVector._aux_Mathlib_RingTheory_WittVector_IsPoly___macroRules__private_Mathlib_RingTheory_WittVector_IsPoly_0_WittVector_term𝕎_1 | Mathlib.RingTheory.WittVector.IsPoly | Lean.Macro | null | false |
Affine.Simplex.exradius_empty | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n), s.exradius ∅ = s.inradius | null | true |
SchwartzMap.instFourierPair | Mathlib.Analysis.Distribution.SchwartzSpace.Fourier | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_3} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
[CompleteSpace E], FourierPair (SchwartzMap V E) (SchwartzMap V E) | null | true |
TopologicalSpace.NonemptyCompacts.isEmbedding_singleton | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α], Topology.IsEmbedding fun x => {x} | null | true |
KuratowskiEmbedding.embeddingOfSubset | Mathlib.Topology.MetricSpace.Kuratowski | {α : Type u} → [MetricSpace α] → (ℕ → α) → α → ↥(lp (fun x => ℝ) ⊤) | A metric space can be embedded in `l^∞(ℝ)` via the distances to points in
a fixed countable set, if this set is dense. This map is given in `kuratowskiEmbedding`,
without density assumptions. | true |
Plausible.Rat.shrinkable | Mathlib.Testing.Plausible.Sampleable | Plausible.Shrinkable ℚ | null | true |
modularCyclotomicCharacter.id | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | ∀ {L : Type u} [inst : CommRing L] [inst_1 : IsDomain L] (n : ℕ) [inst_2 : NeZero n],
modularCyclotomicCharacter.toFun n (RingEquiv.refl L) = 1 | null | true |
_private.Mathlib.Data.Set.Insert.0.Set.inter_insert_of_notMem._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, a ∉ s → s ∩ insert a t = s ∩ t | null | false |
CategoryTheory.InjectiveResolution.descFSucc._proof_5 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
(I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z) (n : ℕ)
(g : J.cocomplex.X n ⟶ I.cocomplex.X n) (g' : J.cocomplex.X (n + 1) ⟶ I.cocomplex.X (n + 1))
(w :
CategoryT... | null | false |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.emitLLVM.match_1 | Lean.Compiler.IR.EmitLLVM | (llvmctx : Lean.LLVM.Context) →
(motive : Option (Lean.LLVM.Value llvmctx) → Sort u_1) →
(__x : Option (Lean.LLVM.Value llvmctx)) →
((global : Lean.LLVM.Value llvmctx) → motive (some global)) →
((x : Option (Lean.LLVM.Value llvmctx)) → motive x) → motive __x | null | false |
_private.Lean.Meta.Tactic.Simp.SimpCongrTheorems.0.Lean.Meta.addSimpCongrTheoremEntry.insert._f | Lean.Meta.Tactic.Simp.SimpCongrTheorems | Lean.Meta.SimpCongrTheorem → (a : List Lean.Meta.SimpCongrTheorem) → List.below a → List Lean.Meta.SimpCongrTheorem | null | false |
Int.ofNat_fmod | Init.Data.Int.DivMod.Lemmas | ∀ (m n : ℕ), ↑(m % n) = (↑m).fmod ↑n | null | true |
CompleteType.isClopen_typesWith | Mathlib.ModelTheory.Topology.Types | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type u_1} (φ : (L.withConstants α).Sentence), IsClopen (T.typesWith φ) | null | true |
PUnit.normedAlgebra._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_2) [inst : NormedField 𝕜] (q : 𝕜) (x : PUnit.{u_1 + 1}), ‖q • x‖ ≤ ‖q‖ * ‖x‖ | null | false |
Std.Sat.AIG.RefVec.cast' | Std.Sat.AIG.RefVec | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{len : ℕ} →
{aig1 aig2 : Std.Sat.AIG α} →
(s : aig1.RefVec len) →
((∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig1.decls.size) →
∀ {i : ℕ} (h : i < len), s.refs[i].gate < aig2.decls.size) →
... | null | true |
CategoryTheory.Limits.isKernelOfComp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {W : C} (g : Y ⟶ W) (h : X ⟶ W) {c : CategoryTheory.Limits.KernelFork h}
(i : CategoryTheory.Limits.IsLimit c) (hf : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork... | null | false |
_private.Mathlib.Topology.Maps.Strict.Group.0.MonoidHom.isStrictMap_prodMap_iff._simp_1_1 | Mathlib.Topology.Maps.Strict.Group | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {f : G →* H} [inst_2 : TopologicalSpace G]
[inst_3 : TopologicalSpace H] [IsTopologicalGroup G], Topology.IsStrictMap ⇑f = IsOpenQuotientMap ⇑f.rangeRestrict | null | false |
_private.Init.Data.Array.GetLit.0.List.take.match_1.eq_1 | Init.Data.Array.GetLit | ∀ {α : Type u_1} (motive : ℕ → List α → Sort u_2) (x : List α) (h_1 : (x : List α) → motive 0 x)
(h_2 : (n : ℕ) → motive n.succ []) (h_3 : (n : ℕ) → (a : α) → (as : List α) → motive n.succ (a :: as)),
(match 0, x with
| 0, x => h_1 x
| n.succ, [] => h_2 n
| n.succ, a :: as => h_3 n a as) =
h_1 x | null | true |
Lean.Elab.InlayHint.noConfusion | Lean.Elab.InfoTree.InlayHints | {P : Sort u} → {t t' : Lean.Elab.InlayHint} → t = t' → Lean.Elab.InlayHint.noConfusionType P t t' | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.pIntegral_bernoulli_even_term._simp_1_7 | Mathlib.NumberTheory.Bernoulli | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds.0.Real.abs_arctan_le_abs._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds | ∀ {x : ℝ}, |Real.arctan x| ≤ |x| | null | false |
ValuationSubring.ofLE._proof_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (R : ValuationSubring K) (S : Subring K),
R.toSubring ≤ S → ∀ (x : K), x ∈ S.carrier ∨ x⁻¹ ∈ S.carrier | null | false |
SkewMonoidAlgebra.instNonAssocSemiring._proof_4 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_2} {G : Type u_1} [inst : Semiring k] [inst_1 : Monoid G] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Std.DHashMap.Raw.Const.get?_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, k ∈ m₂ → Std.DHashMap.Raw.Const.get? (m₁ ∩ m₂) k = Std.DHashMap.Raw.Const.get? m₁ k | null | true |
Std.TreeMap.Raw.getKey!_eq_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α], t.WF → ∀ {k : α}, t.contains k = true → t.getKey! k = k | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.