name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
mulMonoidWithZeroHom_apply | Mathlib.Algebra.GroupWithZero.Prod | ∀ {M₀ : Type u_1} [inst : CommMonoidWithZero M₀] (a : M₀ × M₀), mulMonoidWithZeroHom a = (↑mulMonoidHom).toFun a | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.PosLog.0.Real.posLog_sum._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Log.PosLog | ∀ {ι : Type u_1} {G : Type u_8} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] (f : ι → G)
(s : Finset ι), (|∑ i ∈ s, f i| ≤ ∑ i ∈ s, |f i|) = True | null | false |
HomologicalComplex.evalCompCoyonedaCorepresentableBySingle._proof_2 | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} (c : ComplexShape ι) (i : ι) [inst_3 : DecidableEq ι]
(hi : ∀ (j : ι), ¬c.Rel i j) (X : C) {K : HomologicalComplex C c} (g : (Homological... | null | false |
_private.Mathlib.Algebra.Homology.Embedding.Connect.0.CochainComplex.ConnectData.homologyIsoPos._proof_7 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (n : ℕ) (m : ℤ), m = ↑n → ↑n = m | null | false |
LightCondensed.instMonoidalLightCondSetLightCondModFree._aux_12 | Mathlib.Condensed.Light.Monoidal | (R : Type u_1) →
[inst : CommRing R] →
(X Y : LightCondSet) →
(LightCondensed.free R).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) ⟶
CategoryTheory.MonoidalCategoryStruct.tensorObj ((LightCondensed.free R).obj X) ((LightCondensed.free R).obj Y) | null | false |
CFC.negPart_eq_zero_of_not_isSelfAdjoint | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [inst_2 : SMulCommClass ℝ A A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : StarRing A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] {a : A}, ¬IsSelfAdjoint a → a⁻ = 0 | null | true |
PowerSeries.X_pow_mul_injective | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {k : ℕ}, Function.Injective fun x => PowerSeries.X ^ k * x | null | true |
CompleteSublattice.instCompleteLattice._proof_3 | Mathlib.Order.CompleteSublattice | ∀ {α : Type u_1} [inst : CompleteLattice α] {L : CompleteSublattice α} {x y : ↥L}, ↑x < ↑y ↔ ↑x < ↑y | null | false |
Set.MapsTo.coe_restrict | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} (h : Set.MapsTo f s t),
Subtype.val ∘ Set.MapsTo.restrict f s t h = s.domRestrict f | null | true |
ZeroAtInftyContinuousMap.coe_unitizationAlgEquiv_symm | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | ∀ {X : Type u_1} {R : Type u_2} {S : Type u_3} [inst : TopologicalSpace X] [inst_1 : R1Space X]
[inst_2 : TopologicalSpace R] [inst_3 : CommRing R] [inst_4 : IsTopologicalRing R] [inst_5 : CommSemiring S]
[inst_6 : Algebra S R],
⇑(ZeroAtInftyContinuousMap.unitizationAlgEquiv X R S).symm = ⇑(ZeroAtInftyContinuousM... | null | true |
Std.Sat.AIG | Std.Sat.AIG.Basic | (α : Type) → [DecidableEq α] → [Hashable α] → Type | An And Inverter Graph together with a cache for subterm sharing.
| true |
Valuation.instLinearOrderedCommGroupWithZeroMrange | Mathlib.RingTheory.Valuation.Archimedean | {F : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Field F] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation F Γ₀} → LinearOrderedCommGroupWithZero ↥(MonoidHom.mrange v) | null | true |
Vector.toList_drop | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ}, (xs.drop i).toList = List.drop i xs.toList | null | true |
EsakiaHomClass | Mathlib.Topology.Order.Hom.Esakia | (F : Type u_6) →
(α : outParam (Type u_7)) →
(β : outParam (Type u_8)) →
[TopologicalSpace α] → [Preorder α] → [TopologicalSpace β] → [Preorder β] → [FunLike F α β] → Prop | `EsakiaHomClass F α β` states that `F` is a type of lattice morphisms.
You should extend this class when you extend `EsakiaHom`. | true |
Function.Fiber.mk._proof_1 | Mathlib.Logic.Function.FiberPartition | ∀ {Y : Type u_1} {Z : Type u_2} (f : Y → Z) (y : Y), f ⁻¹' {f y} ∈ Set.range fun x => f ⁻¹' {↑x} | null | false |
CategoryTheory.Abelian.LeftResolution.chainComplex._proof_2 | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) (X : A) [inst_2 : CategoryTheory.Abelian A],
CategoryTheory.Limits.HasKernel (Λ.π.app X) | null | false |
RBTree.RBNode.Path.del.match_1 | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
(motive : RBTree.RBNode.Path α → RBTree.RBNode α → RBTree.RBColor → Sort u_2) →
(x : RBTree.RBNode.Path α) →
(x_1 : RBTree.RBNode α) →
(x_2 : RBTree.RBColor) →
((t : RBTree.RBNode α) → (x : RBTree.RBColor) → motive RBTree.RBNode.Path.root t x) →
((c : RBTree.RB... | null | false |
Std.Time.Weekday.noConfusionType | Std.Time.Date.Unit.Weekday | Sort v✝ → Std.Time.Weekday → Std.Time.Weekday → Sort v✝ | null | true |
ContinuousLinearMap.compSLₗ._proof_4 | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_5} {𝕜₂ : Type u_1} {𝕜₃ : Type u_2} (E' : Type u_6) (F' : Type u_3) (G' : Type u_4)
[inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : NontriviallyNormedField 𝕜₃]
(σ₁₂ : 𝕜 →+* 𝕜₂) (σ₂₃ : 𝕜₂ →+* 𝕜₃) {σ₁₃ : 𝕜 →+* 𝕜₃} [inst_3 : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃]
[... | null | false |
CategoryTheory.Limits.WidePushoutShape.equivalenceOfEquiv._proof_10 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} (J' : Type u_2) (h : J ≃ J') (X : CategoryTheory.Limits.WidePushoutShape J),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.NatIso.ofComponents'
(fun j =>
Option.casesOn (motive := fun t =>
j = t →
(((CategoryTheory.Limits... | null | false |
Finset.HasAntidiagonal.antidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | {A : Type u_1} → {inst : Add A} → [self : Finset.HasAntidiagonal A] → A → Finset (A × A) | The antidiagonal of an element `n` is the finset of pairs `(i, j)` such that
`i + j = n`. | true |
Metric.gromovProduct_self | Mathlib.Topology.MetricSpace.GromovProduct | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] (x y : X), Metric.gromovProduct x y y = dist x y | null | true |
Finset.mul_eq_empty._simp_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α}, (s * t = ∅) = (s = ∅ ∨ t = ∅) | null | false |
Std.ExtDTreeMap.get?_diff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α}, (t₁ \ t₂).get? k = if k ∈ t₂ then none else t₁.get? k | null | true |
Array.foldr_subtype' | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {start : ℕ} {p : α → Prop} {xs : Array { x // p x }} {f : { x // p x } → β → β}
{g : α → β → β} {x : β},
(∀ (x : α) (h : p x) (b : β), f ⟨x, h⟩ b = g x b) →
start = xs.size → Array.foldr f x xs start = Array.foldr g x xs.unattach | Variant of `foldr_subtype` with side condition to check `stop = l.size`. | true |
CategoryTheory.Pretriangulated.rotCompInvRot | Mathlib.CategoryTheory.Triangulated.Rotate | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C) ≅
(Categ... | The unit isomorphism of the auto-equivalence of categories `triangleRotation C` of
`Triangle C` given by the rotation of triangles. | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell.match_5.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (l : Std.DTreeMap.Internal.Impl α β) → l.Balanced → Sort u_3)
(hl : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(h_1 : (hl : Std.DTreeMap.Internal.Impl.leaf.Balanced) → motive Std.DTreeMap.Internal.Impl.leaf hl)
(h_2 :
(sz : ℕ) →
(ky : α) →
(y : β ky) ... | null | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.TauPackage.color_lt._simp_1_13 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
_private.Lean.Compiler.LCNF.Main.0.Lean.Compiler.LCNF.PassManager.run._sparseCasesOn_9 | Lean.Compiler.LCNF.Main | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) → motive_4 (Lean.Compiler.LCNF.Code.let decl k)) →
(Nat.hasNotBit 1 t.ctorIdx → motive_4 t) → ... | null | false |
CategoryTheory.Subobject.pullback_self | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {A B : C}
(f : A ⟶ B) [inst_2 : CategoryTheory.Mono f],
(CategoryTheory.Subobject.pullback f).obj (CategoryTheory.Subobject.mk f) = ⊤ | null | true |
HereditarilyLindelofSpace.isLindelof | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] [HereditarilyLindelofSpace X] (s : Set X), IsLindelof s | null | true |
_private.Std.Http.Internal.String.0.Std.Http.Internal.quoteCore._proof_1 | Std.Http.Internal.String | ∀ (c : Char),
Std.Http.Internal.Char.quotedStringChar c = true →
¬Std.Http.Internal.Char.qdtext c = true →
¬(decide (c = '\"') || decide (c = '\\')) = true → ¬Std.Http.Internal.Char.quotedStringChar c = true | null | false |
Real.cos_sub_cos | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), Real.cos x - Real.cos y = -2 * Real.sin ((x + y) / 2) * Real.sin ((x - y) / 2) | null | true |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.typeSpec._regBuiltin.Lean.Parser.Term.typeSpec.parenthesizer_7 | Lean.Parser.Term.Basic | IO Unit | null | false |
CStarMatrix.map_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {M : CStarMatrix m n A} {f : A → B} {i : m} {j : n},
M.map f i j = f (M i j) | null | true |
_private.Lean.Widget.UserWidget.0.Lean.Widget.initFn._@.Lean.Widget.UserWidget.1015473889._hygCtx._hyg.2 | Lean.Widget.UserWidget | IO Lean.Widget.PanelWidgetsExt✝ | null | false |
Lean.Meta.Simp.SimprocOLeanEntry | Lean.Meta.Tactic.Simp.Types | Type | `Simproc` .olean entry.
| true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comapOn_isBase_iff_of_surjOn._simp_1_3 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis' I X = M.IsBasis I (X ∩ M.E) | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.chevalley_mvPolynomialC._simp_1_6 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} {x : M}, (x ∈ p ⊓ q) = (x ∈ p ∧ x ∈ q) | null | false |
CategoryTheory.plusPlusAdjunction | Mathlib.CategoryTheory.Sites.ConcreteSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type w) →
[inst_1 : CategoryTheory.Category.{w', w} D] →
{FD : D → D → Type u_1} →
{CD : D → Type t} →
[inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (CD Y... | The sheafification functor is left adjoint to the forgetful functor. | true |
Lean.Expr.letE | Lean.Expr | Lean.Name → Lean.Expr → Lean.Expr → Lean.Expr → Bool → Lean.Expr | Let-expressions.
The let-expression `let x : Nat := 2; Nat.succ x` is represented as
```
Expr.letE `x (.const `Nat []) (.lit (.natVal 2)) (.app (.const `Nat.succ []) (.bvar 0)) true
```
If the `nondep` flag is `true`, then the elaborator treats this as a *non-dependent `let`* (known as a *`have` expression*).
Given a... | true |
Std.DTreeMap.Internal.Impl.ExplorationStep.gt.inj | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} {inst : Ord α} {k : α → Ordering} {a : List ((a : α) × β a)} {a_1 : α}
{a_2 : k a_1 = Ordering.gt} {a_3 : β a_1} {a_4 : List ((a : α) × β a)} {a_5 : α} {a_6 : k a_5 = Ordering.gt}
{a_7 : β a_5},
Std.DTreeMap.Internal.Impl.ExplorationStep.gt a a_1 a_2 a_3 =
Std.DTreeMap.Intern... | null | true |
Set.mapsTo_sUnion | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {S : Set (Set α)} {t : Set β} {f : α → β},
Set.MapsTo f (⋃₀ S) t ↔ ∀ s ∈ S, Set.MapsTo f s t | null | true |
SubAddAction.ofStabilizer.addConjMap_comp | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : AddGroup G] {α : Type u_2} [inst_1 : AddAction G α] {g h k : G} {a b c : α} (hg : b = g +ᵥ a)
(hh : c = h +ᵥ b) (hk : c = k +ᵥ a) (H : k = h + g),
(SubAddAction.ofStabilizer.conjMap hh).comp (SubAddAction.ofStabilizer.conjMap hg) =
SubAddAction.ofStabilizer.conjMap hk | null | true |
_private.Init.Data.UInt.Bitwise.0.USize.toUInt8_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | null | false |
Lean.Grind.Ring.toIntModule | Init.Grind.Ring.Basic | {α : Type u} → [I : Lean.Grind.Ring α] → Lean.Grind.IntModule α | null | true |
RingCat.Colimits.ColimitType.AddGroup._proof_2 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat) (n : ℕ)
(x : RingCat.Colimits.ColimitType F), (n + 1) • x = n • x + x | null | false |
CategoryTheory.GradedObject.mapBifunctor₁₂BifunctorDesc.congr_simp | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
SpecialLinearGroup.baseChange._proof_3 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_3} {V : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {S : Type u_2}
[inst_3 : CommRing S] [inst_4 : Algebra R S] [inst_5 : Module.Free R V] [inst_6 : Module.Finite R V]
(x y : SpecialLinearGroup R V),
↑⟨LinearEquiv.baseChange R S V V ↑(x * y), ⋯⟩ =
↑(⟨LinearEquiv... | null | false |
Lean.Meta.AbstractMVars.State.recOn | Lean.Meta.AbstractMVars | {motive : Lean.Meta.AbstractMVars.State → Sort u} →
(t : Lean.Meta.AbstractMVars.State) →
((ngen : Lean.NameGenerator) →
(lctx : Lean.LocalContext) →
(mctx : Lean.MetavarContext) →
(nextParamIdx : ℕ) →
(paramNames : Array Lean.Name) →
(fvars mvars : Arra... | null | false |
RatFunc.CompletionAtInfty.instField._aux_1 | Mathlib.FieldTheory.RatFunc.Valuation | (F : Type u_1) → [inst : Field F] → [inst_1 : DecidableEq (RatFunc F)] → RatFunc.CompletionAtInfty F | null | false |
ContinuousMap.sigmaCodHomeomorph.match_1 | Mathlib.Topology.ContinuousMap.Sigma | ∀ (X : Type u_3) {ι : Type u_1} (Y : ι → Type u_2) [inst : TopologicalSpace X]
[inst_1 : (i : ι) → TopologicalSpace (Y i)] (f : C(X, (i : ι) × Y i))
(motive : (∃ i g, f = (ContinuousMap.sigmaMk i).comp g) → Prop) (x : ∃ i g, f = (ContinuousMap.sigmaMk i).comp g),
(∀ (i : ι) (g : C(X, Y i)) (hg : f = (ContinuousMa... | null | false |
Lean.Lsp.DocumentFilter.ctorIdx | Lean.Data.Lsp.Basic | Lean.Lsp.DocumentFilter → ℕ | null | false |
_private.Init.Data.Dyadic.Basic.0.Dyadic.ble_iff_toRat._simp_1_1 | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, (x.blt y = true) = (x.toRat < y.toRat) | null | false |
NNRat.cast_zpow | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_1} [inst : DivisionSemiring α] [CharZero α] (q : ℚ≥0) (p : ℤ), ↑(q ^ p) = ↑q ^ p | null | true |
OrderIso.subRight_symm_apply | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [inst_2 : AddRightMono α] (a b : α),
(RelIso.symm (OrderIso.subRight a)) b = b + a | null | true |
CategoryTheory.Limits.createsLimitOfRightOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
(K : CategoryTheory.Functor J Cᵒᵖ) →
(F : CategoryTheory.Functor Cᵒᵖ D) →
... | If `F.rightOp : C ⥤ Dᵒᵖ` creates colimits of `K.leftOp : Jᵒᵖ ⥤ Cᵒᵖ`, then `F : Cᵒᵖ ⥤ D`
creates limits of `K : J ⥤ Cᵒᵖ`. | true |
Submodule.isHilbertSumOrthogonal | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (K : Submodule 𝕜 E) [hK : CompleteSpace ↥K],
IsHilbertSum 𝕜 (fun b => ↥(bif b then K else Kᗮ)) fun b => (bif b then K else Kᗮ).subtypeₗᵢ | null | true |
List.min | Init.Data.List.Basic | {α : Type u} → [Min α] → (l : List α) → l ≠ [] → α | Returns the smallest element of a non-empty list.
Examples:
* `[4].min (by decide) = 4`
* `[1, 4, 2, 10, 6].min (by decide) = 1`
| true |
Filter.empty_notMem | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α) [f.NeBot], ∅ ∉ f | null | true |
SeparationQuotient.instNormalSpace | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [NormalSpace X], NormalSpace (SeparationQuotient X) | The `SeparationQuotient` of a normal space is a normal space. | true |
Lean.VersoModuleDocs.Snippet.addBlock | Lean.DocString.Extension | Lean.VersoModuleDocs.Snippet → Lean.Doc.Block Lean.ElabInline Lean.ElabBlock → Lean.VersoModuleDocs.Snippet | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft._proof_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft | ∀ {w : ℕ} (distance curr : ℕ), curr < w → ¬curr + 1 ≤ w → False | null | false |
Norm.mk | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → (E → ℝ) → Norm E | null | true |
«term_∨_» | Init.Notation | Lean.TrailingParserDescr | `Or a b`, or `a ∨ b`, is the disjunction of propositions. There are two
constructors for `Or`, called `Or.inl : a → a ∨ b` and `Or.inr : b → a ∨ b`,
and you can use `match` or `cases` to destruct an `Or` assumption into the
two cases.
Conventions for notations in identifiers:
* The recommended spelling of `∨` in id... | true |
ceilDiv_le_iff_le_mul | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : CeilDiv α α] {a b c : α},
0 < a → (b ⌈/⌉ a ≤ c ↔ b ≤ a * c) | null | true |
Std.Tactic.BVDecide.LRAT.Internal.State.entails_add_of_entails_clause | Std.Tactic.BVDecide.LRAT.Internal.Add | ∀ {s : Std.Tactic.BVDecide.LRAT.Internal.State} {c : Std.Sat.CNF.Clause ℕ},
s.toCNF.EntailsClause c → s.toCNF.Entails (s.add c).toCNF | null | true |
BoundedOrderHom.dual_apply_toOrderHom | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] (f : BoundedOrderHom α β), (BoundedOrderHom.dual f).toOrderHom = OrderHom.dual f.toOrderHom | null | true |
DivisionRing.continuousConstSMul_rat | Mathlib.Topology.Algebra.Algebra.Rat | ∀ {A : Type u_1} [inst : DivisionRing A] [inst_1 : TopologicalSpace A] [SeparatelyContinuousMul A]
[inst_3 : CharZero A], ContinuousConstSMul ℚ A | The action induced by `DivisionRing.toRatAlgebra` is continuous. | true |
RatFunc.denom_div_dvd | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] (p q : Polynomial K),
((algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q).denom ∣ q | null | true |
Sym2.diagElemEquiv_apply | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x : { a // a.IsDiag }), Sym2.diagElemEquiv x = (↑x).diagElem ⋯ | null | true |
Fin.map_rev_findRev? | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {p : Fin n → Bool}, Option.map Fin.rev (Fin.findRev? fun x => p x.rev) = Fin.find? p | null | true |
ProbabilityTheory.integrable_cauchyPDFReal | Mathlib.Probability.Distributions.Cauchy | ∀ (x₀ : ℝ) {γ : NNReal}, MeasureTheory.Integrable (ProbabilityTheory.cauchyPDFReal x₀ γ) MeasureTheory.volume | null | true |
_private.Mathlib.Data.Fin.Basic.0.Fin.coe_int_sub_eq_mod._proof_1_3 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} (u v : Fin n), ¬0 ≤ ↑↑u - ↑↑v + ↑n → False | null | false |
dist_le_dist_of_le_pi | Mathlib.Analysis.Normed.Order.UpperLower | ∀ {α : Type u_1} [inst : NormedAddCommGroup α] [inst_1 : Lattice α] [IsOrderedAddMonoid α] [HasSolidNorm α]
{a₁ a₂ b₁ b₂ : α}, a₂ ≤ a₁ → a₁ ≤ b₁ → b₁ ≤ b₂ → dist a₁ b₁ ≤ dist a₂ b₂ | **Alias** of `dist_le_dist_of_le`. | true |
ClosedAddSubgroup.mk.sizeOf_spec | Mathlib.Topology.Algebra.Group.ClosedSubgroup | ∀ {G : Type u} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : SizeOf G] (toAddSubgroup : AddSubgroup G)
(isClosed' : IsClosed toAddSubgroup.carrier),
sizeOf { toAddSubgroup := toAddSubgroup, isClosed' := isClosed' } = 1 + sizeOf toAddSubgroup + sizeOf isClosed' | null | true |
_private.Mathlib.MeasureTheory.Measure.Hausdorff.0.MeasureTheory.Measure.hausdorffMeasure_zero_singleton._simp_1_2 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LitValue.impureTypeScalarNumLit._sparseCasesOn_2 | Lean.Compiler.LCNF.Basic | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
FreeAddGroup.mk | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → List (α × Bool) → FreeAddGroup α | The canonical map from `List (α × Bool)` to the free additive group on `α`. | true |
Std.Http.Internal.Test.mkPost | Std.Http.Test.Helpers | String → String → optParam String "" → String | POST with a fixed Content-Length body. `extra` is appended before the blank line.
| true |
PerfectRing.pow | Mathlib.FieldTheory.Perfect | ∀ (M : Type u_1) (p : ℕ) [inst : CommMonoid M] [PerfectRing M p] (n : ℕ), PerfectRing M (p ^ n) | null | true |
Nat.floor_natCast | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] (n : ℕ), ⌊↑n⌋₊ = n | null | true |
CategoryTheory.LaxMonoidalFunctor.Hom.ctorIdx | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{D : Type u₂} →
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} →
{inst_3 : CategoryTheory.MonoidalCategory D} → {F G : CategoryTheory.LaxMonoidalFunctor C D} → F.Hom G → ℕ | null | false |
_private.Init.Data.String.Decode.0.parseFirstByte_eq_done_of_utf8DecodeChar?_eq_some | Init.Data.String.Decode | ∀ {b : ByteArray} {i : ℕ} {c : Char},
b.utf8DecodeChar? i = some c →
c.utf8Size = 1 →
∀ (h' : i < b.size), ByteArray.utf8DecodeChar?.parseFirstByte b[i] = ByteArray.utf8DecodeChar?.FirstByte.done | null | true |
Aesop.SearchM.instMonad | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Monad (Aesop.SearchM Q) | null | true |
NNReal.rpow_sub_one' | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {y : ℝ}, y - 1 ≠ 0 → ∀ (x : NNReal), x ^ (y - 1) = x ^ y / x | null | true |
cyclotomicCharacter.toFun._proof_1 | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | ∀ (p : ℕ) [Fact (Nat.Prime p)] (n : ℕ), NeZero (p ^ n) | null | false |
Quiver.Path.vertices_ne_nil | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a b : V} (p : Quiver.Path a b), p.vertices ≠ [] | null | true |
Pi.constMonoidHom._proof_2 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ (α : Type u_1) (β : Type u_2) [inst : MulOneClass β] (x x_1 : β),
Function.const α (x * x_1) = Function.const α (x * x_1) | null | false |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.ofIso._proof_3 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.SimplicialObject.Augmented C}
(e : X ≅ Y) (ed : X.ExtraDegeneracy),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.SimplicialObject.Augmented.drop.mapIso e).inv.app (Opposite.o... | null | false |
IsDedekindFiniteAddMonoid.rec | Mathlib.Algebra.Group.Monoid | {M : Type u_2} →
[inst : AddZero M] →
{motive : IsDedekindFiniteAddMonoid M → Sort u} →
((add_eq_zero_symm : ∀ {a b : M}, a + b = 0 → b + a = 0) → motive ⋯) →
(t : IsDedekindFiniteAddMonoid M) → motive t | null | false |
Lean.Meta.MVarRenaming.mk.injEq | Lean.Meta.Match.MVarRenaming | ∀ (map map_1 : Lean.MVarIdMap Lean.MVarId), ({ map := map } = { map := map_1 }) = (map = map_1) | null | true |
Lean.Elab.WF.GuessLex.RecCallWithContext.rec | Lean.Elab.PreDefinition.WF.GuessLex | {motive : Lean.Elab.WF.GuessLex.RecCallWithContext → Sort u} →
((ref : Lean.Syntax) →
(caller : ℕ) →
(params : Array Lean.Expr) →
(callee : ℕ) →
(args : Array Lean.Expr) →
(ctxt : Lean.Elab.WF.GuessLex.SavedLocalContext) →
motive
{ re... | null | false |
Finset.exists_le_of_expect_le | Mathlib.Algebra.Order.BigOperators.Expect | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedCancelAddMonoid α]
[inst_3 : Module ℚ≥0 α] {a : α} {s : Finset ι} {f : ι → α},
s.Nonempty → (s.expect fun i => f i) ≤ a → ∃ x ∈ s, f x ≤ a | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₄_eq_some_of_toBitVec._simp_1_6 | Init.Data.String.Decode | ∀ {n : ℕ} {x y : BitVec n}, (x ≤ y) = (x.toNat ≤ y.toNat) | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.let._regBuiltin.Lean.Parser.Term.letOptNondep.formatter_9 | Lean.Parser.Term | IO Unit | null | false |
TopCat.uliftFunctor._proof_2 | Mathlib.Topology.Category.TopCat.ULift | ∀ (X : TopCat),
TopCat.ofHom
{ toFun := ULift.map ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)),
continuous_toFun := ⋯ } =
CategoryTheory.CategoryStruct.id ↧(ULift.{u_2, u_1} ↑X) | null | false |
FormalMultilinearSeries.iteratedFDerivSeries._proof_5 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (k : ℕ),
ContinuousAdd (E [×k]→L[𝕜] F) | null | false |
Complex.real_le_real | Mathlib.Analysis.Complex.Order | ∀ {x y : ℝ}, ↑x ≤ ↑y ↔ x ≤ y | null | true |
NumberField.ComplexEmbedding.IsConj.ext_iff | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_1} [inst : Field K] {k : Type u_2} [inst_1 : Field k] [inst_2 : Algebra k K] {φ : K →+* ℂ}
{σ₁ σ₂ : Gal(K/k)}, NumberField.ComplexEmbedding.IsConj φ σ₁ → (σ₁ = σ₂ ↔ NumberField.ComplexEmbedding.IsConj φ σ₂) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.