name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SubStarSemigroup.mk._flat_ctor | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} →
[inst : Mul M] →
[inst_1 : Star M] →
(carrier : Set M) →
(∀ {a b : M}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
(∀ {a : M}, a ∈ carrier → star a ∈ carrier) → SubStarSemigroup M | null | false |
USize.toUInt64 | Init.Data.UInt.Basic | USize → UInt64 | Converts word-sized unsigned integers to 32-bit unsigned integers. This cannot overflow because
`USize.size` is either `2^32` or `2^64`.
This function is overridden at runtime with an efficient implementation.
| true |
_private.Mathlib.Order.Northcott.0.northcott_iff_tendsto._simp_1_1 | Mathlib.Order.Northcott | ∀ {α : Type u_1} {β : Type u_2} (h : α → β) [inst : LE β], Northcott h = ∀ (b : β), {a | h a ≤ b}.Finite | null | false |
MvPolynomial.weightedDecomposition.decompose'_eq | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} (w : σ → M) [inst_1 : AddCommMonoid M]
[inst_2 : DecidableEq M],
DirectSum.Decomposition.decompose' = fun φ =>
(DirectSum.mk (fun i => ↥(MvPolynomial.weightedHomogeneousSubmodule R w i))
(Finset.image (⇑(Finsupp.weight w)) φ.support)... | null | true |
String.Slice.eq_append_of_dropPrefix?_string_eq_some | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s res : String.Slice}, s.dropPrefix? pat = some res → s.copy = pat ++ res.copy | null | true |
CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_inv_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C),
X.rightOpLeftOpIso.inv.right = CategoryTheory.CategoryStruct.id X.right | null | true |
Vector.toArray_zipIdx | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} (k : optParam ℕ 0), (xs.zipIdx k).toArray = xs.toArray.zipIdx k | null | true |
CategoryTheory.Functor.Final.colimitCoconeComp_isColimit | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.ColimitCocone G),
(Cat... | null | true |
GaussianInt.toComplex._proof_1 | Mathlib.NumberTheory.Zsqrtd.GaussianInt | Complex.I * Complex.I = ↑(-1) | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_dvd.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} (motive : a = ↑a.natAbs ∨ a = -↑a.natAbs → Prop) (x : a = ↑a.natAbs ∨ a = -↑a.natAbs),
(∀ (e : a = ↑a.natAbs), motive ⋯) → (∀ (e : a = -↑a.natAbs), motive ⋯) → motive x | null | false |
Topology.IsLowerSet.closure_singleton | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {a : α},
closure {a} = Set.Ici a | The closure of a singleton `{a}` in the lower set topology is the right-closed left-infinite
interval $(-∞,a]$.
| true |
List.prod_hom₂_nonempty | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {ι : Type u_1} {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P]
{l : List ι} (f : M → N → P),
(∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d) →
∀ (f₁ : ι → M) (f₂ : ι → N),
l ≠ [] → (List.map (fun i => f (f₁ i) (f₂ i)) l).prod = f (List.ma... | null | true |
ValuativeRel.IsNontrivial.casesOn | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : Semiring R] →
[inst_1 : ValuativeRel R] →
{motive : ValuativeRel.IsNontrivial R → Sort u} →
(t : ValuativeRel.IsNontrivial R) → ((condition : ∃ γ, γ ≠ 0 ∧ γ ≠ 1) → motive ⋯) → motive t | null | false |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.logMahlerMeasure_C_mul_X_add_C._simp_1_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
_private.Init.Meta.Defs.0.Lean.Syntax.structEq._sparseCasesOn_3 | Init.Meta.Defs | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Vector3.nil | Mathlib.Data.Vector3 | {α : Type u_1} → Vector3 α 0 | The empty vector | true |
_private.Mathlib.Analysis.Normed.Affine.AsymptoticCone.0.AffineSpace.asymptoticNhds_le_cobounded.match_1_1 | Mathlib.Analysis.Normed.Affine.AsymptoticCone | ∀ {P : Type u_1} (motive : Nonempty P → Prop) (x : Nonempty P), (∀ (p : P), motive ⋯) → motive x | null | false |
Mathlib.Meta.Positivity.evalInv | Mathlib.Algebra.Order.Field.Basic | Mathlib.Meta.Positivity.PositivityExt | The `positivity` extension which identifies expressions of the form `a⁻¹`,
such that `positivity` successfully recognises `a`. | true |
AddSubgroup.toAddSubmonoid | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_3} → [inst : AddGroup G] → AddSubgroup G → AddSubmonoid G | Reinterpret an `AddSubgroup` as an `AddSubmonoid`. | true |
allocprof | Init.System.IO | {α : Type} → String → IO α → IO α | null | true |
Int32.not_maxValue_lt | Init.Data.SInt.Lemmas | ∀ {a : Int32}, ¬Int32.maxValue < a | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.mk.sizeOf_spec | Lean.Elab.MutualInductive | ∀ (levels : Lean.LevelMap ℤ), sizeOf { levels := levels } = 1 + sizeOf levels | null | true |
Plausible.PNat.sampleableExt | Mathlib.Testing.Plausible.Sampleable | Plausible.SampleableExt ℕ+ | null | true |
CategoryTheory.Sieve.overEquiv.eq_1 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y : CategoryTheory.Over X),
CategoryTheory.Sieve.overEquiv Y =
{ toFun := fun S => CategoryTheory.Sieve.functorPushforward (CategoryTheory.Over.forget X) S,
invFun := fun S' => CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.forget ... | null | true |
Std.ExtTreeSet.min!_insert_le_self | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α]
{k : α}, (cmp (t.insert k).min! k).isLE = true | null | true |
NNReal.strictMono_rpow_of_pos | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {z : ℝ}, 0 < z → StrictMono fun x => x ^ z | null | true |
Algebra.instCompleteLatticeSubalgebra._proof_2 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(s : Set (Subalgebra R A)), IsGLB s (sInf s) | null | false |
CategoryTheory.Iso.commSemiRingCatIsoToRingEquiv._proof_2 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommSemiRingCat} (e : R ≅ S),
(CommSemiRingCat.Hom.hom e.inv).comp (CommSemiRingCat.Hom.hom e.hom) = RingHom.id ↑R | null | false |
IsDedekindDomain.selmerGroup.valuation | Mathlib.RingTheory.DedekindDomain.SelmerGroup | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
{K : Type v} →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] →
{S : Set (IsDedekindDomain.HeightOneSpectrum R)} →
{n : ℕ} → ↥IsDedekindDomain.selmerG... | The multiplicative `v`-adic valuations on `K⟮S, n⟯` for all `v ∈ S`. | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofEq.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {a b : Lean.Expr} {la lb : Lean.Meta.Grind.Arith.Linear.LinExpr} {a_1 b_1 : Lean.Expr}
{la_1 lb_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofEq a b la lb =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofEq a_1 b_1 la_1 lb_1 →
a = a_1 ∧ b = b_1 ∧ la = la_1 ∧ lb ... | null | true |
LinearMap.IsNonneg.mk | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{I₁ I₂ : R →+* R} [inst_3 : LE R] {B : M →ₛₗ[I₁] M →ₛₗ[I₂] R}, (∀ (x : M), 0 ≤ (B x) x) → B.IsNonneg | null | true |
ProofWidgets.Jsx.getJsxText | ProofWidgets.Data.Html | Lean.TSyntax `ProofWidgets.Jsx.jsxText → String | null | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_2 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a : Array α} (i_1 : ℕ), i_1 + 1 ≤ (a.extract i j).size → i_1 < (a.extract i j).size | null | false |
BoxIntegral.Box | Mathlib.Analysis.BoxIntegral.Box.Basic | Type u_2 → Type u_2 | A nontrivial rectangular box in `ι → ℝ` with corners `lower` and `upper`. Represents the product
of half-open intervals `(lower i, upper i]`. | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._proof_20 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_4} {S : C} {X : ι → C} {S' : C} {p : S' ⟶ S}
{ι' : Type u_3} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'} {α : ι' → ι} {p' : (j : ι') → X' j ⟶ X (α j)} ⦃Y : C⦄
(q : Y ⟶ S') ⦃j₁ j₂ : ι'⦄ (f₁ : Y ⟶ X' j₁) (f₂ : Y ⟶ X' j₂) (q' : Y ⟶ S) (f₂' : Y ⟶ ... | null | false |
Std.Iter.findSome? | Init.Data.Iterators.Consumers.Loop | {α β : Type w} →
{γ : Type x} → [inst : Std.Iterator α Id β] → [Std.IteratorLoop α Id Id] → Std.Iter β → (β → Option γ) → Option γ | Returns the first non-`none` result of applying `f` to each output of the iterator, in order.
Returns `none` if `f` returns `none` for all outputs.
`O(|it|)`. Short-circuits when `f` returns `some _`.The outputs of `it` are examined in order of
iteration.
If the iterator is not finite, this function might run forever... | true |
UniformSpace.Completion.instAddMonoid._proof_11 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] (a : UniformSpace.Completion α),
0 • a = 0 | null | false |
_private.Mathlib.Tactic.Observe.0.Mathlib.Tactic.LibrarySearch._aux_Mathlib_Tactic_Observe___elabRules_Mathlib_Tactic_LibrarySearch_observe_1.match_7 | Mathlib.Tactic.Observe | (motive : Option (Array (List Lean.MVarId × Lean.MetavarContext)) → Sort u_1) →
(__do_lift : Option (Array (List Lean.MVarId × Lean.MetavarContext))) →
((val : Array (List Lean.MVarId × Lean.MetavarContext)) → motive (some val)) →
((x : Option (Array (List Lean.MVarId × Lean.MetavarContext))) → motive x) → ... | null | false |
AlgebraicGeometry.ProjIsoSpecTopComponent.FromSpec.tacticMem_tac | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr | `mem_tac` tries to prove goals of the form `x ∈ 𝒜 i` when `x` has the form of:
* `y ^ n` where `i = n • j` and `y ∈ 𝒜 j`.
* a natural number `n`.
| true |
CochainComplex.shiftShortComplexFunctorIso_add'_hom_app._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | ∀ (n m mn : ℤ), m + n = mn → ∀ (a a' a'' : ℤ), n + a = a' → m + a' = a'' → mn + a = a'' | null | false |
LinearPMap.sup | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
[inst : Ring R] →
[inst_1 : Ring S] →
{σ : R →+* S} →
{E : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : Module R E] →
{F : Type u_5} →
[inst_4 : AddCommGroup F] →
[inst_5 ... | Given two partial linear maps that agree on the intersection of their domains,
`f.sup g h` is the unique partial linear map on `f.domain ⊔ g.domain` that agrees
with `f` and `g`. | true |
Function.Even.left_comp | Mathlib.Algebra.Group.EvenFunction | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] {γ : Type u_3} {g : α → β},
Function.Even g → ∀ (f : β → γ), Function.Even (f ∘ g) | If `f` is arbitrary and `g` is even, then `f ∘ g` is even. | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.ms_eq_mk_iff | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : List (ℝ → ℝ)}
(ms : Tactic.ComputeAsymptotics.MultiseriesExpansion (basis_hd :: basis_tl))
(s : Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) (f : ℝ → ℝ),
ms = Tactic.ComputeAsymptotics.MultiseriesExpansion.mk s f ↔ ms.seq = s ∧ ms.toFun = f | null | true |
_private.Mathlib.Analysis.Complex.AbelLimit.0.Complex.tendsto_tsum_powerSeries_nhdsWithin_stolzSet._simp_1_4 | Mathlib.Analysis.Complex.AbelLimit | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [Nonempty β] [inst_2 : SemilatticeSup β] {u : β → α} {a : α},
Filter.Tendsto u Filter.atTop (nhds a) = ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) a < ε | null | false |
Lean.JsonRpc.MessageMetaData._sizeOf_inst | Lean.Data.JsonRpc | SizeOf Lean.JsonRpc.MessageMetaData | null | false |
_private.Init.Data.SInt.Lemmas.0.Int16.ne_of_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int16}, (x = y) = (x.toInt = y.toInt) | null | false |
ProofWidgets.RpcEncodablePacket.component.injEq._@.ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1 | ProofWidgets.Data.Html | ∀ (a a_1 a_2 a_3 a_4 a_5 a_6 a_7 : Lean.Json),
(ProofWidgets.RpcEncodablePacket.component✝ a a_1 a_2 a_3 =
ProofWidgets.RpcEncodablePacket.component✝ a_4 a_5 a_6 a_7) =
(a = a_4 ∧ a_1 = a_5 ∧ a_2 = a_6 ∧ a_3 = a_7) | null | false |
_private.Mathlib.GroupTheory.GroupAction.Basic.0.MulAction.fixedPoints_of_subsingleton._simp_1_1 | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] {a : α},
(a ∈ MulAction.fixedPoints M α) = ∀ (m : M), m • a = a | null | false |
CategoryTheory.Limits.CatCospanTransform.mkIso_hom_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆}
[inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3 : CategoryTheor... | null | true |
Lean.Meta.SizeOfSpecNested.Context.mk.noConfusion | Lean.Meta.SizeOf | {P : Sort u} →
{indInfo : Lean.InductiveVal} →
{sizeOfFns : Array Lean.Name} →
{ctorName : Lean.Name} →
{params localInsts : Array Lean.Expr} →
{recMap : Lean.NameMap Lean.Name} →
{indInfo' : Lean.InductiveVal} →
{sizeOfFns' : Array Lean.Name} →
{c... | null | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup.0.SubMulAction.IsPretransitive.isPretransitive_ofFixingSubgroup_inter.match_1_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_2} {α : Type u_1} [inst : Group M] [inst_1 : MulAction M α] {s : Set α} {g : M}
(motive : ↑(s ∩ g • s) → Prop) (x : ↑(s ∩ g • s)), (∀ (y : α) (hy : y ∈ s ∩ g • s), motive ⟨y, hy⟩) → motive x | null | false |
SeparationQuotient.lift'_mk | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : T0Space β] {f : α → β},
UniformContinuous f → ∀ (a : α), SeparationQuotient.lift' f (SeparationQuotient.mk a) = f a | null | true |
_private.Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing.0.IsDedekindDomain.FiniteAdeleRing.isUnit_iff._simp_1_4 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
CategoryTheory.ObjectProperty.IsConservativeFamilyOfPoints.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Point.Conservative | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
{P : CategoryTheory.ObjectProperty J.Point},
(CategoryTheory.JointlyReflectIsomorphisms fun Φ => Φ.obj.sheafFiber) → P.IsConservativeFamilyOfPoints | null | false |
_private.Mathlib.Order.ScottContinuity.0.ScottContinuous.const._simp_1_1 | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
ScottContinuous f = ScottContinuousOn Set.univ f | null | false |
CategoryTheory.AddGrpObj.eq_lift_neg_left | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.AddGrpObj B] (f g h : A ⟶ B),
f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStr... | null | true |
Filter.Realizer.map._proof_5 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_3} {β : Type u_1} (m : α → β) {f : Filter α} (F : f.Realizer) (x : Set β),
x ∈ { f := fun s => m '' F.F.f s, pt := F.F.pt, inf := F.F.inf, inf_le_left := ⋯, inf_le_right := ⋯ }.toFilter.sets ↔
x ∈ (Filter.map m f).sets | null | false |
ClosedAddSubgroup.instCoeAddSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → Coe (ClosedAddSubgroup G) (AddSubgroup G) | null | true |
Seminorm.sSup_empty | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E], sSup ∅ = ⊥ | null | true |
CategoryTheory.FunctorToTypes.monoFactorisation_e | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Images | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor C (Type u)} (f : F ⟶ G),
(CategoryTheory.FunctorToTypes.monoFactorisation f).e = CategoryTheory.Subfunctor.toRange f | null | true |
Std.HashMap.Raw.all_eq_false_iff_exists_mem_getElem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.all p = false ↔ ∃ a, ∃ (h : a ∈ m), p a m[a] = false) | null | true |
Matroid.not_indep_iff | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, autoParam (X ⊆ M.E) Matroid.not_indep_iff._auto_1 → (¬M.Indep X ↔ M.Dep X) | null | true |
Array.partition | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Array α × Array α | Returns a pair of arrays that together contain all the elements of `as`. The first array contains
those elements for which `p` returns `true`, and the second contains those for which `p` returns
`false`.
`as.partition p` is equivalent to `(as.filter p, as.filter (not ∘ p))`, but it is
more efficient since it only has ... | true |
CategoryTheory.Lax.LaxTrans.homCategory._proof_6 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {W X Y Z : F ⟶ G} (f : CategoryTheory.Lax.LaxTrans.Hom W X)
(g : CategoryTheory.Lax.LaxTrans.Hom X Y) (h : CategoryTheory.Lax.LaxTrans.Hom Y Z),
{ as := { as := f.as.vc... | null | false |
isAddRightRegular_ofColex | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : Colex α}, IsAddRightRegular (ofColex a) ↔ IsAddRightRegular a | null | true |
AlgebraicGeometry.Spec.map | Mathlib.AlgebraicGeometry.Scheme | {R S : CommRingCat} → (R ⟶ S) → (AlgebraicGeometry.Spec S ⟶ AlgebraicGeometry.Spec R) | The induced map of a ring homomorphism on the ring spectra, as a morphism of schemes. | true |
_private.Mathlib.RingTheory.Ideal.Quotient.PowTransition.0.Submodule.powSMulQuotInclusion_injective._simp_1_3 | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R M} {q : Submodule R₂ ... | null | false |
Complex.IsExpCmpFilter.isLittleO_zpow_mul_exp | Mathlib.Analysis.SpecialFunctions.CompareExp | ∀ {l : Filter ℂ} {b₁ b₂ : ℝ},
Complex.IsExpCmpFilter l →
b₁ < b₂ → ∀ (m n : ℤ), (fun z => z ^ m * Complex.exp (↑b₁ * z)) =o[l] fun z => z ^ n * Complex.exp (↑b₂ * z) | If `l : Filter ℂ` is an "exponential comparison filter", then for any complex `a₁`, `a₂` and any
integer `b₁ < b₂`, we have
`(fun z ↦ z ^ a₁ * exp (b₁ * z)) =o[l] (fun z ↦ z ^ a₂ * exp (b₂ * z))`. | true |
StrongFEPair.symm_Λ_eq | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (P : StrongFEPair E), P.symm.Λ = mellin P.g | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.r_pos._simp_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (z : UpperHalfPlane), (0 < z.im) = True | null | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.Defs.0.ArithmeticFunction.IsMultiplicative.mul._simp_1_3 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {n : ℕ} {x : ℕ × ℕ}, (x ∈ n.divisorsAntidiagonal) = (x.1 * x.2 = n ∧ n ≠ 0) | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.skipPrefixWhile_eq_startPos_iff._simp_1_3 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {s : String}, s.startPos.toSlice = s.toSlice.startPos | null | false |
Lean.Grind.CommRing.instBEqExpr | Init.Grind.Ring.CommSolver | BEq Lean.Grind.CommRing.Expr | null | true |
CategoryTheory.monoidalOpOp._proof_4 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(X' : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.opOp C).obj X')
((CategoryTheory.opOp C).map f))
(Cat... | null | false |
Std.Http.Body.instToByteArrayString | Std.Http.Data.Body.Basic | Std.Http.Body.ToByteArray String | null | true |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_10 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x y : ↥(Unitization.unitsFstOne R A)),
PreQuasiregular.equiv.symm
↑{ val := PreQuasiregular.equiv (↑↑(x * y)).toProd.2, inv := PreQuasireg... | null | false |
CategoryTheory.Endofunctor.Algebra.functorOfNatTrans | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F G : CategoryTheory.Functor C C} →
(G ⟶ F) → CategoryTheory.Functor (CategoryTheory.Endofunctor.Algebra F) (CategoryTheory.Endofunctor.Algebra G) | From a natural transformation `α : G → F` we get a functor from
algebras of `F` to algebras of `G`.
| true |
exists_continuous_add_one_of_isCompact_nnreal | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T2Space X] [LocallyCompactSpace X] {s₀ s₁ t : Set X},
IsCompact s₀ →
IsCompact s₁ →
IsCompact t →
Disjoint s₀ s₁ → s₀ ∪ s₁ ⊆ t → ∃ f₀ f₁, Set.EqOn (⇑f₀) 1 s₀ ∧ Set.EqOn (⇑f₁) 1 s₁ ∧ Set.EqOn (⇑(f₀ + f₁)) 1 t | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{combined : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget aig combined →
{α' : Type} →
[inst' : Hashable α'] →
[inst'_1 : Decid... | null | false |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum | Lean.Compiler.NameMangling | (s : String) → s.Pos → Lean.Name → ℕ → Lean.Name | null | true |
sup_eq_right._simp_2 | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a ⊔ b = b) = (a ≤ b) | null | false |
nsmul_pos | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddLeftMono M] {a : M},
0 < a → ∀ {k : ℕ}, k ≠ 0 → 0 < k • a | null | true |
IndexedPartition.piecewise_preimage | Mathlib.Data.Setoid.Partition | ∀ {ι : Type u_1} {α : Type u_2} {s : ι → Set α} (hs : IndexedPartition s) {β : Type u_3} (f : ι → α → β) (t : Set β),
hs.piecewise f ⁻¹' t = ⋃ i, s i ∩ f i ⁻¹' t | null | true |
Nat.unpaired | Mathlib.Computability.Primrec.Basic | {α : Sort u_1} → (ℕ → ℕ → α) → ℕ → α | Calls the given function on a pair of entries `n`, encoded via the pairing function. | true |
NonUnitalNonAssocCommSemiring.noConfusion | Mathlib.Algebra.Ring.Defs | {P : Sort u_1} →
{α : Type u} →
{t : NonUnitalNonAssocCommSemiring α} →
{α' : Type u} →
{t' : NonUnitalNonAssocCommSemiring α'} → α = α' → t ≍ t' → NonUnitalNonAssocCommSemiring.noConfusionType P t t' | null | false |
WeierstrassCurve.a₂ | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → WeierstrassCurve R → R | The `a₂` coefficient of a Weierstrass curve. | true |
finInsepDegree_eq_pow | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (q : ℕ) [ExpChar F q]
[FiniteDimensional F E], ∃ n, Field.finInsepDegree F E = q ^ n | null | true |
Lie.Derivation.ofLieDerivation | Mathlib.Algebra.Lie.Derivation.BaseChange | {R : Type u_1} →
[inst : CommRing R] →
(A : Type u_2) →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
{L : Type u_3} →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
LieDerivation R L L →ₗ⁅R⁆ LieDerivation R (TensorProduct R A L) (TensorProd... | A Lie derivation of an `R-`Lie algebra `L`, induces a Lie derivation of `A ⊗[R] L` for any
Algebra `A` over `R`. | true |
Lean.Meta.LazyDiscrTree.getMatchLoop | Lean.Meta.LazyDiscrTree | {α : Type} →
Array Lean.Meta.LazyDiscrTree.PartialMatch →
Lean.Meta.LazyDiscrTree.MatchResult α → Lean.Meta.LazyDiscrTree.MatchM α (Lean.Meta.LazyDiscrTree.MatchResult α) | Evaluate all partial matches and add resulting matches to `MatchResult`.
The partial matches are stored in an array that is used as a stack. When adding
multiple partial matches to explore next, to ensure the order of results matches
user expectations, this code must add paths we want to prioritize and return
results ... | true |
AddGroupNorm.casesOn | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : AddGroupNorm G → Sort u} →
(t : AddGroupNorm G) →
((toAddGroupSeminorm : AddGroupSeminorm G) →
(eq_zero_of_map_eq_zero' : ∀ (x : G), toAddGroupSeminorm.toFun x = 0 → x = 0) →
motive { toAddGroupSeminorm := toAddGroupSeminorm,... | null | false |
Std.DTreeMap.Internal.Impl.glue.eq_3 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} (size : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hl_2 : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) (sz' : ℕ) (k'_1 : α) (v'_1 : β k'_1)
(l'' r'' : Std.DTreeMap.Internal.Impl α β) (hr_2 : (Std.DTreeMap.Internal.Impl.inner sz' k'_1 v'_1 l'' r... | null | true |
Fin2.insertPerm.eq_def | Mathlib.Data.Vector3 | ∀ (x : ℕ) (x_1 x_2 : Fin2 x),
x_1.insertPerm x_2 =
match x, x_1, x_2 with
| .(n + 1), Fin2.fz, Fin2.fz => Fin2.fz
| .(n + 1), Fin2.fz, j.fs => j.fs
| .(a.succ + 1), a_1.fs, Fin2.fz => Fin2.fz.fs
| .(a.succ + 1), i.fs, j.fs =>
match i.insertPerm j with
| Fin2.fz => Fin2.fz
| k.fs ... | null | true |
String.Slice.Pos.skipWhile._unsafe_rec | Init.Data.String.Slice | {ρ : Type} → {s : String.Slice} → s.Pos → (pat : ρ) → [String.Slice.Pattern.ForwardPattern pat] → s.Pos | null | false |
Nonneg.linearOrderedCommGroupWithZero._proof_6 | Mathlib.Algebra.Order.Nonneg.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α], 0⁻¹ = 0 | null | false |
_private.Mathlib.CategoryTheory.Limits.Types.Colimits.0.CategoryTheory.Limits.Types.isColimit_iff_coconeTypesIsColimit._simp_1_1 | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)} (c : F.CoconeTypes),
c.IsColimit = Nonempty (CategoryTheory.Limits.IsColimit (F.coconeTypesEquiv c)) | null | false |
OpenPartialHomeomorph.IsImage.restr._proof_3 | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e : OpenPartialHomeomorph X Y} {s : Set X} {t : Set Y} (h : e.IsImage s t), ContinuousOn ↑e.symm ⋯.restr.target | null | false |
EReal.toENNReal_ne_zero_iff | Mathlib.Data.EReal.Basic | ∀ {x : EReal}, x.toENNReal ≠ 0 ↔ 0 < x | null | true |
_private.Mathlib.MeasureTheory.Measure.Stieltjes.0.StieltjesFunction.outer_trim._simp_1_1 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (iInf f < a) = ∃ i, f i < a | null | false |
DirectLimit.instSemigroupOfMulHomClass.eq_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → Semigroup (G ... | null | true |
Lean.Lsp.instToJsonDiagnosticSeverity.match_1 | Lean.Data.Lsp.Diagnostics | (motive : Lean.Lsp.DiagnosticSeverity → Sort u_1) →
(x : Lean.Lsp.DiagnosticSeverity) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.error) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.warning) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.information) →
(Unit → motive Lean.Lsp.DiagnosticSeve... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.