name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
«termΣ'_,_» | Init.NotationExtra | Lean.ParserDescr | null | true |
Lean.LocalContext.modifyLocalDecls | Lean.LocalContext | Lean.LocalContext → (Lean.LocalDecl → Lean.LocalDecl) → Lean.LocalContext | Low-level function for updating every declaration in the local context.
Assumptions about `f`, the resulting nested expressions must be definitionally equal to their original values,
and neither the `index` nor `fvarId` are modified.
| true |
Fintype.card_fin_two | Mathlib.Data.Fintype.Parity | Fact (Even (Fintype.card (Fin 2))) | The cardinality of `Fin 2` is even, `Fact` version.
This `Fact` is needed as an instance by `Matrix.SpecialLinearGroup.instNeg`. | true |
_private.Init.Data.Array.InsertIdx.0.Array.getElem_insertIdx_of_gt._proof_1_1 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {xs : Array α} {i k : ℕ}, k > i → k < i → False | null | false |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.get?.match_1.eq_1 | Batteries.Data.String.Lemmas | ∀ (motive : String → String.Pos.Raw → Sort u_1) (s : String) (p : String.Pos.Raw)
(h_1 : (s : String) → (p : String.Pos.Raw) → motive s p),
(match s, p with
| s, p => h_1 s p) =
h_1 s p | null | true |
CochainComplex.instHasShiftInt._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | 0 = 0 | null | false |
HVertexOperator.compHahnSeries_add | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_5} {Γ' : Type u_6} [inst : PartialOrder Γ] [inst_1 : PartialOrder Γ'] {R : Type u_7} [inst_2 : CommRing R]
{U : Type u_8} {V : Type u_9} {W : Type u_10} [inst_3 : AddCommGroup U] [inst_4 : Module R U]
[inst_5 : AddCommGroup V] [inst_6 : Module R V] [inst_7 : AddCommGroup W] [inst_8 : Module R W]
(A ... | null | true |
MeasurableEquiv.eq_image_iff_symm_image_eq | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] (e : α ≃ᵐ β) (s : Set β)
(t : Set α), s = ⇑e '' t ↔ ⇑e.symm '' s = t | null | true |
Subsemiring.pointwise_smul_le_pointwise_smul_iff₀ | Mathlib.Algebra.Ring.Subsemiring.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : GroupWithZero M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {a : M},
a ≠ 0 → ∀ {S T : Subsemiring R}, a • S ≤ a • T ↔ S ≤ T | null | true |
MonadFunctor.mk.noConfusion | Init.Prelude | {m : semiOutParam (Type u → Type v)} →
{n : Type u → Type w} →
{P : Sort u_1} →
{monadMap monadMap' : {α : Type u} → ({β : Type u} → m β → m β) → n α → n α} →
{ monadMap := monadMap } = { monadMap := monadMap' } → (monadMap ≍ monadMap' → P) → P | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.succ_mod_succ_eq_zero_iff._simp_1_1 | Init.Data.Nat.Lemmas | ∀ (n : ℕ), (n + 1 = 0) = False | null | false |
Lean.Data.AC.Context | Init.Data.AC | Sort u → Type u | null | true |
Turing.ToPartrec.Code.fix.noConfusion | Mathlib.Computability.TuringMachine.Config | {P : Sort u} → {a a' : Turing.ToPartrec.Code} → a.fix = a'.fix → (a = a' → P) → P | null | false |
AlgebraicGeometry.IsAffineOpen.image_of_isOpenImmersion | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} {U : X.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (f : X ⟶ Y) [H : AlgebraicGeometry.IsOpenImmersion f],
AlgebraicGeometry.IsAffineOpen ((AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U) | null | true |
Num.div.eq_1 | Mathlib.Data.Num.ZNum | ∀ (x : Num), Num.zero.div x = 0 | null | true |
RealRMK.rieszMeasure.eq_1 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Real | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : T2Space X] [inst_2 : MeasurableSpace X] [inst_3 : BorelSpace X]
(Λ : CompactlySupportedContinuousMap X ℝ →ₚ[ℝ] ℝ) [inst_4 : LocallyCompactSpace X],
RealRMK.rieszMeasure Λ = (rieszContent (CompactlySupportedContinuousMap.toNNRealLinear Λ)).measure | null | true |
Lean.PersistentHashMap.instGetElemOptionTrue | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
{x : BEq α} → {x_1 : Hashable α} → GetElem (Lean.PersistentHashMap α β) α (Option β) fun x x_2 => True | null | true |
IsPrimitiveRoot.mk | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {ζ : M} {k : ℕ}, ζ ^ k = 1 → (∀ (l : ℕ), ζ ^ l = 1 → k ∣ l) → IsPrimitiveRoot ζ k | null | true |
Lean.Linter.UnusedVariables.FVarDefinition._sizeOf_1 | Lean.Linter.UnusedVariables | Lean.Linter.UnusedVariables.FVarDefinition → ℕ | null | false |
_private.Init.Data.Array.Basic.0.Array.firstM.go._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α), ∀ i < as.size, InvImage (fun x1 x2 => x1 < x2) (fun x => as.size - x) (i + 1) i | null | false |
Projectivization.isCollinear_of_card_eq_two | Mathlib.LinearAlgebra.Projectivization.Collinear | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(S : Set (Projectivization K V)), S.ncard = 2 → Projectivization.IsCollinear S | null | true |
Polynomial.expand_C | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p : ℕ) (r : R), (Polynomial.expand R p) (Polynomial.C r) = Polynomial.C r | null | true |
Filter.Germ.const_top | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : Top β], ↑⊤ = ⊤ | null | true |
MeasureTheory.VectorMeasure.variation.eq_1 | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {X : Type u_1} {mX : MeasurableSpace X} {V : Type u_2} [inst : TopologicalSpace V] [inst_1 : ENormedAddCommMonoid V]
[inst_2 : T2Space V] (μ : MeasureTheory.VectorMeasure X V),
μ.variation = MeasureTheory.preVariation (fun x => ‖μ x‖ₑ) ⋯ ⋯ | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Nat.factorization_lcmUpto._simp_1_5 | Mathlib.NumberTheory.Chebyshev | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
FreeAddGroup.reduceCyclically.addConj_conjugator_reduceCyclically | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} [inst : DecidableEq α] (L : List (α × Bool)),
FreeAddGroup.reduceCyclically.conjugator L ++ FreeAddGroup.reduceCyclically L ++
FreeAddGroup.negRev (FreeAddGroup.reduceCyclically.conjugator L) =
L | null | true |
CategoryTheory.rightDualTensorIso | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(X Y : C) →
[inst_2 : CategoryTheory.HasRightDual X] →
[inst_3 : CategoryTheory.HasRightDual Y] →
[inst_4 : CategoryTheory.HasRightDual (CategoryTheory.MonoidalCategoryS... | The right dual of a tensor product is isomorphic to the reversed tensor product of
the right duals. | true |
CategoryTheory.Mon.forgetMapConeLimitConeIso_hom_hom | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (hc : CategoryTheory.Limits.I... | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula.0.WeierstrassCurve.Affine.nonsingular_negAdd._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a ≠ 0) = (a ≠ 0) | null | false |
Std.Time.PlainDateTime.addWeeks | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Week.Offset → Std.Time.PlainDateTime | Adds a `Week.Offset` to a `PlainDateTime`.
| true |
_private.Mathlib.RingTheory.OrderOfVanishing.Basic.0.Ideal.exact_mulQuot_quotOfMul._simp_1_2 | Mathlib.RingTheory.OrderOfVanishing.Basic | ∀ {α : Type u} [inst : Semiring α] {s : Set α}, Ideal.span s = Submodule.span α s | null | false |
CategoryTheory.GrothendieckTopology.plusCompIso.congr_simp | Mathlib.CategoryTheory.Sites.CompatiblePlus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
(F : CategoryTheory.Functor D E)
[inst_3 :
∀ (J : CategoryTheory.Limits.Multicospan... | null | true |
GroupSeminorm.funLike._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : Group E] (f g : GroupSeminorm E), (fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
Complex.differentiable_iteratedDeriv_sin._f | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ (n : ℕ) (f : Nat.below n), Differentiable ℂ (iteratedDeriv n Complex.sin) | null | false |
List.getElem?_set_self' | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {i : ℕ} {a : α}, (l.set i a)[i]? = Function.const α a <$> l[i]? | This differs from `getElem?_set_self` by monadically mapping `Function.const _ a` over the `Option`
returned by `l[i]?`. | true |
SimpleGraph.mulCayley_univ | Mathlib.Combinatorics.SimpleGraph.Cayley | ∀ {M : Type u_1} [inst : Group M], SimpleGraph.mulCayley Set.univ = ⊤ | null | true |
_private.Mathlib.Order.Interval.Set.OrdConnectedComponent.0.Set.dual_ordConnectedSection._simp_1_4 | Mathlib.Order.Interval.Set.OrdConnectedComponent | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
String.intercalate_cons_cons | Init.Data.String.Lemmas.Intercalate | ∀ {s t u : String} {l : List String}, s.intercalate (t :: u :: l) = t ++ s ++ s.intercalate (u :: l) | null | true |
Std.DHashMap.Raw.Const.getKey?_insertManyIfNewUnit_list_of_mem | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => Unit} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {l : List α} {k : α}, k ∈ m → (Std.DHashMap.Raw.Const.insertManyIfNewUnit m l).getKey? k = m.getKey? k | null | true |
Quiver.freeGroupoidFunctor | Mathlib.CategoryTheory.Groupoid.FreeGroupoid | {V : Type u} →
[inst : Quiver V] →
{V' : Type u'} →
[inst_1 : Quiver V'] → V ⥤q V' → CategoryTheory.Functor (Quiver.FreeGroupoid V) (Quiver.FreeGroupoid V') | The functor of free groupoid induced by a prefunctor of quivers | true |
Nat.add_mod_eq_add_mod_right | Init.Data.Nat.Lemmas | ∀ {a d b : ℕ} (c : ℕ), a % d = b % d → (a + c) % d = (b + c) % d | null | true |
CategoryTheory.Functor.lanAdjunction._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] (L : CategoryTheory.Functor C D) (H : Type u_3)
[inst_2 : CategoryTheory.Category.{u_2, u_3} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
{F : CategoryTheory.F... | null | false |
LinearEquiv.alternatingMapCongrRight._proof_4 | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {ι : Type u_3} {R' : Type u_4} {M'' : Type u_1} {N'' : Type u_5} {N₂'' : Type u_2} [inst : CommSemiring R']
[inst_1 : AddCommMonoid M''] [inst_2 : AddCommMonoid N''] [inst_3 : AddCommMonoid N₂''] [inst_4 : Module R' M'']
[inst_5 : Module R' N''] [inst_6 : Module R' N₂''] (e : N'' ≃ₗ[R'] N₂'') (x : M'' [⋀^ι]→ₗ[R']... | null | false |
NumberField.prod_abs_eq_one | Mathlib.NumberTheory.NumberField.ProductFormula | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {x : K},
x ≠ 0 → (∏ w, w x ^ w.mult) * ∏ᶠ (w : NumberField.FinitePlace K), w x = 1 | The Product Formula for the Number Field `K`. | true |
CategoryTheory.comonadToFunctor._proof_2 | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : CategoryTheory.Comonad C} (f : X ⟶ Y)
(g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).toNatTrans = CategoryTheory.CategoryStruct.comp f.toNatTrans g.toNatTrans | null | false |
Std.TreeMap.containsThenInsertIfNew | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → β → Bool × Std.TreeMap α β cmp | Checks whether a key is present in a map and inserts a value for the key if it was not found.
If the returned `Bool` is `true`, then the returned map is unaltered. If the `Bool` is `false`,
then the returned map has a new value inserted.
Equivalent to (but potentially faster than) calling `contains` followed by `inser... | true |
List.takeWhile._unsafe_rec | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → List α | null | false |
CategoryTheory.Bicategory.Strict.id_comp | Mathlib.CategoryTheory.Bicategory.Strict.Basic | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} [self : CategoryTheory.Bicategory.Strict B] {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f = f | Identity morphisms are left identities for composition. | true |
Affine.Simplex.excenterWeightsUnnorm_map | 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] {V₂ : Type u_3} {P₂ : Type u_4} [inst_4 : NormedAddCommGroup V₂]
[inst_5 : InnerProductSpace ℝ V₂] [inst_6 : MetricSpace P₂] [inst_7 : NormedAddTorsor V₂ P₂] {n : ℕ}... | null | true |
ContextFreeGrammar.reverse_initial | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} (g : ContextFreeGrammar T), g.reverse.initial = g.initial | null | true |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
{P : Sort u} →
{mkNaturalityAssociator :
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.T... | null | false |
IsArtinianRing.equivPi_apply | Mathlib.RingTheory.Artinian.Module | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsArtinianRing R] [inst_2 : IsReduced R] (x : R) (m : MaximalSpectrum R),
(IsArtinianRing.equivPi R) x m = (Ideal.Quotient.mk m.asIdeal) x | null | true |
AList.union_erase | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s₁ s₂ : AList β),
AList.erase a (s₁ ∪ s₂) = AList.erase a s₁ ∪ AList.erase a s₂ | null | true |
_private.ImportGraph.WorkspaceModel.Build.0.ImportGraph.initFn._@.ImportGraph.WorkspaceModel.Build.230814084._hygCtx._hyg.2 | ImportGraph.WorkspaceModel.Build | IO (IO.Ref (Option ImportGraph.WorkspaceModel)) | null | false |
Function.locallyFinsuppWithin.truncate | Mathlib.Topology.LocallyFinsupp | {X : Type u_1} →
[inst : TopologicalSpace X] →
{U : Set X} →
{Y : Type u_3} →
[inst_1 : Zero Y] →
[inst_2 : LinearOrder Y] →
Function.locallyFinsuppWithin U Y → (y : Y) → 0 ≤ y → Function.locallyFinsuppWithin U Y | Truncation of a function with locally finite support: the pointwise minimum with a non-negative
constant `y`.
| true |
Complex.instContinuousMapUniqueHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {A : Type u_2} [inst : TopologicalSpace A] [T2Space A] [inst_2 : Ring A] [inst_3 : StarRing A] [inst_4 : Algebra ℂ A],
ContinuousMap.UniqueHom ℂ A | null | true |
Set.image_fintype_sum_pi | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : Fintype ι] (S : ι → Set α),
(fun f => ∑ i, f i) '' Set.univ.pi S = ∑ i, S i | A special case of `Set.image_finsetSum_pi` for `Finset.univ`. | true |
instToJsonRpcEncodablePacket.toJson._@.Mathlib.Tactic.Widget.Calc.3238076937._hygCtx._hyg.39 | Mathlib.Tactic.Widget.Calc | RpcEncodablePacket✝ → Lean.Json | null | false |
FreeGroup.Lift.aux.eq_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {β : Type v} [inst : Group β] (f : α → β) (L : List (α × Bool)),
FreeGroup.Lift.aux f L = (List.map (fun x => bif x.2 then f x.1 else (f x.1)⁻¹) L).prod | null | true |
ProfiniteGrp._sizeOf_inst | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | SizeOf ProfiniteGrp.{u} | null | false |
LinearMap.BilinForm.isPosSemidef_iff | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : LE R]
{B : LinearMap.BilinForm R M}, B.IsPosSemidef ↔ LinearMap.IsPosSemidef B | A bilinear form is positive semidefinite if and only if it is positive semidefinite
as a sesquilinear form. | true |
Lean.Lsp.instFromJsonWorkspaceFolder.fromJson | Lean.Data.Lsp.Workspace | Lean.Json → Except String Lean.Lsp.WorkspaceFolder | null | true |
NumberField.InfinitePlace.not_isReal_of_mk_isComplex | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] {φ : K →+* ℂ},
(NumberField.InfinitePlace.mk φ).IsComplex → ¬NumberField.ComplexEmbedding.IsReal φ | null | true |
CategoryTheory.sheafify | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
[CategoryTheory.HasWeakSheafify J D] → CategoryTheory.Functor Cᵒᵖ D → CategoryTheory.Functor Cᵒᵖ D | The sheafification of a presheaf `P`. | true |
UpperSet.instMin.eq_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], UpperSet.instMin = { min := fun s t => { carrier := ↑s ∪ ↑t, upper' := ⋯ } } | null | true |
Mathlib.Meta.NormNum.NormNums.mk._flat_ctor | Mathlib.Tactic.NormNum.Core | Lean.Meta.DiscrTree Mathlib.Meta.NormNum.NormNumExt → Lean.PHashSet Lean.Name → Mathlib.Meta.NormNum.NormNums | null | false |
NonUnitalStarSubalgebra.copy | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Star A] → (S : NonUnitalStarSubalgebra R A) → (s : Set A) → s = ↑S → NonUnitalStarSubalgebra R A | Copy of a non-unital star subalgebra with a new `carrier` equal to the old one.
Useful to fix definitional equalities. | true |
Std.DTreeMap.Internal.Impl.Const.get!_insert | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β] (h : t.WF) {k a : α} {v : β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl a =
if compare k a = Ordering.eq then v else Std.DTreeMap.Interna... | null | true |
Lake.DecodeVersion.mk._flat_ctor | Lake.Util.Version | {α : Type u} → (String → Except String α) → Lake.DecodeVersion α | null | false |
PrimeSpectrum.BasicConstructibleSetData.n | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | {R : Type u_1} → PrimeSpectrum.BasicConstructibleSetData R → ℕ | Given the data of a basic constructible set `s = V(g₁, ..., gₙ) \ V(f)`, return `n`. | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBSet.lowerBoundP?_exists.match_1_4 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t : RBTree.RBSet α cmp}
(motive : (∃ x ∈ ↑t, ¬cut x = Ordering.lt) → Prop) (x : ∃ x ∈ ↑t, ¬cut x = Ordering.lt),
(∀ (x : α) (h1 : x ∈ ↑t) (h2 : ¬cut x = Ordering.lt), motive ⋯) → motive x | null | false |
Nat.pos_of_lt_add_left | Init.Data.Nat.Lemmas | ∀ {n k : ℕ}, n < k + n → 0 < k | null | true |
isNilpotent_of_subsingleton | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_3} {x : R} [inst : Zero R] [inst_1 : Pow R ℕ] [Subsingleton R], IsNilpotent x | null | true |
Lean.Grind.AC.Seq.eraseDup._sunfold | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | false |
Nat.floor_lt' | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R} {n : ℕ},
n ≠ 0 → (⌊a⌋₊ < n ↔ a < ↑n) | null | true |
_private.Mathlib.Data.List.TFAE.0.List.exists_tfae._simp_1_2 | Mathlib.Data.List.TFAE | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α} {P : β → Prop}, (∀ i ∈ List.map f l, P i) = ∀ j ∈ l, P (f j) | null | false |
CategoryTheory.Limits.IsImage.fac_lift | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
{F : CategoryTheory.Limits.MonoFactorisation f} (hF : CategoryTheory.Limits.IsImage F)
(F' : CategoryTheory.Limits.MonoFactorisation f), CategoryTheory.CategoryStruct.comp F.e (hF.lift F') = F'.e | null | true |
instT2SpaceWeakSpaceOfSeparatingDual | Mathlib.Analysis.LocallyConvex.WeakSpace | ∀ {R : Type u_4} {V : Type u_5} [inst : CommRing R] [inst_1 : TopologicalSpace R] [T2Space R] [inst_3 : ContinuousAdd R]
[inst_4 : ContinuousConstSMul R R] [inst_5 : AddCommGroup V] [inst_6 : Module R V] [inst_7 : TopologicalSpace V]
[SeparatingDual R V], T2Space (WeakSpace R V) | The weak topology on a space with separating dual is T2 (Hausdorff). | true |
MulMemClass.toSemigroup.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_4} [inst : Semigroup M] {A : Type u_5} [inst_1 : SetLike A M] [inst_2 : MulMemClass A M] (S : A),
MulMemClass.toSemigroup S = { toMul := MulMemClass.mul S, mul_assoc := ⋯ } | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.sliceTo_le_iff._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos},
(q ≤ String.Slice.Pos.ofSliceTo p) = ∃ (h : q ≤ p₀), p₀.sliceTo q h ≤ p | null | false |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.iUnion_Ico_right._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b = Set.Ici a ∩ Set.Iio b | null | false |
Pi.single_apply | Mathlib.Algebra.Notation.Pi.Basic | ∀ {ι : Type u_1} [inst : DecidableEq ι] {M : Type u_7} [inst_1 : Zero M] (i : ι) (x : M) (i' : ι),
Pi.single i x i' = if i' = i then x else 0 | On non-dependent functions, `Pi.single` can be expressed as an `ite` | true |
Lean.Elab.Term.PatternVarDecl.fvarId | Lean.Elab.Match | Lean.Elab.Term.PatternVarDecl → Lean.FVarId | null | true |
_private.Init.Meta.Defs.0.Lean.Syntax.instBEqPreresolved.beq._sparseCasesOn_2 | Init.Meta.Defs | {motive : Lean.Syntax.Preresolved → Sort u} →
(t : Lean.Syntax.Preresolved) →
((n : Lean.Name) → (fields : List String) → motive (Lean.Syntax.Preresolved.decl n fields)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Monad.forget_creates_colimits_of_monad_preserves | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {J : Type u}
[inst_1 : CategoryTheory.Category.{v, u} J] [CategoryTheory.Limits.PreservesColimitsOfShape J T.toFunctor]
(D : CategoryTheory.Functor J T.Algebra) [CategoryTheory.Limits.HasColimit (D.comp T.forget)],
CategoryTh... | For `D : J ⥤ Algebra T`, `D ⋙ forget T` has a colimit, then `D` has a colimit provided colimits
of shape `J` are preserved by `T`.
| true |
WeierstrassCurve.Jacobian.map_polynomialZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Jacobian R) {S : Type s} [inst_1 : CommRing S] (f : R →+* S),
(W'.map f).polynomialZ = (MvPolynomial.map f) W'.polynomialZ | null | true |
Cardinal.toENat_lt_top._simp_1 | Mathlib.SetTheory.Cardinal.ENat | ∀ {c : Cardinal.{u}}, (Cardinal.toENat c < ⊤) = (c < Cardinal.aleph0) | null | false |
Std.Http.Method.link | Std.Http.Data.Method | Std.Http.Method | Create a link relationship between resources.
Source: https://www.rfc-editor.org/rfc/rfc2068#section-19.6.1.2
| true |
Nat.not_isCarmichael_zero | Mathlib.NumberTheory.CarmichaelNumber | ¬Nat.IsCarmichael 0 | null | true |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._proof_22 | Mathlib.CategoryTheory.Bicategory.Monad.Basic | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B],
autoParam
(∀ {a b c d : CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B} (f : a ⟶ b) (g : b ⟶ c) {h h' : c ⟶ d}
(η : h ⟶ h'),
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._aux_9 (CategoryTheory.CategoryStruct.comp f g) η =
Ca... | null | false |
add_sub_add_right_eq_sub | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] (a b c : G), a + c - (b + c) = a - b | null | true |
Primrec.option_some_iff | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {f : α → σ},
(Primrec fun a => some (f a)) ↔ Primrec f | null | true |
MultilinearMap.piFamilyₗ._proof_2 | Mathlib.LinearAlgebra.Multilinear.Pi | ∀ {ι : Type u_2} {κ : ι → Type u_3} {R : Type u_1} {N : ((i : ι) → κ i) → Type u_4} [inst : CommSemiring R]
[inst_1 : (p : (i : ι) → κ i) → AddCommMonoid (N p)] [inst_2 : (p : (i : ι) → κ i) → Module R (N p)],
SMulCommClass R R ((i : (i : ι) → κ i) → N i) | null | false |
CategoryTheory.Functor.CommShift.id_commShiftIso_inv_app | Mathlib.CategoryTheory.Shift.CommShift | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_4} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (x : A) (X : C),
(CategoryTheory.Functor.commShiftIso (CategoryTheory.Functor.id C) x).inv.app X =
CategoryTheory.CategoryStruct.id ((CategoryTheory.shiftFunctor C x).obj X... | null | true |
Filter.atBot_eq_pure_of_isBot | Mathlib.Order.Filter.Ultrafilter.Basic | ∀ {α : Type u} [inst : PartialOrder α] {x : α}, IsBot x → Filter.atBot = pure x | null | true |
AddCommGroup.casesOn | Mathlib.Algebra.Group.Defs | {G : Type u_2} →
{motive : AddCommGroup G → Sort u} →
(t : AddCommGroup G) →
([toAddGroup : AddGroup G] →
(add_comm : ∀ (a b : G), a + b = b + a) → motive { toAddGroup := toAddGroup, add_comm := add_comm }) →
motive t | null | false |
_private.Batteries.Recycling.RBTree.Alter.0.RBTree.RBNode.Path.Ordered.fill.match_1_1 | Batteries.Recycling.RBTree.Alter | ∀ {α : Type u_1} (motive : RBTree.RBNode.Path α → RBTree.RBNode α → Prop) (x : RBTree.RBNode.Path α)
(x_1 : RBTree.RBNode α),
(∀ (x : RBTree.RBNode α), motive RBTree.RBNode.Path.root x) →
(∀ (c : RBTree.RBColor) (parent : RBTree.RBNode.Path α) (v : α) (r x : RBTree.RBNode α),
motive (RBTree.RBNode.Path.... | null | false |
Representation.IntertwiningMap.instAddCommGroup._proof_2 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} [inst : Semiring A] [inst_1 : Monoid G] {V : Type u_3} {W : Type u_4}
[inst_2 : AddCommMonoid V] [inst_3 : AddCommGroup W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W),
autoParam (∀ (a : ρ.IntertwiningMap σ), 0 • a = 0) SubNegMon... | null | false |
Filter.exists_subsingleton_mem_of_forall_separating | Mathlib.Order.Filter.CountableSeparatingOn | ∀ {α : Type u_1} {l : Filter α} [CountableInterFilter l] (p : Set α → Prop) [HasCountableSeparatingOn α p Set.univ],
(∀ (U : Set α), p U → U ∈ l ∨ Uᶜ ∈ l) → ∃ s, s.Subsingleton ∧ s ∈ l | null | true |
UpperSet.mem_Ici_iff | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b ∈ UpperSet.Ici a ↔ a ≤ b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.