name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Basic.0.Lean.initFn._@.Lean.Meta.Basic.2682336532._hygCtx._hyg.2 | Lean.Meta.Basic | IO Unit | null | false |
CategoryTheory.Localization.homEquiv_comp | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C : Type u_1} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_5, u_5} D₁] [inst_2 : CategoryTheory.Category.{v_6, u_6} D₂]
(W : CategoryTheory.MorphismProperty C) (L₁ : CategoryTheory.Functor C D₁) [inst_3 : L₁.IsLocalization W]
(L₂ : CategoryT... | null | true |
normalizedGCDMonoidOfGCD._proof_4 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] [inst_2 : DecidableEq α]
(gcd : α → α → α) (gcd_dvd_left : ∀ (a b : α), gcd a b ∣ a) (x : α),
(if 0 = 0 then 0 else normalize (Classical.choose ⋯)) = 0 | null | false |
Subalgebra.centralizer_le | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (s t : Set A),
s ⊆ t → Subalgebra.centralizer R t ≤ Subalgebra.centralizer R s | null | true |
instMonadBaseIO._aux_1 | Init.System.IO | {α β : Type} → (α → β) → BaseIO α → BaseIO β | null | false |
Subgroup.fintypeQuotientOfFiniteIndex | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : Group G] → {H : Subgroup G} → [H.FiniteIndex] → Fintype (G ⧸ H) | A finite index subgroup has finite quotient. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_alter._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Int32.toInt_sub_of_le | Init.Data.SInt.Lemmas | ∀ (a b : Int32), 0 ≤ b → b ≤ a → (a - b).toInt = a.toInt - b.toInt | null | true |
NumberField.InfinitePlace.even_finrank_of_not_isUnramified | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
{w : NumberField.InfinitePlace K} [IsGalois k K],
¬NumberField.InfinitePlace.IsUnramified k w → Even (Module.finrank k K) | null | true |
IsCoveringMap.monodromy._proof_1 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_2} {X : Type u_1} [inst : TopologicalSpace X] {p : E → X} {x y : X} (e : ↑(p ⁻¹' {x})) (γ : Path x y),
γ 0 = p ↑e | null | false |
CategoryTheory.Endofunctor.Adjunction.AlgCoalgEquiv.unitIso_inv_app_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (adj : F ⊣ G)
(X : CategoryTheory.Endofunctor.Algebra F),
((CategoryTheory.Endofunctor.Adjunction.AlgCoalgEquiv.unitIso adj).inv.app X).f = CategoryTheory.CategoryStruct.id X.a | null | true |
NNRat.nndist_eq | Mathlib.Topology.Instances.Rat | ∀ (p q : ℚ≥0), nndist p q = nndist ↑p ↑q | null | true |
CharacterModule.eq_zero_of_ofSpanSingleton_apply_self | Mathlib.Algebra.Module.CharacterModule | ∀ {A : Type uA} [inst : AddCommGroup A] (a : A), (CharacterModule.ofSpanSingleton a) ⟨a, ⋯⟩ = 0 → a = 0 | null | true |
BoundedContinuousFunction.instAddMonoid | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : AddMonoid R] → [BoundedAdd R] → [ContinuousAdd R] → AddMonoid (BoundedContinuousFunction α R) | null | true |
_private.Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic.0.Path.Homotopic.Quotient.refl_trans._simp_1_2 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] (x : X),
Path.Homotopic.Quotient.refl x = Path.Homotopic.Quotient.mk (Path.refl x) | null | false |
Aesop.GlobalRuleSetMember.base.noConfusion | Aesop.RuleSet.Member | {P : Sort u} →
{m m' : Aesop.BaseRuleSetMember} →
Aesop.GlobalRuleSetMember.base m = Aesop.GlobalRuleSetMember.base m' → (m = m' → P) → P | null | false |
CategoryTheory.Join.isoMkFunctor._proof_2 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_6, u_2} D] {E : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} E]
(F : CategoryTheory.Functor (CategoryTheory.Join C D) E),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerR... | null | false |
CategoryTheory.IsUniversalColimit.isPullback_of_isColimit_left | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {ι : Type u_3} {S B : C} {X : ι → C}
{a : CategoryTheory.Limits.Cofan X},
CategoryTheory.IsUniversalColimit a →
∀ (f : (i : ι) → X i ⟶ S) (u : a.pt ⟶ S) (v : B ⟶ S) {P : ι → C} (q₁ : (i : ι) → P i ⟶ B)
(q₂ : (i : ι) → P i ⟶ X i),
(∀ (i : ι), C... | Pullbacks distribute over universal coproducts on the left: This is the isomorphism
`∐ (B ×[S] Xᵢ) ≅ B ×[S] (∐ Xᵢ)`. | true |
AlgebraicGeometry.IsAffineOpen.fromSpec_preimage_basicOpen' | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U)
(f : ↑(X.presheaf.obj (Opposite.op U))),
(TopologicalSpace.Opens.map hU.fromSpec.base).obj (X.basicOpen f) =
(AlgebraicGeometry.Spec (X.presheaf.obj (Opposite.op U))).basicOpen
((CategoryTheory.ConcreteCategory.hom (Alg... | null | true |
Vector.unzip_snd | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {xs : Vector (α × β) n}, xs.unzip.2 = Vector.map Prod.snd xs | null | true |
_private.Mathlib.Analysis.Normed.Group.SemiNormedGrp.0.SemiNormedGrp.Hom.ext.match_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : SemiNormedGrp} (motive : M.Hom N → Prop) (h : M.Hom N),
(∀ (hom' : NormedAddGroupHom M.carrier N.carrier), motive { hom' := hom' }) → motive h | null | false |
_private.Mathlib.RingTheory.WittVector.Basic.0.Int.castDef.match_1.splitter | Mathlib.RingTheory.WittVector.Basic | (motive : ℤ → Sort u_1) → (x : ℤ) → ((n : ℕ) → motive (Int.ofNat n)) → ((n : ℕ) → motive (Int.negSucc n)) → motive x | null | true |
CategoryTheory.Sheaf.instMonoidalFunctorOppositePresheafToSheaf._aux_3 | Mathlib.CategoryTheory.Sites.Monoidal | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u_4) →
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] →
[inst_2 : CategoryTheory.MonoidalCategory A] →
[inst_3 : J.W.IsMonoidal] →
[inst_4 : C... | null | false |
MeasureTheory.ComplexMeasure.equivSignedMeasure._proof_1 | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (x : MeasureTheory.SignedMeasure α × MeasureTheory.SignedMeasure α),
(MeasureTheory.ComplexMeasure.re
(match x with
| (s, t) => s.toComplexMeasure t),
MeasureTheory.ComplexMeasure.im
(match x with
| (s, t) => s.toComplexMeasure t)) =
x | null | false |
TypeVec.append1Cases | Mathlib.Data.TypeVec | {n : ℕ} →
{C : TypeVec.{u_1} (n + 1) → Sort u} →
((α : TypeVec.{u_1} n) → (β : Type u_1) → C (α ::: β)) → (γ : TypeVec.{u_1} (n + 1)) → C γ | cases on `(n+1)-length` vectors | true |
Filter.NeBot.nonneg_sub | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : AddGroup α] {f : Filter α}, f.NeBot → 0 ≤ f - f | null | true |
Lean.resolveGlobalConst | Lean.ResolveName | {m : Type → Type} →
[Monad m] →
[Lean.MonadResolveName m] →
[Lean.MonadEnv m] →
[Lean.MonadOptions m] →
[Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadError m] → Lean.Syntax → m (List Lean.Name) | Interprets the syntax `n` as an identifier for a global constant, and returns a list of resolved
constant names that it could be referring to based on the currently open namespaces.
This should be used instead of `resolveGlobalConstCore` for identifiers taken from syntax
because `Syntax` objects may have names that hav... | true |
gcd_one_right | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a 1 = 1 | null | true |
Aesop.Script.Tactic._sizeOf_1 | Aesop.Script.Tactic | Aesop.Script.Tactic → ℕ | null | false |
CategoryTheory.MonoidalCategoryStruct.associator | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.MonoidalCategoryStruct C] →
(X Y Z : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z ≅
CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryThe... | The associator isomorphism `(X ⊗ Y) ⊗ Z ≃ X ⊗ (Y ⊗ Z)` | true |
SimpleGraph.cycleGraph.bicoloring_of_even | Mathlib.Combinatorics.SimpleGraph.Coloring.Constructions | (n : ℕ) → Even n → (SimpleGraph.cycleGraph n).Coloring Bool | Bicoloring of a cycle graph of even size | true |
Multiset.powersetAux' | Mathlib.Data.Multiset.Powerset | {α : Type u_1} → List α → List (Multiset α) | Helper function for the powerset of a multiset. Given a list `l`, returns a list
of sublists of `l` (using `sublists'`), as multisets. | true |
Lean.Elab.Tactic.RCases.RCasesPatt.typed.sizeOf_spec | Lean.Elab.Tactic.RCases | ∀ (ref : Lean.Syntax) (a : Lean.Elab.Tactic.RCases.RCasesPatt) (a_1 : Lean.Term),
sizeOf (Lean.Elab.Tactic.RCases.RCasesPatt.typed ref a a_1) = 1 + sizeOf ref + sizeOf a + sizeOf a_1 | null | true |
Lean.Elab.FixedParams.Info.casesOn | Lean.Elab.PreDefinition.FixedParams | {motive : Lean.Elab.FixedParams.Info → Sort u} →
(t : Lean.Elab.FixedParams.Info) →
((graph : Array (Array (Option (Array (Option ℕ))))) →
(revDeps : Array (Array (Array ℕ))) → motive { graph := graph, revDeps := revDeps }) →
motive t | null | false |
FreeAddGroup.sum_surjective | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} [inst : AddGroup α], Function.Surjective ⇑FreeAddGroup.sum | null | true |
Lean.Lsp.instBEqInsertReplaceEdit | Lean.Data.Lsp.LanguageFeatures | BEq Lean.Lsp.InsertReplaceEdit | null | true |
TwoP.swapEquiv | Mathlib.CategoryTheory.Category.TwoP | TwoP ≌ TwoP | The equivalence between `TwoP` and itself induced by `Prod.swap` both ways. | true |
_private.Mathlib.Topology.Compactness.Paracompact.0.refinement_of_locallyCompact_sigmaCompact_of_nhds_basis.match_1_1 | Mathlib.Topology.Compactness.Paracompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {ι : X → Type u_2} {p : (x : X) → ι x → Prop} {B : (x : X) → ι x → Set X}
(motive :
(∃ α c r,
(∀ (a : α), c a ∈ Set.univ ∧ p (c a) (r a)) ∧
Set.univ ⊆ ⋃ a, B (c a) (r a) ∧ LocallyFinite fun a => B (c a) (r a)) →
Prop)
(x :
∃ α c r,
(... | null | false |
summable_congr | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] {f g : β → α}
{L : SummationFilter β}, (∀ (b : β), f b = g b) → (Summable f L ↔ Summable g L) | See `summable_congr_cofinite` for a version allowing the functions to
disagree on a finite set. | true |
Std.Http.URI.Authority.port._default | Std.Http.Data.URI.Basic | Std.Http.URI.Port | null | false |
_private.Mathlib.Data.Stream.Init.0.Stream'.getElem?_take._simp_1_3 | Mathlib.Data.Stream.Init | ∀ (n : ℕ), (0 < n.succ) = True | null | false |
PrimeSpectrum.BasicConstructibleSetData.mk.inj | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {f : R} {n : ℕ} {g : Fin n → R} {f_1 : R} {n_1 : ℕ} {g_1 : Fin n_1 → R},
{ f := f, n := n, g := g } = { f := f_1, n := n_1, g := g_1 } → f = f_1 ∧ n = n_1 ∧ g ≍ g_1 | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Prod.0.MeasureTheory.VectorMeasure.prodOfIsFiniteMeasureLeft._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Prod | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], IsNormableSpace ℝ F | null | false |
CategoryTheory.Pseudofunctor.DescentData'.toDescentDataFunctor._proof_2 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryT... | null | false |
Fin2.rev | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 n → Fin2 n | Maps `0` to `n-1`, `1` to `n-2`, ..., `n-1` to `0`. | true |
RingPreordering.mk.sizeOf_spec | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : SizeOf R] (toSubsemiring : Subsemiring R)
(mem_of_isSquare' :
autoParam (∀ {x : R}, IsSquare x → x ∈ toSubsemiring.carrier) RingPreordering.mem_of_isSquare'._autoParam)
(neg_one_notMem' : autoParam (-1 ∉ toSubsemiring.carrier) RingPreordering.neg_one_notMem'._autoP... | null | true |
Std.DTreeMap.Internal.Const.RooSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{inst : Ord α} →
{t : Std.DTreeMap.Internal.Const.RooSliceData α β} →
{α' : Type u} →
{β' : Type v} →
{inst' : Ord α'} →
{t' : Std.DTreeMap.Internal.Const.RooSliceData α' β'} →
α = α'... | null | false |
Lean.Elab.Info.type? | Lean.Elab.InfoTree.Util | Lean.Elab.Info → Lean.MetaM (Option Lean.Expr) | null | true |
IsCoprime.sub_mul_left_left_iff._simp_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y z : R}, IsCoprime (x - y * z) y = IsCoprime x y | null | false |
BoundedVariationOn.continuousWithinAt_variationOnFromTo_inter_Ici_iff | Mathlib.Topology.EMetricSpace.VariationOnFromTo | ∀ {α : Type u_1} [inst : LinearOrder α] {M : Type u_3} [inst_1 : PseudoEMetricSpace M] [inst_2 : TopologicalSpace α]
[OrderTopology α] {s : Set α} {g : α → M},
BoundedVariationOn g s →
∀ {a x : α},
a ∈ s →
x ∈ s →
(ContinuousWithinAt (variationOnFromTo g s a) (s ∩ Set.Ici x) x ↔ Continuo... | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.functorExt.match_1.splitter | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
(motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u_3) →
(j : CategoryTheory.Limits.WalkingMulticospan J) →
((i : J.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((i : J.R) → motive (CategoryTheory.Limits.WalkingMulticospan.... | null | true |
Int.toInt16 | Init.Data.SInt.Basic | ℤ → Int16 | Converts an arbitrary-precision integer to a 16-bit integer, wrapping on overflow or underflow.
Examples:
* `Int.toInt16 48 = 48`
* `Int.toInt16 (-129) = -129`
* `Int.toInt16 (128) = 128`
* `Int.toInt16 70000 = 4464`
* `Int.toInt16 (-40000) = 25536`
| true |
CategoryTheory.LaxFunctor.mapComp_naturality_right | Mathlib.CategoryTheory.Bicategory.Functor.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(self : CategoryTheory.LaxFunctor B C) {a b c : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g'),
CategoryTheory.CategoryStruct.comp (self.mapComp f g) (self.map₂ (CategoryTheory.Bicategory.whiskerLeft f η)) =
Ca... | Naturality of the lax functoriality constraint, on the right. | true |
_private.Mathlib.MeasureTheory.VectorMeasure.WithDensityVec.0.MeasureTheory.VectorMeasure.variation_withDensity'._simp_1_16 | Mathlib.MeasureTheory.VectorMeasure.WithDensityVec | ∀ {α : Type u_1} {β : α → Type u_4} {p : (a : α) × β a → Prop}, (∃ x, p x) = ∃ a b, p ⟨a, b⟩ | null | false |
Set.image_subtype_val_Ioo_Ioi | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} (c : ↑(Set.Ioo a b)), Subtype.val '' Set.Ioi c = Set.Ioo (↑c) b | null | true |
IsCompactlyGenerated | Mathlib.Order.CompactlyGenerated.Basic | (α : Type u_3) → [Preorder α] → Prop | A complete lattice is said to be compactly generated if any
element is the least upper bound of compact elements. | true |
Homotopy.mkCoinductive._proof_2 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : CochainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 1 ⟶ Q.X 0)
(comm_zero : e.f 0 = CategoryTheory.CategoryStruct.comp (P.d 0 1) zero) (one : P.X 2 ⟶ Q.X 1)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.c... | null | false |
ChainComplex.fromSingle₀Equiv_symm_apply_f_zero | Mathlib.Algebra.Homology.Single | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] {C : ChainComplex V ℕ} {X : V} (f : X ⟶ C.X 0),
((C.fromSingle₀Equiv X).symm f).f 0 = f | null | true |
Lean.instEmptyCollectionFVarIdSet | Lean.Expr | EmptyCollection Lean.FVarIdSet | null | true |
CategoryTheory.ShortComplex.instPreservesFiniteColimitsπ₂ | Mathlib.Algebra.Homology.ShortComplex.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{v_2, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteColimits C],
CategoryTheory.Limits.PreservesFiniteColimits CategoryTheory.ShortComplex.π₂ | null | true |
CategoryTheory.RingObjCat.Hom.mk | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{R₁ R₂ : CategoryTheory.RingObjCat C} →
(hom : R₁.X ⟶ R₂.X) → [isRingHom : CategoryTheory.IsRingHom hom] → R₁.Hom R₂ | null | true |
CategoryTheory.GrothendieckTopology.instPartialOrder._proof_4 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (x x_1 : CategoryTheory.GrothendieckTopology C),
x ≤ x_1 → x_1 ≤ x → x = x_1 | null | false |
GenContFract.IntFractPair.mapFr | Mathlib.Algebra.ContinuedFractions.Computation.Basic | {K : Type u_1} → {β : Type u_2} → (K → β) → GenContFract.IntFractPair K → GenContFract.IntFractPair β | Maps a function `f` on the fractional components of a given pair.
| true |
CategoryTheory.Functor.RightExtension.IsPointwiseRightKanExtension.homTo._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_5} {D : Type u_4} {H : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Category.{u_1, u_2} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.RightExtension F}
(h : E.IsPointwiseRightKanExtensio... | null | false |
ShareCommon.instInhabitedState | Init.ShareCommon | {σ : ShareCommon.StateFactory} → Inhabited (ShareCommon.State σ) | null | true |
LinearMap.mul._proof_2 | Mathlib.Algebra.Algebra.Bilinear | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[IsScalarTower R A A] (r : R) (x y : A), r • x * y = r • (x * y) | null | false |
Std.Async.BaseAsync.toRawBaseIO | Std.Async.Basic | {α : Type} → Std.Async.BaseAsync α → BaseIO (Std.Async.MaybeTask α) | Converts a `BaseAsync` into a `BaseIO`
| true |
addConjugatesOf | Mathlib.Algebra.Group.Conj | {α : Type u} → [AddMonoid α] → α → Set α | Given an element `a`, `addConjugatesOf a` is the set of additive conjugates. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.minKey!_alter_eq_self._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
CategoryTheory.Limits.sigmaConst_map_app | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C] {X Y : C}
(f : X ⟶ Y) (n : Type w), (CategoryTheory.Limits.sigmaConst.map f).app n = CategoryTheory.Limits.Sigma.map fun x => f | null | true |
_private.Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree.0.Polynomial.IsMonicOfDegree.of_mul_left._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {n m : ℕ}, (n + m = 0) = (n = 0 ∧ m = 0) | null | false |
CategoryTheory.Functor.addMonObjObj._proof_2 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.AddMonObj... | null | false |
Module.Basis.localizationLocalization | Mathlib.RingTheory.Localization.Module | {R : Type u_1} →
(Rₛ : Type u_2) →
[inst : CommSemiring R] →
(S : Submonoid R) →
[inst_1 : CommSemiring Rₛ] →
[inst_2 : Algebra R Rₛ] →
[IsLocalization S Rₛ] →
{A : Type u_3} →
[inst_4 : CommSemiring A] →
[inst_5 : Algebra R A] →
... | If `A` has an `R`-basis, then localizing `A` at `S` has a basis over `R` localized at `S`.
A suitable instance for `[Algebra A Aₛ]` is `localizationAlgebra`.
| true |
_private.Init.Data.Array.Extract.0.Array.popWhile_filterMap._simp_1_1 | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {l : List α},
(List.filterMap f l).reverse = List.filterMap f l.reverse | null | false |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.mk.inj | Mathlib.Tactic.Translate.UnfoldBoundary | ∀ {unfolds : Lean.NameMap Lean.Meta.SimpTheorem} {casts : Lean.NameMap (Lean.Name × Lean.Name)}
{insertionFuns : Lean.NameSet} {unfolds_1 : Lean.NameMap Lean.Meta.SimpTheorem}
{casts_1 : Lean.NameMap (Lean.Name × Lean.Name)} {insertionFuns_1 : Lean.NameSet},
{ unfolds := unfolds, casts := casts, insertionFuns := ... | null | true |
Lean.TraceResult.ctorElimType | Lean.Message | {motive : Lean.TraceResult → Sort u} → ℕ → Sort (max 1 u) | null | false |
CategoryTheory.Functor.IsLocalization.comp | Mathlib.CategoryTheory.Localization.Composition | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(L₁ : CategoryTheory.Functor C₁ C₂) (L₂ : CategoryTheory.Functor C₂ C₃) (W₁ : CategoryTheory.MorphismProperty C₁)
(W₂ : Category... | null | true |
List.length_rightpad | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, (List.rightpad n a l).length = max n l.length | null | true |
Mathlib.Tactic.Determinant.Cert._sizeOf_1 | Mathlib.Tactic.Determinant.Bird.Cert | {u : Lean.Level} → {α : Q(Type u)} → {rα : Q(CommRing «$α»)} → Mathlib.Tactic.Determinant.Cert rα → ℕ | null | false |
_private.Mathlib.Data.Holor.0.Holor.cprankMax_add.match_1_3 | Mathlib.Data.Holor | ∀ {α : Type} {ds : List ℕ} [inst : Mul α] [inst_1 : AddMonoid α]
(motive : (x : Holor α ds) → Holor.CPRankMax 0 x → Prop) (x : Holor α ds) (hx : Holor.CPRankMax 0 x),
(∀ (_ : Unit), motive 0 ⋯) → motive x hx | null | false |
NumberField.ComplexEmbedding.Extension.not_isReal_of_not_isReal | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] {ψ : K →+* ℂ} [inst_2 : Algebra K L]
(φ : NumberField.ComplexEmbedding.Extension L ψ),
¬NumberField.ComplexEmbedding.IsReal ψ → ¬NumberField.ComplexEmbedding.IsReal ↑φ | null | true |
ArchimedeanClass.instLinearOrderedAddCommGroupWithTop._proof_2 | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : Field R] [inst_2 : IsOrderedRing R] (x : ArchimedeanClass R),
0 • x = 0 | null | false |
GroupSeminorm.toSeminormedCommGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_2} → [inst : CommGroup E] → GroupSeminorm E → SeminormedCommGroup E | Construct a seminormed group from a seminorm, i.e., registering the pseudodistance and the
pseudometric space structure from the seminorm properties. Note that in most cases this instance
creates bad definitional equalities (e.g., it does not take into account a possibly existing
`UniformSpace` instance on `E`). | true |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.equivAddCircle_eq._proof_1_3 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (p : 𝕜) [inst_1 : LinearOrder 𝕜] [hp : Fact (0 < p)], p ≠ 0 | null | false |
CauSeq.Completion.instSMulCauchyOfIsScalarTower | Mathlib.Algebra.Order.CauSeq.Completion | {α : Type u_1} →
[inst : Field α] →
[inst_1 : LinearOrder α] →
[inst_2 : IsStrictOrderedRing α] →
{β : Type u_2} →
[inst_3 : Ring β] →
{abv : β → α} →
[inst_4 : IsAbsoluteValue abv] →
{γ : Type u_3} → [inst_5 : SMul γ β] → [IsScalarTower γ β β] → S... | null | true |
TopologicalSpace.OpenNhdsOf.ctorIdx | Mathlib.Topology.Sets.Opens | {α : Type u_2} → {inst : TopologicalSpace α} → {x : α} → TopologicalSpace.OpenNhdsOf x → ℕ | null | false |
AffineSubspace.span_univ | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], affineSpan k Set.univ = ⊤ | The span of `univ` is `⊤`. | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction.0.CochainComplex.HomComplex.Cochain.InductionUp.limitSequence_eqUpTo._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {d : ℤ} {X : ℕ → Set (CochainComplex.HomComplex.Cochain K L d)} {p₀ : ℤ} (x₀ : ↑(X 0))
(n : ℕ), ∀ p ≤ p₀ + ↑n, (p - p₀).toNat ≤ n | null | false |
ZeroHom.instModule._proof_4 | Mathlib.Algebra.Module.Hom | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (m : ZeroHom A B), 0 • m = 0 | null | false |
_private.Mathlib.Tactic.SplitIfs.0.Mathlib.Tactic.SplitPosition.rec | Mathlib.Tactic.SplitIfs | {motive : Mathlib.Tactic.SplitPosition✝ → Sort u} →
motive Mathlib.Tactic.SplitPosition.target✝ →
((fvarId : Lean.FVarId) → motive (Mathlib.Tactic.SplitPosition.hyp✝ fvarId)) →
(t : Mathlib.Tactic.SplitPosition✝) → motive t | null | false |
Batteries.CodeAction.getAllArgs._unsafe_rec | Batteries.CodeAction.Misc | Lean.Expr → Array Lean.Name → Array Lean.Name | null | false |
SpecialLinearGroup.congr_linearEquiv._proof_2 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {W : Type u_3}
[inst_3 : AddCommGroup W] [inst_4 : Module R W] (e : V ≃ₗ[R] W) (g : SpecialLinearGroup R W),
LinearEquiv.det (e ≪≫ₗ ↑g ≪≫ₗ e.symm) = 1 | null | false |
Function.locallyFinsuppWithin.logCounting_strictMono | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : DecidableEq E] [inst_2 : ProperSpace E]
{D : Function.locallyFinsupp E ℤ} {e : E},
Function.locallyFinsuppWithin.single e 1 ≤ D →
StrictMonoOn (Function.locallyFinsuppWithin.logCounting D) (Set.Ioi ‖e‖) | The logarithmic counting function of a positive function with locally finite support is
asymptotically strictly monotone.
| true |
_private.Mathlib.Basic.Complex.Basic.0.Complex.verticalSegment_eq._simp_1_1 | Mathlib.Basic.Complex.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
_private.Mathlib.Topology.Bornology.Absorbs.0.absorbs_inter._simp_1_3 | Mathlib.Topology.Bornology.Absorbs | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) = ((∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x) | null | false |
Lean.Expr.updateLetE! | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr | Like `Expr.updateLet!` but preserves the `nondep` flag. | true |
_private.Mathlib.Analysis.Normed.Lp.lpSpace.0.LipschitzWith.coordinate._simp_1_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f = LipschitzOnWith K f Set.univ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas.0.Nat.nthRoot_eq_of_le_of_lt._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas | ∀ {n a b : ℕ}, a ≤ n.nthRoot b → n.nthRoot b < a + 1 → n.nthRoot b = a | null | false |
_private.Mathlib.Data.Nat.Fib.Basic.0.Nat.le_fib_add_one.match_1_1 | Mathlib.Data.Nat.Fib.Basic | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (_ : Unit), motive 0) →
(∀ (_ : Unit), motive 1) →
(∀ (_ : Unit), motive 2) →
(∀ (_ : Unit), motive 3) →
(∀ (_ : Unit), motive 4) → (∀ (_n : ℕ), motive _n.succ.succ.succ.succ.succ) → motive x | null | false |
Option.max_eq_none_iff._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Max α] {o o' : Option α}, (o ⊔ o' = none) = (o = none ∧ o' = none) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.