name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Sym.eq_nil_of_card_zero | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} (s : Sym α 0), s = Sym.nil | null | true |
QuotientAddGroup.preimage_mk_zero | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] (N : AddSubgroup α), QuotientAddGroup.mk ⁻¹' {↑0} = ↑N | null | true |
definition._proof_9._@.Mathlib.RingTheory.ClassGroup.Basic.3062443935._hygCtx._hyg.2 | Mathlib.RingTheory.ClassGroup.Basic | ∀ (R : Type u_2) (K : Type u_1) [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] (x y : Kˣ),
FractionalIdeal.spanSingleton (nonZeroDivisors R) (↑(x * y))⁻¹ *
FractionalIdeal.spanSingleton (nonZeroDivisors R) ↑(x * y) =
1 | null | false |
_private.Mathlib.Analysis.InnerProductSpace.MeanErgodic.0.«_aux_Mathlib_Analysis_InnerProductSpace_MeanErgodic___macroRules__private_Mathlib_Analysis_InnerProductSpace_MeanErgodic_0_term⟪_,_⟫_1» | Mathlib.Analysis.InnerProductSpace.MeanErgodic | Lean.Macro | null | false |
Lean.KeyedDeclsAttribute.OLeanEntry._sizeOf_1 | Lean.KeyedDeclsAttribute | Lean.KeyedDeclsAttribute.OLeanEntry → ℕ | null | false |
Std.Internal.Do.Spec.forIn_roo | Std.Internal.Do.Triple.SpecLemmas | ∀ {α β : Type u} {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.Internal.Do.Assertion Pred]
[inst_2 : Std.Internal.Do.Assertion EPred] [inst_3 : Std.Internal.Do.WPMonad m Pred EPred] [LawfulMonad m]
[inst_5 : LT α] [inst_6 : DecidableLT α] [inst_7 : Std.PRange.UpwardEnumerable α] [inst_8... | null | true |
Std.TreeMap.Raw.getEntryGED | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → α × β → α × β | Tries to retrieve the key-value pair with the smallest key that is greater than or equal to the
given key, returning `fallback` if no such pair exists.
| true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.sup_pure._simp_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} (a : α), pure a = Filter.principal {a} | null | false |
DihedralGroup.Product | Mathlib.GroupTheory.CommutingProbability | List ℕ → Type | A finite product of Dihedral groups. | true |
CategoryTheory.Preadditive.mk.noConfusion | Mathlib.CategoryTheory.Preadditive.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{P : Sort u_1} →
{homGroup : autoParam ((P Q : C) → AddCommGroup (P ⟶ Q)) CategoryTheory.Preadditive.homGroup._autoParam} →
{add_comp :
autoParam
(∀ (P Q R : C) (f f' : P ⟶ Q) (g : Q ⟶ R),
CategoryTh... | null | false |
_private.Lean.Elab.Tactic.Grind.Sym.0.Lean.Elab.Tactic.Grind.evalSymDSimp | Lean.Elab.Tactic.Grind.Sym | Lean.Elab.Tactic.Grind.GrindTactic | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanlMUnsafe._proof_1 | Batteries.Data.Vector.Basic | ∀ {n : ℕ}, n < USize.size | null | false |
_private.Mathlib.Analysis.InnerProductSpace.LinearPMap.0.LinearPMap.graph_adjoint_toLinearPMap_eq_adjoint._simp_1_2 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Lean.MetavarContext.UnivMVarParamResult.recOn | Lean.MetavarContext | {motive : Lean.MetavarContext.UnivMVarParamResult → Sort u} →
(t : Lean.MetavarContext.UnivMVarParamResult) →
((mctx : Lean.MetavarContext) →
(newParamNames : Array Lean.Name) →
(nextParamIdx : ℕ) →
(expr : Lean.Expr) →
motive { mctx := mctx, newParamNames := newParamNa... | null | false |
Std.TreeMap.recOn | Std.Data.TreeMap.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
{motive : Std.TreeMap α β cmp → Sort u_1} →
(t : Std.TreeMap α β cmp) → ((inner : Std.DTreeMap α (fun x => β) cmp) → motive { inner := inner }) → motive t | null | false |
CategoryTheory.Limits.IsLimit.binaryFanSwap | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{s : CategoryTheory.Limits.BinaryFan X Y} → CategoryTheory.Limits.IsLimit s → CategoryTheory.Limits.IsLimit s.swap | If a binary fan `s` over `X Y` is a limit cone, then `s.swap` is a limit cone over `Y X`. | true |
Array.append_ne_empty_of_left_ne_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α}, xs ≠ #[] → xs ++ ys ≠ #[] | null | true |
Set.image2_union_inter_subset_union | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s s' : Set α} {t t' : Set β},
Set.image2 f (s ∪ s') (t ∩ t') ⊆ Set.image2 f s t ∪ Set.image2 f s' t' | null | true |
CategoryTheory.Abelian.SpectralObject.cyclesIso_inv_cyclesMap | 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₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
{i₀' i₁' i₂' i₃' : ι} (f₁' : i₀' ⟶ i₁') (... | null | true |
Nat.factorial_eq_one._simp_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ {n : ℕ}, (n.factorial = 1) = (n ≤ 1) | null | false |
AffineMap.ofMapMidpoint._proof_1 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {V : Type u_2} {P : Type u_4} {W : Type u_1} {Q : Type u_3} [inst : SeminormedAddCommGroup V]
[inst_1 : PseudoMetricSpace P] [inst_2 : NormedAddTorsor V P] [inst_3 : NormedAddCommGroup W] [inst_4 : MetricSpace Q]
[inst_5 : NormedAddTorsor W Q] [inst_6 : NormedSpace ℝ V] [inst_7 : NormedSpace ℝ W] (f : P → Q),
(... | null | false |
Lean.Lsp.SymbolKind.key.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.key = 1 | null | true |
CommGrpCat.coyoneda_obj_obj_coe | Mathlib.Algebra.Category.Grp.Yoneda | ∀ (M : CommGrpCatᵒᵖ) (N : CommGrpCat), ↑((CommGrpCat.coyoneda.obj M).obj N) = (↑(Opposite.unop M) →* ↑N) | null | true |
CategoryTheory.Bicategory.Adjunction.homEquiv₂.eq_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c},
adj.homEquiv₂ =
{
toFun := fun α =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).inv
(Category... | null | true |
CategoryTheory.yonedaEquiv_symm_naturality_right | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) {F F' : CategoryTheory.Functor Cᵒᵖ (Type v₁)}
(f : F ⟶ F') (x : F.obj (Opposite.op X)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.yonedaEquiv.symm x) f =
CategoryTheory.yonedaEquiv.symm ((CategoryTheory.ConcreteCategory.hom (f.app (Opp... | null | true |
CompleteLat.instConcreteCategoryCompleteLatticeHomCarrier._proof_4 | Mathlib.Order.Category.CompleteLat | ∀ {X Y Z : CompleteLat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g) x = g (f x) | null | false |
TopologicalSpace.Opens.comap_comp | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (g : C(β, γ)) (f : C(α, β)),
TopologicalSpace.Opens.comap (g.comp f) = (TopologicalSpace.Opens.comap f).comp (TopologicalSpace.Opens.comap g) | null | true |
CategoryTheory.NatTrans.Equifibered.whiskerLeft | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {K : Type u_2} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] [inst_2 : CategoryTheory.Category.{v_3, u_2} K]
{F G : CategoryTheory.Functor J C} {α : F ⟶ G},
CategoryTheory.NatTrans.Equifibered α →
∀ (H : CategoryTheory.Functor K J... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.sliceTo_lt_sliceTo_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
GeneralizedBooleanAlgebra.toNonUnitalCommRing._proof_7 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (a : α), symmDiff ⊥ a = a | null | false |
Nat.prod_primeFactorsList | Mathlib.Data.Nat.Factors | ∀ {n : ℕ}, n ≠ 0 → n.primeFactorsList.prod = n | null | true |
_private.Mathlib.Algebra.Group.WithOne.Defs.0.WithZero.unzero.match_1.splitter | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u_1} →
(motive : (x : WithZero α) → x ≠ 0 → Sort u_2) →
(x : WithZero α) → (x_1 : x ≠ 0) → ((x : α) → (x_2 : ↑x ≠ 0) → motive (some x) x_2) → motive x x_1 | null | true |
Lean.Compiler.LCNF.Code.inc.injEq | Lean.Compiler.LCNF.Basic | ∀ {pu : Lean.Compiler.LCNF.Purity} (fvarId : Lean.FVarId) (n : ℕ) (check persistent : Bool)
(k : Lean.Compiler.LCNF.Code pu)
(h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.Alt._auto_15) (fvarId_1 : Lean.FVarId)
(n_1 : ℕ) (check_1 persistent_1 : Bool) (k_1 : Lean.Compiler.LCNF.Code pu)
... | null | true |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {n : ℕ} (hn : autoParam ({ len := n }.len ≤ 2) SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_1)
(hn' : autoParam ({ len := n + 1 }.len ≤ 2) SimplexCategory.Truncated.δ₂_one_comp_σ₂_zero._auto_3),
CategoryTheory.CategoryStruct.comp (SimplexCategory.Truncated.δ₂ 1 hn hn') (SimplexCategory.Truncated.σ₂ 0 hn' h... | null | true |
instContinuousAddULift | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M], ContinuousAdd (ULift.{u, u_3} M) | null | true |
AddMonoidAlgebra.mapDomainAddEquiv._proof_3 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : Add M] [inst_2 : Add N] (e : M ≃ N)
(x y : AddMonoidAlgebra R M),
AddMonoidAlgebra.mapDomain (⇑e) (x + y) = AddMonoidAlgebra.mapDomain (⇑e) x + AddMonoidAlgebra.mapDomain (⇑e) y | null | false |
Std.Tactic.BVDecide.LRAT.Internal.Clause.unit | Std.Tactic.BVDecide.LRAT.Internal.Clause | {α : outParam (Type u)} → {β : Type v} → [self : Std.Tactic.BVDecide.LRAT.Internal.Clause α β] → Std.Sat.Literal α → β | null | true |
CochainComplex.shiftFunctorZero_inv_app_f | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : CochainComplex C ℤ) (n : ℤ),
((CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ).inv.app K).f n = (HomologicalComplex.XIsoOfEq K ⋯).hom | null | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.extract'._simp_1_7 | Batteries.Data.String.Lemmas | ∀ {m k n : ℕ}, (n + m ≤ n + k) = (m ≤ k) | null | false |
Std.Iter.find?_eq_findSome? | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} [inst : Std.Iterator α Id β] [inst_1 : Std.IteratorLoop α Id Id] [Std.Iterators.Finite α Id]
{it : Std.Iter β} {f : β → Bool}, it.find? f = it.findSome? fun x => if f x = true then some x else none | null | true |
CategoryTheory.MorphismProperty.Over.homMk | Mathlib.CategoryTheory.MorphismProperty.Comma | {T : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} T] →
{P Q : CategoryTheory.MorphismProperty T} →
{X : T} →
[inst_1 : Q.IsMultiplicative] →
{A B : P.Over Q X} →
(f : A.left ⟶ B.left) →
autoParam (CategoryTheory.CategoryStruct.comp f B.hom = A.hom)
... | Make a morphism in `P.Over Q X` from a morphism in `T` with compatibilities. | true |
Lean.Elab.Info.ofChoiceInfo.injEq | Lean.Elab.InfoTree.Types | ∀ (i i_1 : Lean.Elab.ChoiceInfo), (Lean.Elab.Info.ofChoiceInfo i = Lean.Elab.Info.ofChoiceInfo i_1) = (i = i_1) | null | true |
CategoryTheory.FreeBicategory.bicategory._proof_7 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u_1} [inst : Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g')
(h : c ⟶ d),
Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_right h) ⋯
(Quot.map (CategoryTheory.FreeBicategory.Hom₂.whisker_left f) ⋯ η) =
CategoryTheory.CategoryStruct.comp
... | null | false |
MeasurableEquiv.IicProdIoc._proof_5 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] [inst_2 : DecidableLE ι] {X : ι → Type u_2}
[inst_3 : LocallyFiniteOrderBot ι] [inst_4 : (i : ι) → MeasurableSpace (X i)] {a b : ι} (hab : a ≤ b),
Measurable
⇑{ toFun := fun x i => if h : ↑i ≤ a then x.1 ⟨↑i, ⋯⟩ else x.2 ⟨↑i, ⋯⟩,
... | null | false |
Std.Internal.List.getValueCastD_filter_not_contains_of_containsKey_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α} {k : α}
{fallback : β k},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.getValueCastD k (List.filter (fun p => !l₂.contains p.fst) l₁) fallba... | null | true |
_private.Mathlib.LinearAlgebra.Projection.0.Submodule.quotientEquivOfIsCompl._simp_4 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{x y : M}, (Submodule.Quotient.mk x = Submodule.Quotient.mk y) = (x - y ∈ p) | null | false |
Equiv.nonUnitalCommSemiring._proof_2 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β] (x y : α),
e (e.symm (e x + e y)) = e x + e y | null | false |
_private.Init.Data.List.MapIdx.0.List.mapIdx_eq_replicate_iff._simp_1_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {a : α} {n : ℕ} {l : List α}, (l = List.replicate n a) = (l.length = n ∧ ∀ b ∈ l, b = a) | null | false |
Lean.Omega.Constraint.not_sat_of_isImpossible | Init.Omega.Constraint | ∀ {c : Lean.Omega.Constraint}, c.isImpossible = true → ∀ {t : ℤ}, ¬c.sat t = true | null | true |
rightAddCoset_mem_rightAddCoset | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] (s : AddSubgroup α) {a : α}, a ∈ s → AddOpposite.op a +ᵥ ↑s = ↑s | null | true |
Lean.Order.FlatOrder.rel.refl | Init.Internal.Order.Basic | ∀ {α : Sort u} {b : α} {x : Lean.Order.FlatOrder b}, x.rel x | null | true |
HasFDerivAt.const_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {𝔸 : Type u_5} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸] {a : E → 𝔸}
{a' : E →L[𝕜] 𝔸}, HasFDerivAt a a' x → ∀ (b : 𝔸), HasFDerivAt (fun y => b * a y) (b • a') x | null | true |
Lean.Elab.InfoTree.node.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} →
{i : Lean.Elab.Info} →
{children : Lean.PersistentArray Lean.Elab.InfoTree} →
{i' : Lean.Elab.Info} →
{children' : Lean.PersistentArray Lean.Elab.InfoTree} →
Lean.Elab.InfoTree.node i children = Lean.Elab.InfoTree.node i' children' →
(i = i' → children = children... | null | false |
MvPowerSeries.isWeightedHomogeneous_weightedHomogeneousComponent | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) (f : MvPowerSeries σ R) (p : ℕ),
MvPowerSeries.IsWeightedHomogeneous w ((MvPowerSeries.weightedHomogeneousComponent w p) f) p | null | true |
CategoryTheory.IsVanKampenColimit | Mathlib.CategoryTheory.Limits.VanKampen | {J : Type v'} →
[inst : CategoryTheory.Category.{u', v'} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor J C} → CategoryTheory.Limits.Cocone F → Prop | A (colimit) cocone over a diagram `F : J ⥤ C` is van Kampen if for every cocone `c'` over the
pullback of the diagram `F' : J ⥤ C'`, `c'` is colimiting iff `c'` is the pullback of `c`.
TODO: Show that this is iff the functor `C ⥤ Catᵒᵖ` sending `x` to `C/x` preserves it.
TODO: Show that this is iff the inclusion funct... | true |
Matrix.reindex_isTotallyUnimodular | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyUnimodular | ∀ {m : Type u_1} {m' : Type u_2} {n : Type u_3} {n' : Type u_4} {R : Type u_5} [inst : CommRing R] (A : Matrix m n R)
(em : m ≃ m') (en : n ≃ n'), ((Matrix.reindex em en) A).IsTotallyUnimodular ↔ A.IsTotallyUnimodular | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic.0.CFC.posPart_negPart_unique._simp_1_4 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {F : Type u_1} {R : outParam (Type u_2)} {S : outParam (Type u_3)} {inst : Star R} {inst_1 : Star S}
{inst_2 : FunLike F R S} [self : StarHomClass F R S] (f : F) (r : R), star (f r) = f (star r) | null | false |
IsLocallyInjective_iff_isOpenEmbedding | Mathlib.Topology.SeparatedMap | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y},
IsLocallyInjective f ↔ Topology.IsOpenEmbedding (toPullbackDiag f) | null | true |
exists_pos_rat_lt | Mathlib.Algebra.Order.Archimedean.Basic | ∀ {K : Type u_4} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [Archimedean K] {x : K},
0 < x → ∃ q, 0 < q ∧ ↑q < x | null | true |
PadicInt.instMetricSpace._proof_24 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] {x y : ℤ_[p]}, dist x y = 0 → x = y | null | false |
NonUnitalStarAlgHomClass.map_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | Lean.Syntax | null | false |
AddSubgroup.isComplement'_top_right._simp_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G}, H.IsComplement' ⊤ = (H = ⊥) | null | false |
instInhabitedCompactum._aux_1 | Mathlib.Topology.Category.Compactum | Compactum | null | false |
CategoryTheory.Limits.Cocone.equivStructuredArrow_unitIso | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor J C),
(CategoryTheory.Limits.Cocone.equivStructuredArrow F).unitIso =
CategoryTheory.NatIso.ofComponents CategoryTheory.Limits.Cocone.eta ⋯ | null | true |
CategoryTheory.MonoOver.image._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [inst_1 : CategoryTheory.Limits.HasImages C]
{f g : CategoryTheory.Over X} (k : f ⟶ g),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.image.lift
{ I := CategoryTheory.Limits.image g.hom, m := CategoryTheory.Limits.image... | null | false |
Lean.JsonRpc.MessageMetaData.responseError.inj | Lean.Data.JsonRpc | ∀ {id : Lean.JsonRpc.RequestID} {code : Lean.JsonRpc.ErrorCode} {message : String} {data? : Option Lean.Json}
{id_1 : Lean.JsonRpc.RequestID} {code_1 : Lean.JsonRpc.ErrorCode} {message_1 : String} {data?_1 : Option Lean.Json},
Lean.JsonRpc.MessageMetaData.responseError id code message data? =
Lean.JsonRpc.Mes... | null | true |
Profinite.NobelingProof.Products.lt_ord_of_lt | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u} [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {l m : Profinite.NobelingProof.Products I}
{o : Ordinal.{u}},
m < l → (∀ i ∈ ↑l, Profinite.NobelingProof.ord I i < o) → ∀ i ∈ ↑m, Profinite.NobelingProof.ord I i < o | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.d₂₁_single_self_inv_ρ_sub_inv_self._abel_1_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u_1, u_1, u_1} k G} (g : G) (a : ↑A),
(((fun₀ | g⁻¹ => a) - fun₀ | 1 => (A.ρ g) a) + fun₀ | g => (A.ρ g) a) -
(((fun₀ | g => (A.ρ g) a) - fun₀ | 1 => a) + fun₀ | g⁻¹ => a) =
(fun₀ | 1 => a) - fun₀ | 1 => (A.ρ g) a | null | false |
Int.Linear.eq_def_cert.eq_1 | Init.Data.Int.Linear | ∀ (x : Int.Linear.Var) (xPoly p : Int.Linear.Poly),
Int.Linear.eq_def_cert x xPoly p = p.beq' (Int.Linear.Poly.add (-1) x xPoly) | null | true |
Std.TreeMap.get_union_of_mem_right | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
(mem : k ∈ t₂), (t₁ ∪ t₂).get k ⋯ = t₂.get k mem | null | true |
NNRatCast.noConfusionType | Mathlib.Data.Rat.Init | Sort u → {K : Type u_1} → NNRatCast K → {K' : Type u_1} → NNRatCast K' → Sort u | null | false |
_private.Mathlib.RingTheory.LaurentSeries.0.LaurentSeries.Cauchy.exists_lb_eventual_support._simp_1_1 | Mathlib.RingTheory.LaurentSeries | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x : R}, (v x < 1) = (v.restrict x < 1) | null | false |
Aesop.StatsExtensionEntry._sizeOf_inst | Aesop.Stats.Extension | SizeOf Aesop.StatsExtensionEntry | null | false |
_private.Mathlib.Algebra.Group.Submonoid.Units.0.Subgroup.mem_units_iff_val_mem._simp_1_3 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {S : Type u_3} {G : Type u_4} [inst : InvolutiveInv G] {x : SetLike S G} [InvMemClass S G] {H : S} {x_1 : G},
(x_1⁻¹ ∈ H) = (x_1 ∈ H) | null | false |
CategoryTheory.RingObjCat.forget_map | Mathlib.CategoryTheory.Monoidal.Ring | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.RingObjCat C} (f : X ⟶ Y),
(CategoryTheory.RingObjCat.forget C).map f = f.hom | null | true |
pi_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {β : Type v} {X : β → Type u_3} [inst : Fintype β] [inst_1 : (b : β) → PseudoMetricSpace (X b)]
[h : ∀ (b : β), ProperSpace (X b)], ProperSpace ((b : β) → X b) | A finite product of proper spaces is proper. | true |
_private.Mathlib.Data.Num.ZNum.0.ZNum.mul_comm | Mathlib.Data.Num.ZNum | ∀ (a b : ZNum), a * b = b * a | null | true |
Lean.Lsp.ServerInfo._sizeOf_inst | Lean.Data.Lsp.InitShutdown | SizeOf Lean.Lsp.ServerInfo | null | false |
Function.Bijective.finite_iff | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β}, Function.Bijective f → (Finite α ↔ Finite β) | null | true |
Order.pred_eq_iff_covBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α], Order.pred a = b ↔ b ⋖ a | null | true |
Real.pow_arith_mean_le_arith_mean_pow_of_even | Mathlib.Analysis.MeanInequalitiesPow | ∀ {ι : Type u} (s : Finset ι) (w z : ι → ℝ),
(∀ i ∈ s, 0 ≤ w i) → ∑ i ∈ s, w i = 1 → ∀ {n : ℕ}, Even n → (∑ i ∈ s, w i * z i) ^ n ≤ ∑ i ∈ s, w i * z i ^ n | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.pow_self_pos._simp_1_1 | Init.Data.Nat.Lemmas | ∀ {a n : ℕ}, (0 < a ^ n) = (0 < a ∨ n = 0) | null | false |
Finset.inf_inv | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] [inst_1 : Inv α] [inst_2 : SemilatticeInf β]
[inst_3 : OrderTop β] (s : Finset α) (f : α → β), s⁻¹.inf f = s.inf fun x => f x⁻¹ | null | true |
Submodule.module'._proof_5 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {S : Type u_3} {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M}
(p : Submodule R M) [inst_2 : Semiring S] [inst_3 : SMul S R] [inst_4 : Module S M] [inst_5 : IsScalarTower S R M]
(x y : S) (b : ↥p), (x * y) • b = x • y • b | null | false |
IntervalIntegrable.comp_add_left_iff._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax | null | false |
IsUltrametricDist.ball_openAddSubgroup.eq_1 | Mathlib.Analysis.Normed.Group.Ultra | ∀ (S : Type u_1) [inst : SeminormedAddGroup S] [inst_1 : IsUltrametricDist S] {r : ℝ} (hr : 0 < r),
IsUltrametricDist.ball_openAddSubgroup S hr =
{ carrier := Metric.ball 0 r, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯, isOpen' := ⋯ } | null | true |
_private.Mathlib.CategoryTheory.Limits.Types.Images.0.CategoryTheory.Limits.Types.limitOfSurjectionsSurjective.preimage._proof_1 | Mathlib.CategoryTheory.Limits.Types.Images | ∀ {F : CategoryTheory.Functor ℕᵒᵖ (Type u_1)}
(hF : ∀ (n : ℕ), Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (F.map (CategoryTheory.homOfLE ⋯).op)))
(a : F.obj (Opposite.op 0)) (n : ℕ),
∃ a_1,
(CategoryTheory.ConcreteCategory.hom (F.map (CategoryTheory.homOfLE ⋯).op)) a_1 =
CategoryTheory.Li... | null | false |
_private.Mathlib.Topology.Order.0.IndiscreteTopology.isClosed_iff._simp_1_2 | Mathlib.Topology.Order | ∀ {α : Type u_1} {t₂ : TopologicalSpace α} [IndiscreteTopology α] (U : Set α), IsOpen U = (U = ∅ ∨ U = Set.univ) | null | false |
Lean.Grind.CommRing.Mon.below | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Mon → Sort u} → Lean.Grind.CommRing.Mon → Sort (max 1 u) | null | false |
_private.Mathlib.Algebra.Central.End.0.LinearEquiv.conjAlgEquiv_ext_iff._simp_1_2 | Mathlib.Algebra.Central.End | ∀ {R₁ : Type u_2} {R₂ : Type u_3} {R₃ : Type u_4} {M₁ : Type u_8} {M₂ : Type u_9} {M₃ : Type u_10} [inst : Semiring R₁]
[inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂]
[inst_5 : AddCommMonoid M₃] {module_M₁ : Module R₁ M₁} {module_M₂ : Module R₂ M₂} {module_M₃ :... | null | false |
_private.Mathlib.Tactic.Explode.0.Mathlib.Explode.explodeCore.match_11 | Mathlib.Tactic.Explode | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((varName : Lean.Name) →
... | null | false |
ValuationSubring.algebra | Mathlib.RingTheory.Valuation.AlgebraInstances | {K : Type u_1} →
[inst : Field K] →
(v : Valuation K (WithZero (Multiplicative ℤ))) →
(L : Type u_2) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
(E : Type u_3) →
[inst_3 : Field E] →
[inst_4 : Algebra K E] →
[inst_5 : Algebra ... | Given an algebra between two field extensions `L` and `E` of a field `K` with a valuation `v`,
create an algebra between their two rings of integers. | true |
WeierstrassCurve.Projective.addXYZ_of_Z_eq_zero_left | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P → P 2 = 0 → W'.addXYZ P Q = (P 1 ^ 2 * Q 2) • Q | null | true |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.mkPathAux.match_1 | Lean.Meta.Sym.Simp.DiscrTree | (motive : Lean.Meta.DiscrTree.Key × Array Lean.Expr → Sort u_1) →
(x : Lean.Meta.DiscrTree.Key × Array Lean.Expr) →
((k : Lean.Meta.DiscrTree.Key) → (todo : Array Lean.Expr) → motive (k, todo)) → motive x | null | false |
MeasureTheory.Measure.restrict_le_self | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α}, μ.restrict s ≤ μ | null | true |
Int16.instUpwardEnumerable | Init.Data.Range.Polymorphic.SInt | Std.PRange.UpwardEnumerable Int16 | null | true |
MonoidHom.map_pow | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (a : M) (n : ℕ), f (a ^ n) = f a ^ n | null | true |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.toCentralizer_equivariant._simp_1_1 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a * b⁻¹ = c) = (a = c * b) | null | false |
Nat.ne_zero_iff_zero_lt | Init.Data.Nat.Basic | ∀ {n : ℕ}, n ≠ 0 ↔ 0 < n | null | true |
instReprSymbol.repr | Mathlib.Computability.Language | {T : Type u_4} → {N : Type u_5} → [Repr T] → [Repr N] → Symbol T N → ℕ → Std.Format | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.