name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Sat.AIG.Entrypoint.ref | Std.Sat.AIG.Basic | {α : Type} → [inst : DecidableEq α] → [inst_1 : Hashable α] → (self : Std.Sat.AIG.Entrypoint α) → self.aig.Ref | The reference to the node in `aig` that this `Entrypoint` targets.
| true |
Aesop.PhaseSpec.ctorIdx | Aesop.Builder.Basic | Aesop.PhaseSpec → ℕ | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convol... | null | false |
IsCoinitial | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → Prop | A set is coinitial when for every `x : α` there exists `y ∈ s` with `y ≤ x`. | true |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mkNaturalityRightUnitor | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality m] →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr | The naturality for the right unitor. | true |
Lean.Lsp.DependencyBuildMode.recOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.DependencyBuildMode → Sort u} →
(t : Lean.Lsp.DependencyBuildMode) →
motive Lean.Lsp.DependencyBuildMode.always →
motive Lean.Lsp.DependencyBuildMode.once → motive Lean.Lsp.DependencyBuildMode.never → motive t | null | false |
TopCat.GlueData.MkCore.mk.sizeOf_spec | Mathlib.Topology.Gluing | ∀ {J : Type u} (U : J → TopCat) (V : (i : J) → J → TopologicalSpace.Opens ↑(U i))
(t :
(i j : J) →
(TopologicalSpace.Opens.toTopCat (U i)).obj (V i j) ⟶ (TopologicalSpace.Opens.toTopCat (U j)).obj (V j i))
(V_id : ∀ (i : J), V i i = ⊤) (t_id : ∀ (i : J), ⇑(CategoryTheory.ConcreteCategory.hom (t i i)) = id... | null | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.toPreOneHypercover_Y | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X) (x x_1 : data.I₀)
(j : data.I₁ x x_1), data.toPreOneHypercover.Y j = F.obj (data.Y j) | null | true |
GroupCone.mem_oneLE._simp_2 | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : CommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedMonoid H] {a : H},
(a ∈ GroupCone.oneLE H) = (1 ≤ a) | null | false |
_private.Mathlib.Geometry.Euclidean.Sphere.PolePolar.0.EuclideanGeometry.Sphere.polar_eq_orthRadius_self_iff._simp_1_4 | Mathlib.Geometry.Euclidean.Sphere.PolePolar | ∀ {R : Type u} [inst : Ring R] {a : R} [NoZeroDivisors R], (a ^ 2 = 1) = (a = 1 ∨ a = -1) | null | false |
PFun.restrict | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (f : α →. β) → {p : Set α} → p ⊆ f.Dom → α →. β | Restrict a partial function to a smaller domain. | true |
Std.DTreeMap.Internal.Impl.balanceL.match_3.congr_eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTre... | null | true |
Std.Sat.AIG.ExtendTarget.w | Std.Sat.AIG.Basic | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {aig : Std.Sat.AIG α} → {newWidth : ℕ} → aig.ExtendTarget newWidth → ℕ | null | true |
Lean.Syntax.getOptional? | Init.Prelude | Lean.Syntax → Option Lean.Syntax | Assuming `stx` was parsed by `optional`, returns the enclosed syntax
if it parsed something and `none` otherwise.
| true |
Std.Time.DateFormatSymbols.mk | Std.Time.Format.DateFormat | Vector String 12 →
Vector String 12 →
Vector String 12 →
Vector String 7 →
Vector String 7 →
Vector String 7 →
Vector String 7 →
Vector String 2 →
Vector String 2 →
Vector String 2 →
Vector String 4 →
... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_eq_get!_getKey?._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 |
Array.find? | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Option α | Returns the first element of the array for which the predicate `p` returns `true`, or `none` if no
such element is found.
Examples:
* `#[7, 6, 5, 8, 1, 2, 6].find? (· < 5) = some 1`
* `#[7, 6, 5, 8, 1, 2, 6].find? (· < 1) = none`
| true |
_private.Mathlib.RingTheory.Ideal.UFD.0.Ideal.isPrincipal_of_isPrincipal_isLocalizationAway_of_prime._simp_1_1 | Mathlib.RingTheory.Ideal.UFD | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M], ⊥.IsPrincipal = True | null | false |
Nat.Partrec.below.casesOn | Mathlib.Computability.Partrec | ∀ {motive : (a : ℕ →. ℕ) → Nat.Partrec a → Prop}
{motive_1 : {a : ℕ →. ℕ} → (t : Nat.Partrec a) → Nat.Partrec.below t → Prop} {a : ℕ →. ℕ} {t : Nat.Partrec a}
(t_1 : Nat.Partrec.below t),
motive_1 Nat.Partrec.zero ⋯ →
motive_1 Nat.Partrec.succ ⋯ →
motive_1 Nat.Partrec.left ⋯ →
motive_1 Nat.Partr... | null | false |
Multiset.prod_min_le | Mathlib.Algebra.Order.BigOperators.Group.Multiset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : LinearOrder α] [IsOrderedMonoid α] {s : Multiset ι}
{f g : ι → α}, (Multiset.map (fun i => min (f i) (g i)) s).prod ≤ min (Multiset.map f s).prod (Multiset.map g s).prod | null | true |
spectrum_realPart' | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.RealImaginaryPart | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : Algebra ℂ A]
[inst_4 : StarModule ℂ A] [ContinuousFunctionalCalculus ℂ A IsStarNormal] (a : A),
autoParam (IsStarNormal a) spectrum_realPart'._auto_1 → spectrum ℝ ↑(realPart a) = Complex.re '' spectrum ℂ a | null | true |
NeZero | Init.Data.NeZero | {R : Type u_1} → [Zero R] → R → Prop | A type-class version of `n ≠ 0`. | true |
Vector.snd_lt_add_of_mem_zipIdx | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {x : α × ℕ} {k : ℕ} {xs : Vector α n}, x ∈ xs.zipIdx k → x.2 < k + n | null | true |
ArchimedeanClass.exists_int_ge_of_mk_nonneg | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {x : R},
0 ≤ ArchimedeanClass.mk x → ∃ n, x ≤ ↑n | null | true |
CliffordAlgebra.EvenHom.mk | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] →
(bilin : M →ₗ[R] M →ₗ[R] A) →
... | null | true |
_private.Std.Do.WP.Sound.0.Std.Do.instWPSoundOptionTExceptPUnitPureOfLawfulMonad.match_5.eq_2 | Std.Do.WP.Sound | ∀ {α : Type u_1} {P : α → Prop}
(motive :
(r : Option α) →
(match r with
| some a => P a
| none => True) →
Sort u_2)
(x :
match none with
| some a => P a
| none => True)
(h_1 :
(a : α) →
(hp :
match some a with
| some a => P a
|... | null | true |
Std.DTreeMap.Internal.Cell.get?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.OrientedOrd α] [inst_2 : Std.LawfulEqOrd α] {k : α}
(c : Std.DTreeMap.Internal.Cell α β (compare k)),
c.get? =
match h : c.inner with
| none => none
| some p => some (cast ⋯ p.snd) | null | true |
DFinsupp.instCanonicallyOrderedAddOfAddLeftMono | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} (α : ι → Type u_2) [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)] [∀ (i : ι), OrderedSub (α i)]
[∀ (i : ι), AddLeftMono (α i)], CanonicallyOrderedAdd (Π₀ (i : ι), α i) | null | true |
ClosureOperator.noConfusion | Mathlib.Order.Closure | {P : Sort u} →
{α : Type u_1} →
{inst : Preorder α} →
{t : ClosureOperator α} →
{α' : Type u_1} →
{inst' : Preorder α'} →
{t' : ClosureOperator α'} → α = α' → inst ≍ inst' → t ≍ t' → ClosureOperator.noConfusionType P t t' | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.EqResult.false | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | Lean.Expr → Nat.EqResult✝ | null | true |
_private.Init.Data.List.Find.0.List.lt_findIdx_iff._proof_1_3 | Init.Data.List.Find | ∀ {α : Type u_1} (xs : List α) (p : α → Bool),
∀ i < List.findIdx p xs, List.findIdx p xs ≤ xs.length → ¬i < xs.length → False | null | false |
Lean.Lsp.InlayHintParams | Lean.Data.Lsp.LanguageFeatures | Type | null | true |
DifferentiableOn.sum | 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] {s : Set E}
{ι : Type u_4} {u : Finset ι} {A : ι → E → F},
(∀ i ∈ u, DifferentiableOn 𝕜 (A i) s) → Differenti... | null | true |
MeasurableEquiv.piCongrLeft.eq_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {δ : Type u_4} {δ' : Type u_5} (π : δ' → Type u_6) [inst : (x : δ') → MeasurableSpace (π x)] (f : δ ≃ δ'),
MeasurableEquiv.piCongrLeft π f = { toEquiv := Equiv.piCongrLeft π f, measurable_toFun := ⋯, measurable_invFun := ⋯ } | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabUnsafe._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
PartOrdEmb.of.injEq | Mathlib.Order.Category.PartOrdEmb | ∀ (carrier : Type u_1) [str : PartialOrder carrier] (carrier_1 : Type u_1) (str_1 : PartialOrder carrier_1),
(↧carrier = ↧carrier_1) = (carrier = carrier_1 ∧ str ≍ str_1) | null | true |
Batteries.CodeAction.instInhabitedTacticCodeActionEntry.default | Batteries.CodeAction.Attr | Batteries.CodeAction.TacticCodeActionEntry | null | true |
neZero_iff | Init.Data.NeZero | ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n ↔ n ≠ 0 | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Basic.0.CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_inv_app_eq._simp_1_2 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
CategoryTheory.ObjectProperty.coproductFromFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.CostructuredArrow P.ι X → C | Given `P : ObjectProperty C` and `X : C`, this is the map which
sends `i : CostructuredArrow P.ι X` to `i.left.obj : C`. The coproduct
of this family is the source of the morphism `P.coproductFrom X`. | true |
StieltjesFunction.mk.inj | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} {inst : LinearOrder R} {inst_1 : TopologicalSpace R} {toFun : R → ℝ} {mono' : Monotone toFun}
{right_continuous' : ∀ (x : R), ContinuousWithinAt toFun (Set.Ici x) x} {toFun_1 : R → ℝ} {mono'_1 : Monotone toFun_1}
{right_continuous'_1 : ∀ (x : R), ContinuousWithinAt toFun_1 (Set.Ici x) x},
{ toFun... | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._simp_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} {a b : Additive α}, (a = b) = (Additive.toMul a = Additive.toMul b) | null | false |
LightProfinite.instEpiAppOppositeNatπAsLimitCone | Mathlib.Topology.Category.LightProfinite.Extend | ∀ (S : LightProfinite) (i : ℕᵒᵖ), CategoryTheory.Epi (S.asLimitCone.π.app i) | null | true |
Lean.Lsp.SymbolKind.interface.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 10 → motive Lean.Lsp.SymbolKind.interface → motive t | null | false |
ProfiniteAddGrp.hom_ext | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {f g : A ⟶ B}, ProfiniteAddGrp.Hom.hom f = ProfiniteAddGrp.Hom.hom g → f = g | null | true |
notMem_nonZeroDivisorsLeft_iff | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] {x : M₀}, x ∉ nonZeroDivisorsLeft M₀ ↔ {y | x * y = 0 ∧ y ≠ 0}.Nonempty | null | true |
Std.Iter.toArray_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toArray = it.toArray.extract n | null | true |
Ideal.quotientInfToPiQuotient.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {ι : Type u_1} (I : ι → Ideal R) [inst_1 : ∀ (i : ι), (I i).IsTwoSided],
Ideal.quotientInfToPiQuotient I = Ideal.Quotient.lift (⨅ i, I i) (RingHom.pi fun i => Ideal.Quotient.mk (I i)) ⋯ | null | true |
Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusion | Lean.Elab.Do.Legacy | {P : Sort u} →
{t t' : Lean.Elab.Term.Do.ToCodeBlock.Context} → t = t' → Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusionType P t t' | null | false |
minpoly.dvd_map_of_isScalarTower | Mathlib.FieldTheory.Minpoly.Field | ∀ (A : Type u_3) (K : Type u_4) {R : Type u_5} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Ring R]
[inst_3 : Algebra A K] [inst_4 : Algebra A R] [inst_5 : Algebra K R] [IsScalarTower A K R] (x : R),
minpoly K x ∣ Polynomial.map (algebraMap A K) (minpoly A x) | null | true |
Lean.Doc.Block.brecOn_2.eq | Lean.DocString.Types | ∀ {i : Type u} {b : Type v} {motive_1 : Lean.Doc.Block i b → Sort u_1}
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1}
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1}
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1}
{motive_5 : List (Lean.Doc.L... | null | true |
Set.fintypeImage2._proof_1 | Mathlib.Basic.Finite.Prod | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} (f : α → β → γ) (s : Set α) (t : Set β),
Fintype ↑(Set.image2 f s t) = Fintype ↑((fun x => f x.1 x.2) '' s ×ˢ t) | null | false |
Algebra.FiniteType.out | Mathlib.RingTheory.FiniteType | ∀ {R : Type uR} {A : Type uA} {inst : CommSemiring R} {inst_1 : Semiring A} {inst_2 : Algebra R A}
[self : Algebra.FiniteType R A], ⊤.FG | null | true |
GradedMonoid.GMul.casesOn | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : Add ι] →
{motive : GradedMonoid.GMul A → Sort u} →
(t : GradedMonoid.GMul A) → ((mul : {i j : ι} → A i → A j → A (i + j)) → motive { mul := mul }) → motive t | null | false |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app_assoc | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1)
{Z : C} (h : (CategoryTheory.unopUnop C).obj ((CategoryTheory.shiftFunctor Cᵒᵖᵒᵖ n).... | null | true |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape._sizeOf_1 | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
{inst_1 : LinearOrder J} →
{inst_2 : SuccOrder J} →
{inst_3 : OrderBot J} →
{inst_4 : WellFoundedLT J} →
{X Y : C} →
... | null | false |
MeasureTheory.withDensityᵥ_toReal | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ (hf : ∫⁻ (x : α), f x ∂μ ≠ ⊤), (μ.withDensityᵥ fun x => (f x).toReal) = (μ.withDensity f).toSignedMeasure | null | true |
Lean.ErrorExplanation.mk.injEq | Lean.ErrorExplanation | ∀ (doc : String) (metadata : Lean.ErrorExplanation.Metadata) (declLoc? : Option Lean.DeclarationLocation)
(doc_1 : String) (metadata_1 : Lean.ErrorExplanation.Metadata) (declLoc?_1 : Option Lean.DeclarationLocation),
({ doc := doc, metadata := metadata, declLoc? := declLoc? } =
{ doc := doc_1, metadata := met... | null | true |
Ideal.fiberIsoOfBijectiveResidueField | Mathlib.RingTheory.Etale.QuasiFinite | {R : Type u_1} →
{R' : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing R'] →
[inst_2 : CommRing S] →
[inst_3 : Algebra R R'] →
[inst_4 : Algebra R S] →
{p : Ideal R} →
{q : Ideal R'} →
[in... | If `q` is a prime of `R'` lying over `p`, a prime of `R`, such that `κ(q) = κ(p)`, then
the fiber of `R' → R' ⊗[R] S` over `q` is in bijection with the fiber of `R → S` over `p`. | true |
EReal.add_iInf_le_iInf_add | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {u v : α → EReal}, (⨅ x, u x) + ⨅ x, v x ≤ ⨅ x, (u + v) x | null | true |
Real.fromBinary_surjective | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | Function.Surjective Real.fromBinary | null | true |
Set.DefinableFun.ofPred_eq_const | Mathlib.ModelTheory.Definability | ∀ {M : Type u_1} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u_2} {A : Set M} {f : (α → M) → M},
Set.DefinableFun L A f → ∀ {a : M}, a ∈ A → A.Definable L {v | f v = a} | The preimage of a constant under a definable function is definable. | true |
ULift.distrib | Mathlib.Algebra.Ring.ULift | {R : Type u} → [Distrib R] → Distrib (ULift.{u_1, u} R) | null | true |
RBTree.RBNode.Path.insertNew_eq_insert | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {t : RBTree.RBNode α} {path : RBTree.RBNode.Path α} {v : α},
RBTree.RBNode.zoom (cmp v) t = (RBTree.RBNode.nil, path) → path.insertNew v = (RBTree.RBNode.insert cmp t v).setBlack | null | true |
Std.DHashMap.Raw.get?_union_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∪ m₂).get? k = m₁.get? k | null | true |
IsAddTorsion.addGroup | Mathlib.GroupTheory.Torsion | {G : Type u_1} → [inst : AddMonoid G] → IsAddTorsion G → AddGroup G | Torsion additive monoids are really additive groups. | true |
CategoryTheory.Monad.algebraEquivOfIsoMonads_unitIso | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂),
(CategoryTheory.Monad.algebraEquivOfIsoMonads h).unitIso =
CategoryTheory.Monad.algebraFunctorOfMonadHomId.symm ≪≫
CategoryTheory.Monad.algebraFunctorOfMonadHomEq ⋯ ≪≫ CategoryTheory.Monad.algebraFunc... | null | true |
Set.Icc_union_Icc' | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α},
c ≤ b → a ≤ d → Set.Icc a b ∪ Set.Icc c d = Set.Icc (min a c) (max b d) | null | true |
MonadWriter.mk.noConfusion | Mathlib.Control.Monad.Writer | {ω : outParam (Type u)} →
{M : Type u → Type v} →
{P : Sort u_1} →
{tell : ω → M PUnit.{u + 1}} →
{listen : {α : Type u} → M α → M (α × ω)} →
{pass : {α : Type u} → M (α × (ω → ω)) → M α} →
{tell' : ω → M PUnit.{u + 1}} →
{listen' : {α : Type u} → M α → M (α × ω)}... | null | false |
Ring.instDirectLimit._proof_16 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j), autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
HopfAlgebra.ofConvInverse | Mathlib.RingTheory.HopfAlgebra.Basic | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Bialgebra R A] →
(antipode : A →ₗ[R] A) →
WithConv.toConv antipode * WithConv.toConv LinearMap.id = 1 →
WithConv.toConv LinearMap.id * WithConv.toConv antipode = 1 → Hopf... | Upgrade a bialgebra to a Hopf algebra by specifying a convolution inverse of the identity. | true |
toIcoDiv_add_left' | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIcoDiv hp (p + a) b = toIcoDiv hp a b - 1 | null | true |
CategoryTheory.instAddCommGroupHomComma._proof_9 | Mathlib.CategoryTheory.Preadditive.Comma | ∀ {A : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} A] [inst_1 : CategoryTheory.Preadditive A] {B : Type u_4}
[inst_2 : CategoryTheory.Category.{u_2, u_4} B] [inst_3 : CategoryTheory.Preadditive B] {T : Type u_6}
[inst_4 : CategoryTheory.Category.{u_5, u_6} T] [inst_5 : CategoryTheory.Preadditive T]
(L : ... | null | false |
BinaryTree.getOrElse | Mathlib.Data.Tree.Get | {α : Type u_1} → PosNum → BinaryTree α → α → α | Retrieves an element from the tree, or the provided default value
if the index is invalid. See `BinaryTree.get`. | true |
Int8.toNatClampNeg_lt | Init.Data.SInt.Lemmas | ∀ (x : Int8), x.toNatClampNeg < 2 ^ 7 | null | true |
_private.Lean.Meta.ForEachExpr.0.Lean.Meta.forEachExpr'.visit | Lean.Meta.ForEachExpr | {m : Type → Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] →
(Lean.Expr → m Bool) →
(x : STWorld IO.RealWorld m) →
MonadLiftT (ST IO.RealWorld) m → Lean.Expr → Lean.MonadCacheT Lean.Expr Unit m Unit | null | true |
_private.Init.Data.Nat.Lemmas.0.Nat.one_mod_eq_one.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive x | null | false |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.mu'_apply_self | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_4} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (a : α), (IncidenceAlgebra.mu'✝ 𝕜) a a = 1 | null | true |
MeasureTheory.Egorov.notConvergentSeqLTIndex | Mathlib.MeasureTheory.Function.Egorov | {α : Type u_1} →
{β : Type u_2} →
{ι : Type u_3} →
{m : MeasurableSpace α} →
[inst : PseudoEMetricSpace β] →
{μ : MeasureTheory.Measure α} →
{s : Set α} →
{ε : ENNReal} →
{f : ι → α → β} →
{g : α → β} →
[inst_1... | Given some `ε > 0`, `notConvergentSeqLTIndex` provides the index such that
`notConvergentSeq` (intersected with a set of finite measure) has measure less than
`ε * 2⁻¹ ^ n`.
This definition is useful for Egorov's theorem. | true |
Lean.Meta.MVarRenaming.map | Lean.Meta.Match.MVarRenaming | Lean.Meta.MVarRenaming → Lean.MVarIdMap Lean.MVarId | null | true |
SemidirectProduct.inr | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} → {G : Type u_2} → [inst : Group N] → [inst_1 : Group G] → {φ : G →* MulAut N} → G →* N ⋊[φ] G | The canonical map `G →* N ⋊[φ] G` sending `g` to `⟨1, g⟩` | true |
GroupSeminorm.coe_sSup_apply' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E] {s : Set (GroupSeminorm E)},
BddAbove s → ∀ {x : E}, (sSup s) x = sSup ((fun x_1 => x_1 x) '' s) | null | true |
Algebra.IsPushout.cancelBaseChangeAux.congr_simp | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_1) (S : Type v₃) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (A : Type u_8)
(B : Type u_9) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsSc... | null | true |
_private.Lean.Server.GoTo.0.Lean.Server.getInstanceProjectionArg?.reduceToProjection?._sparseCasesOn_6 | Lean.Server.GoTo | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
RingSeminormClass.mk._flat_ctor | Mathlib.Algebra.Order.Hom.RingNorm | ∀ {F : Type u_4} {α : outParam (Type u_5)} {β : outParam (Type u_6)} [inst : NonUnitalNonAssocRing α]
[inst_1 : Semiring β] [inst_2 : PartialOrder β] [inst_3 : FunLike F α β],
(∀ (f : F) (a b : α), f (a + b) ≤ f a + f b) →
(∀ (f : F), f 0 = 0) →
(∀ (f : F) (a : α), f (-a) = f a) → (∀ (f : F) (a b : α), f ... | null | false |
UpperHalfPlane.isBoundedAtImInfty_of_hasSum_qExpansion | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {h : ℝ} {f : UpperHalfPlane → ℂ} {c : ℕ → ℂ},
0 < h →
(∀ (τ : UpperHalfPlane), HasSum (fun m => c m • Function.Periodic.qParam h ↑τ ^ m) (f τ)) →
UpperHalfPlane.IsBoundedAtImInfty f | A function on the upper half plane that is given everywhere by a convergent `q`-expansion with
non-negative exponents, `f τ = ∑' m, c m * 𝕢 h τ ^ m`, is bounded at `i∞`. This is a converse to
`hasSum_qExpansion`: there, boundedness is a hypothesis used to produce the `q`-expansion, while
here convergence of the `q`-ex... | true |
_private.Init.Data.Fin.Basic.0.Fin.exists_iff.match_1_1 | Init.Data.Fin.Basic | ∀ {n : ℕ} {p : Fin n → Prop} (motive : (∃ i, p i) → Prop) (x : ∃ i, p i),
(∀ (i : ℕ) (hi : i < n) (hpi : p ⟨i, hi⟩), motive ⋯) → motive x | null | false |
LieModule.Cohomology.twoCocycle.eq_1 | Mathlib.Algebra.Lie.Cochain | ∀ (R : Type u_1) [inst : CommRing R] (L : Type u_2) [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M],
LieModule.Cohomology.twoCocycle R L M = (LieModule.Cohomology.d₂₃ R L M).ker | null | true |
Convex.norm_image_sub_le_of_norm_fderiv_le | Mathlib.Analysis.Calculus.MeanValue | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {𝕜 : Type u_3} {G : Type u_4}
[inst_2 : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → G} {C : ℝ} {s : Set E} {x y : E},
(∀ x ∈ s, Diffe... | The mean value theorem on a convex set: if the derivative of a function is bounded by `C`,
then the function is `C`-Lipschitz. Version with `fderiv`. | true |
Std.DTreeMap.Internal.Impl.applyPartition_eq_apply_toListModel | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α]
[inst_3 : Std.LawfulBEqOrd α] {k : α} {l : Std.DTreeMap.Internal.Impl α β},
l.Ordered →
∀
{f :
List ((a : α) × β a) →
(c : Std.DTreeMap.Internal.Cell α β (compare k)) →
(Std... | null | true |
Lean.Elab.Do.InferControlInfo.ofSeq | Lean.Elab.Do.InferControlInfo | Lean.DoSeq → Lean.Elab.TermElabM Lean.Elab.Do.ControlInfo | null | true |
Mathlib.Tactic.Order.OrderType.lin.sizeOf_spec | Mathlib.Tactic.Order.Preprocessing | sizeOf Mathlib.Tactic.Order.OrderType.lin = 1 | null | true |
_private.Init.Data.Nat.Control.0.Nat.forM.loop._unsafe_rec | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit | null | false |
SymAlg.instCommMagmaOfInvertibleOfNat | Mathlib.Algebra.Symmetrized | {α : Type u_1} → [inst : Ring α] → [Invertible 2] → CommMagma αˢʸᵐ | null | true |
LeanSearchClient.instReprSearchResult | LeanSearchClient.Syntax | Repr LeanSearchClient.SearchResult | null | true |
Nat.mul_left_comm | Init.Data.Nat.Basic | ∀ (n m k : ℕ), n * (m * k) = m * (n * k) | null | true |
UInt16.toFin_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), (a % b).toFin = a.toFin % b.toFin | null | true |
PadicSeq.valuation | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [Fact (Nat.Prime p)] → PadicSeq p → ℤ | The `p`-adic valuation on `ℚ` lifts to `PadicSeq p`.
`Valuation f` is defined to be the valuation of the (`ℚ`-valued) stationary point of `f`. | true |
SimpleGraph.sum_incMatrix_apply_of_notMem_edgeSet | Mathlib.Combinatorics.SimpleGraph.IncMatrix | ∀ {R : Type u_1} {α : Type u_2} (G : SimpleGraph α) [inst : NonAssocSemiring R] [inst_1 : DecidableEq α]
[inst_2 : DecidableRel G.Adj] {e : Sym2 α} [inst_3 : Fintype α],
e ∉ G.edgeSet → ∑ a, SimpleGraph.incMatrix R G a e = 0 | null | true |
ValueDistribution.logCounting_const | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {c : E} {e : WithTop E},
ValueDistribution.logCounting (fun x => c) e = 0 | The logarithmic counting function of a constant function is zero.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.