name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.standardσ_simplicialInsert._proof_1_20 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (m₁ a : ℕ) (L : List ℕ) {m : ℕ} (j : ℕ),
m + (a :: L).length + 1 = m₁ → ¬j < a → m + (a :: SimplexCategoryGenRel.simplicialInsert (j + 1) L).length = m₁ | null | false |
Turing.ToPartrec.Cont.then._unsafe_rec | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Cont → Turing.ToPartrec.Cont → Turing.ToPartrec.Cont | null | false |
SimpleGraph.componentComplFunctor._proof_3 | Mathlib.Combinatorics.SimpleGraph.Ends.Defs | ∀ {V : Type u_1} (G : SimpleGraph V) {x Y Z : (Finset V)ᵒᵖ} (h : x ⟶ Y) (h' : Y ⟶ Z),
TypeCat.ofHom (SimpleGraph.ComponentCompl.hom ⋯) =
CategoryTheory.CategoryStruct.comp (TypeCat.ofHom (SimpleGraph.ComponentCompl.hom ⋯))
(TypeCat.ofHom (SimpleGraph.ComponentCompl.hom ⋯)) | null | false |
CategoryTheory.Square.unop_f₁₂ | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (sq : CategoryTheory.Square Cᵒᵖ), sq.unop.f₁₂ = sq.f₂₄.unop | null | true |
CategoryTheory.ShortComplex.RightHomologyData.mk.injEq | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (Q H : C) (p : S.X₂ ⟶ Q) (ι : H ⟶ Q)
(wp : CategoryTheory.CategoryStruct.comp S.f p = 0)
(hp : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofor... | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.MVarErrorInfo.logError.appendExtra | Lean.Elab.Term.TermElabM | Option Lean.MessageData → Lean.MessageData → Lean.MessageData | null | true |
Ideal.Quotient.mk_span_range | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {ι : Type u_1} {R : Type u_3} [inst : Ring R] (f : ι → R) [inst_1 : (Ideal.span (Set.range f)).IsTwoSided] (i : ι),
(Ideal.Quotient.mk (Ideal.span (Set.range f))) (f i) = 0 | null | true |
Nat.Partition.conjugate._proof_1 | Mathlib.Combinatorics.Enumerative.Partition.YoungDiagram | ∀ {n : ℕ} (p : n.Partition), (YoungDiagram.ofPartition p).transpose.card = n | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.TotallyNonneg.0.Matrix.IsTotallyNonneg.smul._proof_1_1 | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyNonneg | ∀ {ι : Type u_2} {R : Type u_1} [inst : PartialOrder ι] [inst_1 : CommRing R] [inst_2 : PartialOrder R]
[IsOrderedRing R] {M : Matrix ι ι R},
M.IsTotallyNonneg →
∀ {c : R},
0 ≤ c → ∀ ⦃n : ℕ⦄ ⦃rows cols : Fin n → ι⦄, StrictMono rows → StrictMono cols → 0 ≤ (c • M.submatrix rows cols).det | null | false |
Lean.Meta.SynthInstance.Answer._sizeOf_inst | Lean.Meta.SynthInstance | SizeOf Lean.Meta.SynthInstance.Answer | null | false |
_private.Mathlib.Geometry.Euclidean.Sphere.Tangent.0.EuclideanGeometry.Sphere.ncard_tangentsFrom_eq_two_of_radius_lt_dist._proof_1_1 | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {P : Type u_1} [inst : MetricSpace P] {s : EuclideanGeometry.Sphere P}, 0 < s.radius → s.radius < 0 → False | null | false |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.Pos.ofSliceTo_prev._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p₀ : s.Pos} {pos pos' : (s.sliceTo p₀).Pos},
(pos = pos') = (String.Slice.Pos.ofSliceTo pos = String.Slice.Pos.ofSliceTo pos') | null | false |
Std.Rxi.instIteratorIteratorIdOfUpwardEnumerable._proof_1 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] (it : Std.IterM Id α),
Std.Rxi.Iterator.Monadic.step it = Std.Rxi.Iterator.Monadic.step it | null | false |
AddMonoidAlgebra.coeff_toMultiplicativeBialgEquiv_apply | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ (R : Type u_1) (A : Type u_3) (M : Type u_8) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A]
[inst_3 : AddMonoid M] (a : AddMonoidAlgebra A M),
((AddMonoidAlgebra.toMultiplicativeBialgEquiv R A M) a).coeff = Finsupp.mapDomain (⇑Multiplicative.ofAdd) a.coeff | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.ne_not_self._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
_private.Mathlib.Algebra.Lie.Weights.RootSystem.0.LieAlgebra.IsKilling.rootSpace_neg_nsmul_add_chainTop_of_lt._simp_1_12 | Mathlib.Algebra.Lie.Weights.RootSystem | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
Set.infsep_empty | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α], ∅.infsep = 0 | null | true |
unitInterval.instConnectedSpaceElemReal | Mathlib.Topology.UnitInterval | ConnectedSpace ↑unitInterval | null | true |
Array.pmap_append | Init.Data.Array.Attach | ∀ {ι : Type u_1} {α : Type u_2} {p : ι → Prop} {f : (a : ι) → p a → α} {xs ys : Array ι} (h : ∀ a ∈ xs ++ ys, p a),
Array.pmap f (xs ++ ys) h = Array.pmap f xs ⋯ ++ Array.pmap f ys ⋯ | null | true |
_private.Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators.0.SheafOfModules.LocalGeneratorsData.shrink._proof_3 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat]
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R}
... | null | false |
Algebra.IsCentral.recOn | Mathlib.Algebra.Central.Defs | {K : Type u} →
[inst : CommSemiring K] →
{D : Type v} →
[inst_1 : Semiring D] →
[inst_2 : Algebra K D] →
{motive : Algebra.IsCentral K D → Sort u_1} →
(t : Algebra.IsCentral K D) → ((out : Subalgebra.center K D ≤ ⊥) → motive ⋯) → motive t | null | false |
Plausible.BoundedRandom.mk.noConfusion | Plausible.Random | {m : Type u → Type u_1} →
{α : Type u} →
{inst : LE α} →
{P : Sort u_2} →
{randomR randomR' :
{g : Type} → (lo hi : α) → lo ≤ hi → [RandomGen g] → Plausible.RandGT g m { a // lo ≤ a ∧ a ≤ hi }} →
{ randomR := randomR } = { randomR := randomR' } → (randomR ≍ randomR' → P) → P | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.LogBounds.0.Complex.hasDerivAt_logTaylor._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
SimpleGraph.ConnectedComponent.Represents | Mathlib.Combinatorics.SimpleGraph.Connectivity.Represents | {V : Type u} → {G : SimpleGraph V} → Set V → Set G.ConnectedComponent → Prop | A set of vertices represents a set of components if it contains exactly one vertex from
each component. | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.all_rotateL._simp_1_6 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {P : α → Prop} {l : Ordnode α} {x : α} {m : Ordnode α} {y : α} {r : Ordnode α},
Ordnode.All P (l.node4L x m y r) = (Ordnode.All P l ∧ P x ∧ Ordnode.All P m ∧ P y ∧ Ordnode.All P r) | null | false |
Std.ExtDTreeMap.alter | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] →
[Std.LawfulEqCmp cmp] →
Std.ExtDTreeMap α β cmp → (a : α) → (Option (β a) → Option (β a)) → Std.ExtDTreeMap α β cmp | Modifies in place the value associated with a given key,
allowing creating new values and deleting values via an `Option` valued replacement function.
This function ensures that the value is used linearly.
| true |
CategoryTheory.RingObjCat.mk | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
(X : C) → [ringObj : CategoryTheory.RingObj X] → CategoryTheory.RingObjCat C | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Cartan.Realisation.0.CartanMatrix.Realisation.weylGroup.induction._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {G : Type u_3} [inst : InvolutiveInv G] {a b : G}, (a = b⁻¹) = (a⁻¹ = b) | null | false |
Lean.ParametricAttribute.setParamFromExt | Lean.Attributes | {α : Type} →
Lean.PersistentEnvExtension (Lean.Name × α) (Lean.Name × α) (List Lean.Name × Lean.NameMap α) →
Lean.AttributeImpl → Lean.Environment → Lean.Name → α → Except String Lean.Environment | null | true |
Monotone.image_lowerBounds_subset_lowerBounds_image | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Monotone f → ∀ {s : Set α}, f '' lowerBounds s ⊆ lowerBounds (f '' s) | null | true |
SimpleGraph.deleteEdges_adj | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} {v w : V} {G : SimpleGraph V} {s : Set (Sym2 V)}, (G.deleteEdges s).Adj v w ↔ G.Adj v w ∧ s(v, w) ∉ s | null | true |
Algebra.Presentation.differentials.comm₁₂ | Mathlib.Algebra.Module.Presentation.Differentials | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(pres : Algebra.Presentation R S ι σ),
pres.toExtension.cotangentComplex ∘ₗ Algebra.Presentation.differentials.hom₁ pres =
↑pres.cotangentSpaceBasis.repr.symm ∘ₗ pres.differentialsRelations.map | null | true |
AddConjClasses.exists_rep | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : AddMonoid α] (a : AddConjClasses α), ∃ a0, AddConjClasses.mk a0 = a | null | true |
Lean.Meta.Sym.DSimp.State.mk.noConfusion | Lean.Meta.Sym.DSimp.DSimpM | {P : Sort u} →
{numSteps : ℕ} →
{cache : Lean.Meta.Sym.DSimp.Cache} →
{numSteps' : ℕ} →
{cache' : Lean.Meta.Sym.DSimp.Cache} →
{ numSteps := numSteps, cache := cache } = { numSteps := numSteps', cache := cache' } →
(numSteps = numSteps' → cache = cache' → P) → P | null | false |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsFiltered.FilteredClosureSmall.bundledAbstractFilteredClosure.match_1._arg_pusher | Mathlib.CategoryTheory.Filtered.Small | ∀ (motive : ℕ → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x) (rel : ℕ → α → Prop) (x : ℕ)
(h_1 : Unit → ((y : α) → rel 0 y → β y) → motive 0) (h_2 : (n : ℕ) → ((y : α) → rel n.succ y → β y) → motive n.succ),
((match (motive := (x : ℕ) → ((y : α) → rel x y → β y) → motive x) x with
| 0 => fun ... | null | false |
Lean.JsonRpc.Notification.ofMessage? | Lean.Data.JsonRpc | Lean.JsonRpc.Message → Option (Lean.JsonRpc.Notification Lean.Json) | null | true |
Height.AdmissibleAbsValues.mk | Mathlib.NumberTheory.Height.Basic | {K : Type u_1} →
[inst : Field K] →
(archAbsVal : Multiset (AbsoluteValue K ℝ)) →
(nonarchAbsVal : Set (AbsoluteValue K ℝ)) →
(∀ v ∈ nonarchAbsVal, IsNonarchimedean ⇑v) →
(∀ {x : K}, x ≠ 0 → Function.HasFiniteMulSupport fun v => ↑v x) →
(∀ {x : K}, x ≠ 0 → (Multiset.map (fun x_... | null | true |
Filter.HasBasis.clusterPt_iff | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {ιX : Sort u_3} {ιF : Sort u_4} {pX : ιX → Prop} {sX : ιX → Set X}
{pF : ιF → Prop} {sF : ιF → Set X} {F : Filter X},
(nhds x).HasBasis pX sX →
F.HasBasis pF sF → (ClusterPt x F ↔ ∀ ⦃i : ιX⦄, pX i → ∀ ⦃j : ιF⦄, pF j → (sX i ∩ sF j).Nonempty) | null | true |
CategoryTheory.Discrete.sumEquiv_unitIso_hom_app | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_1} {K : Type u_2} (X : CategoryTheory.Discrete (J ⊕ K)),
CategoryTheory.Discrete.sumEquiv.unitIso.hom.app X =
(match X.as with
| Sum.inl x => CategoryTheory.Iso.refl { as := Sum.inl x }
| Sum.inr x => CategoryTheory.Iso.refl { as := Sum.inr x }).hom | null | true |
CategoryTheory.ProjectiveResolution.extEquivCohomologyClass_symm_zero | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.ProjectiveResolution X) {n : ℕ},
R.extEquivCohomologyClass.symm 0 = 0 | null | true |
AddEquiv.mk'.congr_simp | Mathlib.Algebra.Category.Grp.ForgetCorepresentable | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] (f f_1 : M ≃ N) (e_f : f = f_1)
(h : ∀ (x y : M), f (x + y) = f x + f y), AddEquiv.mk' f h = AddEquiv.mk' f_1 ⋯ | null | true |
Matrix.one_submatrix_mul | Mathlib.Data.Matrix.Mul | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : Fintype m] [Finite o]
[inst_2 : NonAssocSemiring α] [inst_3 : DecidableEq o] (e₁ : l → o) (e₂ : m ≃ o) (M : Matrix m n α),
Matrix.submatrix 1 e₁ ⇑e₂ * M = M.submatrix (⇑e₂.symm ∘ e₁) id | null | true |
Subrepresentation.submoduleSubrepresentationOrderIso | Mathlib.RepresentationTheory.Subrepresentation | {A : Type u_1} →
{G : Type u_2} →
{M : Type u_4} →
[inst : CommSemiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid M] →
[inst_3 : Module (MonoidAlgebra A G) M] →
Submodule (MonoidAlgebra A G) M ≃o Subrepresentation (Representation.ofModule M) | An order-preserving equivalence between `A[G]`-submodules of an `A[G]`-module M and
subrepresentations of `ρ`. | true |
Mathlib.Meta.Positivity.Strictness.nonzero.sizeOf_spec | Mathlib.Tactic.Positivity.Core | ∀ {u : Lean.Level} {α : Q(Type u)} {zα : Q(Zero «$α»)} {e : Q(«$α»)} {pα? : Option Q(PartialOrder «$α»)}
(pf : Q(«$e» ≠ 0)), sizeOf (Mathlib.Meta.Positivity.Strictness.nonzero pf) = 1 + sizeOf pα? + sizeOf pf | null | true |
Array._sizeOf_1 | Init.SizeOf | {α : Type u} → [SizeOf α] → Array α → ℕ | null | false |
CategoryTheory.functorOfIsEmpty._proof_2 | Mathlib.CategoryTheory.PEmpty | ∀ (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] [inst_2 : IsEmpty C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
isEmptyElim X (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (isEmptyElim X f) (isEmptyElim Y g) | null | false |
Std.DTreeMap.Internal.Impl.contains_minKey | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {he : t.isEmpty = false}, Std.DTreeMap.Internal.Impl.contains (t.minKey he) t = true | null | true |
Commute.geom_sum₂_Ico_mul | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] {x y : R},
Commute x y →
∀ {m n : ℕ}, m ≤ n → (∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ (n - m) * x ^ m | null | true |
SimplexCategoryGenRel.simplicialEvalσ._unsafe_rec | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | List ℕ → ℕ → ℕ | null | false |
Finite.divisionRing_to_field | Mathlib.RingTheory.LittleWedderburn | (D : Type u_1) → [DivisionRing D] → [Finite D] → Field D | **Alias** of `littleWedderburn`.
---
A finite division ring is a field. See `Finite.isDomain_to_isField` and
`Fintype.divisionRingOfIsDomain` for more general statements, but these create data, and therefore
may cause diamonds if used improperly. | true |
CategoryTheory.Limits.cospanExt_hom_app_one | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z X' Y' Z' : C} (iX : X ≅ X') (iY : Y ≅ Y') (iZ : Z ≅ Z')
{f : X ⟶ Z} {g : Y ⟶ Z} {f' : X' ⟶ Z'} {g' : Y' ⟶ Z'}
(wf : CategoryTheory.CategoryStruct.comp iX.hom f' = CategoryTheory.CategoryStruct.comp f iZ.hom)
(wg : CategoryTheory.CategoryStruct.comp i... | null | true |
AlgebraicGeometry.Scheme.IsQuasiAffine.isBasis_basicOpen | Mathlib.AlgebraicGeometry.QuasiAffine | ∀ (X : AlgebraicGeometry.Scheme) [X.IsQuasiAffine],
TopologicalSpace.Opens.IsBasis {x | ∃ r, ∃ (_ : AlgebraicGeometry.IsAffineOpen (X.basicOpen r)), X.basicOpen r = x} | null | true |
ClosureOperator.closure_inf_le | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : SemilatticeInf α] (c : ClosureOperator α) (x y : α), c (x ⊓ y) ≤ c x ⊓ c y | null | true |
Std.HashMap.toList_filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} {f : α → β → Option γ},
(Std.HashMap.filterMap f m).toList.Perm
(List.filterMap (fun p => Option.map (fun x => (p.1, x)) (f p.1 p.2)) m.toList) | null | true |
_private.Mathlib.AlgebraicGeometry.OrderOfVanishing.0.AlgebraicGeometry.Scheme.ord_le_smul._simp_1_2 | Mathlib.AlgebraicGeometry.OrderOfVanishing | ∀ (X : AlgebraicGeometry.Scheme) [inst : AlgebraicGeometry.IsIntegral X] (U : X.Opens) [inst_1 : Nonempty ↥↑U],
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (X.germToFunctionField U)) = True | null | false |
HasFDerivAt.const_smul | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {R : Type u_4} [inst_5 : Monoid R] [inst_6 : DistribMulAction R F]
[inst... | null | true |
Aesop.ScriptGenerated.noConfusion | Aesop.Stats.Basic | {P : Sort u} → {t t' : Aesop.ScriptGenerated} → t = t' → Aesop.ScriptGenerated.noConfusionType P t t' | null | false |
Lean.PersistentHashMap.isEmpty | Lean.Data.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → {x : BEq α} → {x_1 : Hashable α} → Lean.PersistentHashMap α β → Bool | null | true |
Rat.divCasesOn | Mathlib.Data.Rat.Defs | {C : ℚ → Sort u_1} → (a : ℚ) → ((n : ℤ) → (d : ℕ) → d ≠ 0 → n.natAbs.Coprime d → C (↑n / ↑d)) → C a | A version of `Rat.casesOn` that uses `/` instead of `Rat.mk'`. Use as
```lean
cases r with
| div p q nonzero coprime =>
```
| true |
OrderHom.instMonoid._proof_6 | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} [inst : Preorder α] (n : ℕ) (x : α →o α), x ^ (n + 1) = x ^ n * x | null | false |
_private.Batteries.Data.Float.Lemmas.0.Float32.beq_self_eq_false_iff._proof_1_1 | Batteries.Data.Float.Lemmas | ∀ {f : Float32}, (f == f) = false ↔ f = Float32.nan | null | false |
DistLat.ofHom_comp | Mathlib.Order.Category.DistLat | ∀ {X Y Z : Type u} [inst : DistribLattice X] [inst_1 : DistribLattice Y] [inst_2 : DistribLattice Z]
(f : LatticeHom X Y) (g : LatticeHom Y Z),
DistLat.ofHom (g.comp f) = CategoryTheory.CategoryStruct.comp (DistLat.ofHom f) (DistLat.ofHom g) | null | true |
Std.Http.Body.Full.tryRecv | Std.Http.Data.Body.Full | Std.Http.Body.Full → Std.Async.Async (Option (Option Std.Http.Chunk)) | Non-blocking receive. `Full` bodies are always in-memory, so data is always
immediately available. Returns `some chunk` on first call, `some none` (EOF)
once consumed or closed.
| true |
RingEquiv.ofRingHom | Mathlib.Algebra.Ring.Equiv | {R : Type u_4} →
{S : Type u_5} →
[inst : NonAssocSemiring R] →
[inst_1 : NonAssocSemiring S] →
(f : R →+* S) → (g : S →+* R) → f.comp g = RingHom.id S → g.comp f = RingHom.id R → R ≃+* S | If a ring homomorphism has an inverse, it is a ring isomorphism. | true |
Matrix.submatrixEquivInvertibleEquivInvertible_apply | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
[inst_3 : Fintype m] [inst_4 : DecidableEq m] (A : Matrix m m α) (e₁ e₂ : n ≃ m)
(x : Invertible (A.submatrix ⇑e₁ ⇑e₂)),
(A.submatrixEquivInvertibleEquivInvertible e₁ e₂) x = A.invertibleOfSubmatrixEquivInv... | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.ofAbelian._proof_5 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
CategoryTheory.Limits.HasKernel
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryTheory.Limits.cokernel.π S.f)) | null | false |
Submonoid.LocalizationMap.sec.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) (z : N), f.sec z = Classical.choose ⋯ | null | true |
_private.Mathlib.Probability.Independence.Process.HasIndepIncrements.IsGaussianProcess.0.Finset.orderEmbOfFinWithBot | Mathlib.Probability.Independence.Process.HasIndepIncrements.IsGaussianProcess | {T : Type u_1} → [LinearOrder T] → (I : Finset T) → [Bot T] → Fin (I.card + 1) → T | Given a finite set `I : Finset T` of cardinality `n`,
`I.orderEmbOfFinWithBot : Fin (#I + 1) → T` is the map `(⊥, t₁, ..., tₙ)`,
where `t₁ < ... < tₙ` are the elements of `I` and `⊥` is the smallest element of `T`. | true |
UInt32.modn | Init.Data.UInt.Basic | UInt32 → ℕ → UInt32 | null | true |
PresheafOfModules.pullback_id_comp | Mathlib.Algebra.Category.ModuleCat.Presheaf.Pullback | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {R : CategoryTheory.Functor Dᵒᵖ RingCat} {S : CategoryTheory.Functor Cᵒᵖ RingCat}
(φ : S ⟶ F.op.comp R) [inst_2 : (PresheafOfModules.pushforward φ).IsRightAdjoint]... | null | true |
AddSubgroup.eq_bot_iff_forall | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), H = ⊥ ↔ ∀ x ∈ H, x = 0 | null | true |
NumberField.mixedEmbedding_injective | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Function.Injective ⇑(NumberField.mixedEmbedding K) | null | true |
UniformSpaceCat._sizeOf_1 | Mathlib.Topology.Category.UniformSpace | UniformSpaceCat → ℕ | null | false |
_private.Mathlib.Order.Filter.Pi.0.Filter.pi_neBot._simp_1_1 | Mathlib.Order.Filter.Pi | ∀ {α : Type u_1} {f : Filter α}, f.NeBot = (f ≠ ⊥) | null | false |
Std.le_iff_lt_or_eq | Init.Data.Order.Lemmas | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [Std.IsPartialOrder α] {a b : α},
a ≤ b ↔ a < b ∨ a = b | null | true |
BoundedContinuousFunction.instFunLike._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
(f g : BoundedContinuousFunction α β), (fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
_private.Mathlib.RingTheory.NoetherNormalization.0.exists_integral_inj_algHom_of_quotient._proof_1_2 | Mathlib.RingTheory.NoetherNormalization | ∀ (d s : ℕ), s ≤ d → s ≤ d + 1 | null | false |
SheafOfModules.Presentation.map._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_5, u_4} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {C' : Type u_2} [inst_3 : CategoryTheory.Category.{u_3, u_2} C']
... | null | false |
ContDiffMapSupportedIn.structureMapLM._proof_7 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) {E : Type u_3} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : SMulCommClass ℝ 𝕜 F] (i : ℕ), IsBoundedSMul 𝕜 (E [×i]→L[ℝ] F) | null | false |
Valuation.comap_comp | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{S₁ : Type u_7} {S₂ : Type u_8} [inst_2 : Ring S₁] [inst_3 : Ring S₂] (f : S₁ →+* S₂) (g : S₂ →+* R),
Valuation.comap (g.comp f) v = Valuation.comap f (Valuation.comap g v) | null | true |
CategoryTheory.GrothendieckTopology.instCompleteLattice._proof_3 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (a b : CategoryTheory.GrothendieckTopology C),
a ≤
{ sieves := sInf (CategoryTheory.GrothendieckTopology.sieves '' {x | a ≤ x ∧ b ≤ x}), top_mem' := ⋯,
pullback_stable' := ⋯, transitive' := ⋯ } | null | false |
CategoryTheory.Subobject.isoOfMkEq_inv | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (f : A ⟶ B) [inst_1 : CategoryTheory.Mono f]
(X : CategoryTheory.Subobject B) (h : CategoryTheory.Subobject.mk f = X),
(CategoryTheory.Subobject.isoOfMkEq f X h).inv = X.ofLEMk f ⋯ | null | true |
MeasureTheory.integral_vadd_eq_self | Mathlib.MeasureTheory.Group.Integral | ∀ {α : Type u_1} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {G : Type u_5}
[inst_2 : AddGroup G] [inst_3 : MeasurableSpace α] [inst_4 : AddAction G α] [MeasurableConstVAdd G α]
{μ : MeasureTheory.Measure α} [MeasureTheory.VAddInvariantMeasure G α μ] (f : α → E) {g : G},
∫ (x : α), f (... | null | true |
real_inner_self_nonpos | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] {x : F}, inner ℝ x x ≤ 0 ↔ x = 0 | null | true |
CategoryTheory.MorphismProperty.isomorphisms.infer_property | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [hf : CategoryTheory.IsIso f],
CategoryTheory.MorphismProperty.isomorphisms C f | null | true |
LocallyFiniteOrderTop.mk | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
[inst : Preorder α] →
(finsetIoi finsetIci : α → Finset α) →
(∀ (a x : α), x ∈ finsetIci a ↔ a ≤ x) → (∀ (a x : α), x ∈ finsetIoi a ↔ a < x) → LocallyFiniteOrderTop α | null | true |
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.exists_root_sum_quadratic._simp_1_1 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | null | false |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.toDigitsCore.match_1.eq_1 | Mathlib.Data.Nat.Digits.Defs | ∀ (motive : ℕ → ℕ → List Char → Sort u_1) (x : ℕ) (ds : List Char) (h_1 : (x : ℕ) → (ds : List Char) → motive 0 x ds)
(h_2 : (fuel n : ℕ) → (ds : List Char) → motive fuel.succ n ds),
(match 0, x, ds with
| 0, x, ds => h_1 x ds
| fuel.succ, n, ds => h_2 fuel n ds) =
h_1 x ds | null | true |
CategoryTheory.isDetector_separator | Mathlib.CategoryTheory.Generator.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Balanced C]
[inst_2 : CategoryTheory.HasSeparator C], CategoryTheory.IsDetector (CategoryTheory.separator C) | null | true |
UniversalEnvelopingAlgebra.Rel.casesOn | Mathlib.Algebra.Lie.UniversalEnveloping | ∀ {R : Type u₁} {L : Type u₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
{motive : (a a_1 : TensorAlgebra R L) → UniversalEnvelopingAlgebra.Rel R L a a_1 → Prop} {a a_1 : TensorAlgebra R L}
(t : UniversalEnvelopingAlgebra.Rel R L a a_1),
(∀ (x y : L),
motive ((TensorAlgebra.ι R) ⁅x, ... | null | false |
AlgebraicGeometry.PresheafedSpace.GlueData.f_open | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (self : AlgebraicGeometry.PresheafedSpace.GlueData C)
(i j : self.J), AlgebraicGeometry.PresheafedSpace.IsOpenImmersion (self.f i j) | null | true |
Finset.card_eq_three | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α], s.card = 3 ↔ ∃ x y z, x ≠ y ∧ x ≠ z ∧ y ≠ z ∧ s = {x, y, z} | null | true |
TrivSqZeroExt.commRing._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [inst_4 : IsCentralScalar R M] (a b : TrivSqZeroExt R M), a * b = b * a | null | false |
Function.Surjective.addMonoidWithOne | Mathlib.Algebra.Ring.InjSurj | {R : Type u_1} →
{S : Type u_2} →
(f : R → S) →
Function.Surjective f →
[inst : Add S] →
[inst_1 : Zero S] →
[inst_2 : One S] →
[inst_3 : SMul ℕ S] →
[inst_4 : NatCast S] →
[inst_5 : AddMonoidWithOne R] →
f 0 =... | A type endowed with `0`, `1` and `+` is an additive monoid with one, if it admits a surjective
map that preserves `0`, `1` and `*` from an additive monoid with one. See note
[reducible non-instances]. | true |
AddSubgroup.topologicalClosure.eq_1 | Mathlib.Topology.Algebra.Group.Subgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
(s : AddSubgroup G), s.topologicalClosure = { carrier := closure ↑s, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯ } | null | true |
CategoryTheory.ComposableArrows.homMk₃_app_zero | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 3}
(app₀ : f.obj' 0 _proof_311✝ ⟶ g.obj' 0 _proof_311✝)
(app₁ :
f.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₃₁₂._proof_2 ⟶
g.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₃₁₂._proof_2)
(ap... | null | true |
_private.Mathlib.Tactic.Ring.RingNF.0.Mathlib.Tactic.RingNF.initFn._@.Mathlib.Tactic.Ring.RingNF.1278461645._hygCtx._hyg.2 | Mathlib.Tactic.Ring.RingNF | IO Unit | Overrides the default error message in `ring1` to use a prettified version of the goal. | false |
RelSeries.tail._proof_2 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p : RelSeries r) (i : Fin (p.length - 1)), (↑i).succ < p.length | null | false |
CompleteLattice.toLattice | Mathlib.Order.CompleteLattice.Defs | {α : Type u_4} → [self : CompleteLattice α] → Lattice α | null | true |
HomologicalComplex.extend.XIso._proof_1 | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_2} {c : ComplexShape ι} {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c) {i : Option ι} {j : ι}, i = some j → HomologicalComplex.extend.X K i = K.X j | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.