name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
isClopen_iInter | Mathlib.Topology.AlexandrovDiscrete | ∀ {ι : Sort u_1} {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {f : ι → Set α},
(∀ (i : ι), IsClopen (f i)) → IsClopen (⋂ i, f i) | null | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabOfNatCore._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.Builtins | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.normalOfIsPushoutSndOfNormal._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S} [gn : CategoryTheory.NormalEpi g]
(comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k)
(t : CategoryT... | null | false |
Std.TreeSet.Raw.max?_eq_none_iff._simp_1 | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → (t.max? = none) = (t.isEmpty = true) | null | false |
matrixEquivTensor._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_2) (R : Type u_1) (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Fintype n] [inst_4 : DecidableEq n],
Function.RightInverse (MatrixEquivTensor.equiv n R A).invFun (MatrixEquivTensor.equiv n R A).toFun | null | false |
BitVec.mul_succ | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x * (y + 1#w) = x * y + x | null | true |
Equiv.IicFinsetSet._proof_2 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] (a : α),
Function.LeftInverse (fun b => ⟨↑b, ⋯⟩) fun b => ⟨↑b, ⋯⟩ | null | false |
two_mul_le_add_mul_sq | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a b ε : α},
0 < ε → 2 * a * b ≤ ε * a ^ 2 + ε⁻¹ * b ^ 2 | null | true |
nhdsWithin_extChartAt_target_eq_of_mem | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] {x : M} {z : E},
z ∈ (extChartAt I x)... | Around a point in the target, the neighborhoods are the same within `(extChartAt I x).target`
and within `range I`. | true |
CategoryTheory.Limits.IsImage.instInhabitedSelf | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.Mono f] →
Inhabited (CategoryTheory.Limits.IsImage (CategoryTheory.Limits.MonoFactorisation.self f)) | null | true |
Lean.Elab.Command.ComputedFieldView.mk.injEq | Lean.Elab.MutualInductive | ∀ (ref modifiers : Lean.Syntax) (fieldId : Lean.Name) (type : Lean.Term)
(matchAlts : Lean.TSyntax `Lean.Parser.Term.matchAlts) (ref_1 modifiers_1 : Lean.Syntax) (fieldId_1 : Lean.Name)
(type_1 : Lean.Term) (matchAlts_1 : Lean.TSyntax `Lean.Parser.Term.matchAlts),
({ ref := ref, modifiers := modifiers, fieldId :=... | null | true |
Std.DTreeMap.Internal.Const.RoiSliceData.noConfusionType | Std.Data.DTreeMap.Internal.Zipper | Sort u_1 →
{α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.DTreeMap.Internal.Const.RoiSliceData α β →
{α' : Type u} → {β' : Type v} → [inst' : Ord α'] → Std.DTreeMap.Internal.Const.RoiSliceData α' β' → Sort u_1 | null | false |
Std.Internal.List.getValue?_insertList | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((_ : α) × β)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.DistinctKeys toInsert →
Std.Internal.List.getValue? k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.getValue? k toInsert).or (Std.I... | null | true |
Set.insert_diff_subset | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α} {a : α}, insert a s \ t ⊆ insert a (s \ t) | **Alias** of `Set.insert_sdiff_subset`. | true |
Algebra.norm | Mathlib.RingTheory.Norm.Defs | (R : Type u_1) → {S : Type u_2} → [inst : CommRing R] → [inst_1 : Ring S] → [Algebra R S] → S →* R | The norm of an element `s` of an `R`-algebra is the determinant of `(*) s`. | true |
HasFTaylorSeriesUpToOn.hasStrictFDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {𝕂 : Type u_1} [inst : RCLike 𝕂] {E' : Type u_2} [inst_1 : NormedAddCommGroup E'] [inst_2 : NormedSpace 𝕂 E']
{F' : Type u_3} [inst_3 : NormedAddCommGroup F'] [inst_4 : NormedSpace 𝕂 F'] {n : WithTop ℕ∞} {s : Set E'}
{f : E' → F'} {x : E'} {p : E' → FormalMultilinearSeries 𝕂 E' F'},
HasFTaylorSeriesUpToOn ... | If a function has a Taylor series at order at least 1, then at points in the interior of the
domain of definition, the term of order 1 of this series is a strict derivative of `f`. | true |
MulRingSeminormClass | Mathlib.Algebra.Order.Hom.Basic | (F : Type u_7) →
(α : outParam (Type u_8)) →
(β : outParam (Type u_9)) → [NonAssocRing α] → [Semiring β] → [PartialOrder β] → [FunLike F α β] → Prop | `MulRingSeminormClass F α` states that `F` is a type of `β`-valued multiplicative seminorms
on the ring `α`.
You should extend this class when you extend `MulRingSeminorm`. | true |
IsSumSq.natCast._simp_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {R : Type u_2} [inst : NonAssocSemiring R] (n : ℕ), IsSumSq ↑n = True | null | false |
LinearEquiv.multilinearMapCongrRight.congr_simp | Mathlib.LinearAlgebra.Multilinear.Finsupp | ∀ {R : Type uR} (S : Type uS) {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} {M₃ : Type v₃} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : (i : ι) → Module R (M₁ i)] [inst_3 : AddCommMonoid M₂]
[inst_4 : Module R M₂] [inst_5 : Semiring S] [inst_6 : Module S M₂] [inst_7 : SMulCommClass R S ... | null | true |
RingCon.mk'._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (c : RingCon R), ↑1 = ↑1 | null | false |
WithZero.instPreorder._proof_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Preorder α],
autoParam (∀ (a b : WithZero α), a < b ↔ a ≤ b ∧ ¬b ≤ a) Preorder.lt_iff_le_not_ge._autoParam | null | false |
RingEquiv.piMulOpposite._proof_4 | Mathlib.Algebra.Ring.Equiv | ∀ {ι : Type u_1} (S : ι → Type u_2) [inst : (i : ι) → NonUnitalNonAssocSemiring (S i)] (x x_1 : ((i : ι) → S i)ᵐᵒᵖ),
(fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i)) = fun i => MulOpposite.op (MulOpposite.unop (x + x_1) i) | null | false |
CategoryTheory.Dial.tensorUnit_rel | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C],
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Dial C)).rel = ⊤ | null | true |
Lean.Lsp.InlayHintParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.InlayHintParams} → t = t' → Lean.Lsp.InlayHintParams.noConfusionType P t t' | null | false |
Chebyshev.primeCounting_sub_theta_div_log_isBigO | Mathlib.NumberTheory.Chebyshev | (fun x => ↑⌊x⌋₊.primeCounting - Chebyshev.theta x / Real.log x) =O[Filter.atTop] fun x => x / Real.log x ^ 2 | null | true |
NNDist.mk.noConfusion | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} →
{P : Sort u} →
{nndist nndist' : α → α → NNReal} → { nndist := nndist } = { nndist := nndist' } → (nndist ≍ nndist' → P) → P | null | false |
DFinsupp.liftAddHom_apply_single | Mathlib.Data.DFinsupp.BigOperators | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)]
[inst_2 : AddCommMonoid γ] (f : (i : ι) → β i →+ γ) (i : ι) (x : β i),
((DFinsupp.liftAddHom f) fun₀ | i => x) = (f i) x | The `DFinsupp` version of `Finsupp.liftAddHom_apply_single` | true |
Tropical.instAddCommSemigroupTropical._proof_2 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (x x_1 : Tropical R), x + x_1 = x_1 + x | null | false |
threeGPFree_smul_set₀ | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} [inst : CommMonoidWithZero α] [IsCancelMulZero α] [NoZeroDivisors α] {s : Set α} {a : α},
a ≠ 0 → (ThreeGPFree (a • s) ↔ ThreeGPFree s) | null | true |
ProbabilityTheory.Kernel.withDensity_zero' | Mathlib.Probability.Kernel.WithDensity | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
[inst : ProbabilityTheory.IsSFiniteKernel κ], (κ.withDensity fun x x_1 => 0) = 0 | null | true |
Submodule.Quotient.addCommGroup._proof_5 | Mathlib.LinearAlgebra.Quotient.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M),
autoParam (∀ (a b : M ⧸ p), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
Nat.Prime.dvd_primorial_iff | Mathlib.NumberTheory.Primorial | ∀ {p n : ℕ}, Nat.Prime p → (p ∣ primorial n ↔ p ≤ n) | null | true |
Lean.MessageData.ofWidget.sizeOf_spec | Lean.Message | ∀ (a : Lean.Widget.WidgetInstance) (a_1 : Lean.MessageData),
sizeOf (Lean.MessageData.ofWidget a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
star_left_conjugate_le_conjugate | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a b : R}, a ≤ b → ∀ (c : R), star c * a * c ≤ star c * b * c | null | true |
CategoryTheory.GrpObj.zpow_comp_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G H X : C} [inst_2 : CategoryTheory.GrpObj G] [inst_3 : CategoryTheory.GrpObj H] (f : X ⟶ G) (n : ℤ) (g : G ⟶ H)
[CategoryTheory.IsMonHom g] {Z : C} (h : H ⟶ Z),
CategoryTheory.CategoryStruct.comp (f ^ ... | null | true |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.reassocMax.maxArgs._sparseCasesOn_1 | Lean.Meta.Constructions.CtorElim | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → ((a a_1 : Lean.Level) → motive (a.max a_1)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Util.Diff.0.Lean.Diff.Histogram.addLeft.match_1 | Lean.Util.Diff | {α : Type u_1} →
{lsize rsize : ℕ} →
(motive : Option (Lean.Diff.Histogram.Entry α lsize rsize) → Sort u_2) →
(x : Option (Lean.Diff.Histogram.Entry α lsize rsize)) →
(Unit → motive none) → ((x : Lean.Diff.Histogram.Entry α lsize rsize) → motive (some x)) → motive x | null | false |
Cardinal.mk_range_inr | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u} {β : Type v}, Cardinal.mk ↑(Set.range Sum.inr) = Cardinal.lift.{u, v} (Cardinal.mk β) | null | true |
Lean.Parser.Term.set_option.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
CategoryTheory.Limits.ConeMorphism.w_assoc | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {A B : CategoryTheory.Limits.Cone F} (self : CategoryTheory.Limits.ConeMorphism A B)
(j : J) {Z : C} (h : F.obj j ⟶ Z),
CategoryTheory.CategoryStruct.comp self.h... | The triangle consisting of the two natural transformations and `hom` commutes | true |
IsTop.not_isBot | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α} [Nontrivial α], IsTop a → ¬IsBot a | null | true |
bddOrd_dual_comp_forget_to_bipointed | Mathlib.Order.Category.BddOrd | BddOrd.dual.comp (CategoryTheory.forget₂ BddOrd Bipointed) =
(CategoryTheory.forget₂ BddOrd Bipointed).comp Bipointed.swap | null | true |
_private.Mathlib.Topology.Algebra.Group.OpenMapping.0.isOpenMap_smul_of_sigmaCompact._simp_1_1 | Mathlib.Topology.Algebra.Group.OpenMapping | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
IsOpenMap f = ∀ (x : X), nhds (f x) ≤ Filter.map f (nhds x) | null | false |
WeakFEPair.f_modif_aux1 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (P : WeakFEPair E),
Set.EqOn (fun x => P.f_modif x - P.f x + P.f₀)
(((Set.Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1)
(Set.Ioi 0) | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom.congr_simp | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J) (U : ↑X.affineOpens),
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U =
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.Stained.toFMVarId.match_1 | Mathlib.Tactic.Linter.FlexibleLinter | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) → (Unit → motive none) → ((decl : Lean.LocalDecl) → motive (some decl)) → motive x | null | false |
String.Pos.le_slice_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos} {q : s.Pos} {h₀ : p₀ ≤ q} {h₁ : q ≤ p₁},
p ≤ q.slice p₀ p₁ h₀ h₁ ↔ String.Pos.ofSlice p ≤ q | null | true |
Algebra.GrothendieckAddGroup.lift | Mathlib.GroupTheory.MonoidLocalization.GrothendieckGroup | {M : Type u_1} →
{G : Type u_2} →
[inst : AddCommMonoid M] → [inst_1 : AddCommGroup G] → (M →+ G) ≃ (Algebra.GrothendieckAddGroup M →+ G) | A monoid homomorphism from a monoid `M` to a group `G` lifts to a group homomorphism from the
Grothendieck group of `M` to `G`. | true |
_private.Lean.Elab.DocString.0.Lean.Doc.fixupInline.match_3 | Lean.Elab.DocString | (motive : Option Lean.Doc.ElabLink✝ → Sort u_1) →
(x : Option Lean.Doc.ElabLink✝) →
((name : Lean.StrLit) → motive (some { name := name })) → ((x : Option Lean.Doc.ElabLink✝) → motive x) → motive x | null | false |
CategoryTheory.PrelaxFunctor.id._proof_3 | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
(CategoryTheory.PrelaxFunctorStruct.id B).map₂ (CategoryTheory.CategoryStruct.comp η θ) =
CategoryTheory.CategoryStruct.comp ((CategoryTheory.PrelaxFunctorStruct.id B).map₂ η)
((CategoryTheory.PrelaxFunc... | null | false |
SkewMonoidAlgebra.mapDomain_smul | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_3} {f : G → G'} {v : SkewMonoidAlgebra k G}
{R : Type u_5} [inst_1 : Monoid R] [inst_2 : DistribMulAction R k] {b : R},
(SkewMonoidAlgebra.mapDomain f) (b • v) = b • (SkewMonoidAlgebra.mapDomain f) v | null | true |
MulEquiv.monoidHomCongrLeft.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M₁ : Type u_5} {M₂ : Type u_6} {N : Type u_8} [inst : MulOneClass M₁] [inst_1 : MulOneClass M₂]
[inst_2 : CommMonoid N] (e : M₁ ≃* M₂), e.monoidHomCongrLeft = { toEquiv := e.monoidHomCongrLeftEquiv, map_mul' := ⋯ } | null | true |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.maxCalls | Lean.Util.ParamMinimizer | {m : Type → Type} → Lean.Util.ParamMinimizer.Context✝ m → ℕ | Budget. That is, the maximum number of calls to `test` that we are willing to perform.
`0` means unbounded.
| true |
SimpleGraph.Embedding.sumInl | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_3} → {W : Type u_5} → {G : SimpleGraph V} → {H : SimpleGraph W} → G ↪g G ⊕g H | The embedding of `G` into `G ⊕g H`. | true |
CStarAlgebra.pow_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
AddSubgroup.instPartialOrder.eq_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G], AddSubgroup.instPartialOrder = PartialOrder.ofSetLike (AddSubgroup G) G | null | true |
Lean.Data.AC.EvalInformation.evalOp | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β → β → β | null | true |
MeasureTheory.isTightMeasureSet_iff_exists_isCompact_measure_compl_le | Mathlib.MeasureTheory.Measure.Tight | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {S : Set (MeasureTheory.Measure 𝓧)} [inst : TopologicalSpace 𝓧],
MeasureTheory.IsTightMeasureSet S ↔ ∀ (ε : ENNReal), 0 < ε → ∃ K, IsCompact K ∧ ∀ μ ∈ S, μ Kᶜ ≤ ε | A set of measures `S` is tight if for all `0 < ε`, there exists a compact set `K` such that
for all `μ ∈ S`, `μ Kᶜ ≤ ε`. | true |
Matrix.ProjectiveSpecialLinearGroup | Mathlib.LinearAlgebra.Matrix.ProjectiveSpecialLinearGroup | (n : Type u) → [DecidableEq n] → [Fintype n] → (R : Type v) → [CommRing R] → Type (max (max u v) v u) | A projective special linear group is the quotient of a special linear group by its center. | true |
instModuleQuotientAddSubgroupTorsion._proof_2 | Mathlib.GroupTheory.Torsion | ∀ {M : Type u_1} [inst : AddCommGroup M], (AddCommGroup.torsion M).Normal | null | false |
ByteArray.findFinIdx?.loop | Init.Data.ByteArray.Basic | (a : ByteArray) → (UInt8 → Bool) → ℕ → Option (Fin a.size) | null | true |
SimpleGraph.IsEdgeReachable.rfl | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ} {u : V}, G.IsEdgeReachable k u u | null | true |
Set.unbounded_le_iff | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α], Set.Unbounded (fun x1 x2 => x1 ≤ x2) s ↔ ∀ (a : α), ∃ b ∈ s, a < b | null | true |
PointedCone.map_id | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommMonoid E] [inst_4 : Module R E] (C : PointedCone R E), PointedCone.map LinearMap.id C = C | null | true |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.differentiable_set_subset_D._simp_1_5 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Polynomial.monic_X_pow_sub_C | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Ring R] (a : R) {n : ℕ}, n ≠ 0 → (Polynomial.X ^ n - Polynomial.C a).Monic | `X ^ n - a` is monic. | true |
CategoryTheory.MorphismProperty.MapFactorizationData.hp | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C} {X Y : C}
{f : X ⟶ Y} (self : W₁.MapFactorizationData W₂ f), W₂ self.p | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.cmp₁ | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | Array Lean.Meta.Grind.Arith.Cutsat.VarInfo → Int.Linear.Var → Int.Linear.Var → Ordering | null | true |
Lean.Lsp.instToJsonMarkupContent | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.MarkupContent | null | true |
Plausible.TotalFunction.rec | Plausible.Functions | {α : Type u} →
{β : Type v} →
{motive : Plausible.TotalFunction α β → Sort u_1} →
((a : List ((_ : α) × β)) → (a_1 : β) → motive (Plausible.TotalFunction.withDefault a a_1)) →
(t : Plausible.TotalFunction α β) → motive t | null | false |
CategoryTheory.Functor.IsStronglyCocartesian.mk._flat_ctor | Mathlib.CategoryTheory.FiberedCategory.Cocartesian | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {R S : 𝒮} {a b : 𝒳} {f : R ⟶ S} {φ : a ⟶ b} [toIsHomLift : p.IsHomLift f φ],
(∀ {b' : 𝒳} (g : S ⟶ p.obj b') (φ' : a ⟶ b') [p.IsHomLift (CategoryTheory.Cat... | null | false |
Fin.encodeSubtype_succ_neg | Batteries.Data.Fin.Coding | ∀ {n : ℕ} {P : Fin (n + 1) → Prop} [inst : DecidablePred P] (h₀ : ¬P 0) {i : Fin n} (h : P i.succ),
Fin.encodeSubtype P ⟨i.succ, h⟩ = Fin.cast ⋯ (Fin.encodeSubtype (fun i => P i.succ) ⟨i, h⟩) | null | true |
instFloorSemiringNat._proof_1 | Mathlib.Algebra.Order.Floor.Defs | ∀ {a n : ℕ}, n ≤ id a ↔ ↑n ≤ a | null | false |
_private.Init.Data.Vector.Perm.0.Vector.swap_perm._simp_1_2 | Init.Data.Vector.Perm | ∀ {α : Type u_1} {n : ℕ} {as bs : Vector α n}, as.Perm bs = as.toList.Perm bs.toList | null | false |
Std.DTreeMap.Raw.inter_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp}, t₁.inter t₂ = t₁ ∩ t₂ | null | true |
Int.neg_clog_inv_eq_log | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [inst_3 : FloorSemiring R]
(b : ℕ) (r : R), -Int.clog b r⁻¹ = Int.log b r | null | true |
compl_le_compl | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a b : α}, a ≤ b → bᶜ ≤ aᶜ | null | true |
CategoryTheory.instQuiverMonad | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → Quiver (CategoryTheory.Monad C) | null | true |
Mathlib.Tactic.Push.pullStep | Mathlib.Tactic.Push | Mathlib.Tactic.Push.Head → Lean.Meta.Simp.Simproc | Try to rewrite using a `pull` lemma. | true |
Array.back_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : ℕ → α → β} (h : 0 < (Array.mapIdx f xs).size),
(Array.mapIdx f xs).back h = f (xs.size - 1) (xs.back ⋯) | null | true |
Function.locallyFinsuppWithin.restrictMonoidHom_apply | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddCommGroup Y] {V : Set X}
(D : Function.locallyFinsuppWithin U Y) (h : V ⊆ U),
(Function.locallyFinsuppWithin.restrictMonoidHom h) D = D.restrict h | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.findShadowedNames.match_3 | Lean.Elab.DocString | {α : Type} →
(motive : Lean.Name × α → Sort u_1) →
(x : Lean.Name × α) → ((fullName : Lean.Name) → (snd : α) → motive (fullName, snd)) → motive x | null | false |
FiberPrebundle.pretrivializationAt | Mathlib.Topology.FiberBundle.Basic | {B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_5} →
[inst : TopologicalSpace B] →
[inst_1 : TopologicalSpace F] →
[inst_2 : (x : B) → TopologicalSpace (E x)] →
FiberPrebundle F E → B → Bundle.Pretrivialization F Bundle.TotalSpace.proj | null | true |
Aesop.ExtResult._sizeOf_1 | Aesop.Util.Tactic.Ext | Aesop.ExtResult → ℕ | null | false |
List.getLast!_eq_getLast?_getD | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Inhabited α] {l : List α}, l.getLast! = l.getLast?.getD default | null | true |
MonoidHom.decidableMemRange | Mathlib.Algebra.Group.Subgroup.Finite | {G : Type u_1} →
[inst : Group G] →
{N : Type u_3} →
[inst_1 : Group N] → (f : G →* N) → [Fintype G] → [DecidableEq N] → DecidablePred fun x => x ∈ f.range | null | true |
CategoryTheory.regularTopology.EqualizerCondition.bijective_mapToEqualizer_pullback | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.Functor Cᵒᵖ (Type u_4)},
CategoryTheory.regularTopology.EqualizerCondition P →
∀ {X B : C} (π : X ⟶ B) [CategoryTheory.EffectiveEpi π] [inst_2 : CategoryTheory.Limits.HasPullback π π],
Function.Bijective
⇑(CategoryThe... | null | true |
UInt64.toUInt16_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a.toUInt16 < b.toUInt16 ↔ a % 65536 < b % 65536 | null | true |
Nonneg.conditionallyCompleteLinearOrder._proof_10 | Mathlib.Algebra.Order.Nonneg.Lattice | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {a : α} (this : Inhabited ↑(Set.Ici a)),
autoParam (∀ (a_1 b : { x // a ≤ x }), compare a_1 b = compareOfLessAndEq a_1 b)
ConditionallyCompleteLinearOrder.compare_eq_compareOfLessAndEq._autoParam | null | false |
AddSubmonoid.addGroupMultiples._proof_4 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : AddMonoid M] {x : M} {n : ℕ},
n • x = 0 → ∀ (m : ℕ) (x_1 : ↥(AddSubmonoid.multiples x)), (↑m.succ).natMod ↑n • x_1 = (↑m).natMod ↑n • x_1 + x_1 | null | false |
collinear_empty | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} (P : Type u_3) [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P], Collinear k ∅ | The empty set is collinear. | true |
CategoryTheory.Functor.whiskerRight._proof_1 | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
{G H : CategoryTheory.Functor C D} (α : G ⟶ H) (F : CategoryTheory.Functor D E) (X Y : C) (f : X ⟶ Y),
CategoryTheory.Categor... | null | false |
RBTree.RBNode.Stream.cons.sizeOf_spec | BatteriesRecycling.RBTree.Basic | ∀ {α : Type u_1} [inst : SizeOf α] (v : α) (r : RBTree.RBNode α) (tail : RBTree.RBNode.Stream α),
sizeOf (RBTree.RBNode.Stream.cons v r tail) = 1 + sizeOf v + sizeOf r + sizeOf tail | null | true |
Lean.Lsp.ReferenceParams.context | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceParams → Lean.Lsp.ReferenceContext | null | true |
CategoryTheory.Abelian.extFunctor_obj | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ) (X : Cᵒᵖ),
(CategoryTheory.Abelian.extFunctor n).obj X = CategoryTheory.Abelian.extFunctorObj (Opposite.unop X) n | null | true |
_private.Mathlib.Algebra.Homology.Embedding.CochainComplex.0.CochainComplex.quasiIso_truncGEMap_iff._proof_1_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | ∀ (n : ℤ) (i : ℕ), n ≤ n + ↑i | null | false |
MeasurableSpace.measurableSet_empty | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_7} (self : MeasurableSpace α), MeasurableSpace.MeasurableSet' self ∅ | The empty set is a measurable set. Use `MeasurableSet.empty` instead. | true |
ContinuousMultilinearMap.ratio_le_opNorm | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(f : ContinuousMultilinearMap 𝕜 E G) (m... | null | true |
SymbolicDynamics.FullShift.MulSubshift.ctorIdx | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{inst : TopologicalSpace A} → {G : Type u_2} → {inst_1 : Monoid G} → SymbolicDynamics.FullShift.MulSubshift A G → ℕ | null | false |
Lean.Meta.Match.Example.val.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} → {a a' : Lean.Expr} → Lean.Meta.Match.Example.val a = Lean.Meta.Match.Example.val a' → (a = a' → P) → P | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.