name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.List.Cycle.0.Cycle.decidableNontrivialCoe.match_1.splitter | Mathlib.Data.List.Cycle | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) → ((x : α) → motive [x]) → ((x y : α) → (l : List α) → motive (x :: y :: l)) → motive x | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.Base.0.Real.rpow_logb_eq_abs._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddLeftMono α] {a : α}, (0 < |a|) = (a ≠ 0) | null | false |
Bundle.Trivialization.codExtend_target | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace Z] {s : Set B} (hs : IsOpen s) (nonempty : s.Nonempty) {proj : Z → ↑s}
(e : Bundle.Trivialization F proj),
(Bundle.Trivialization.codExtend hs nonempty e).target = Prod.map Subtype.v... | null | true |
_private.Mathlib.NumberTheory.LucasLehmer.0.Mathlib.Meta.Positivity.evalMersenne._sparseCasesOn_1 | Mathlib.NumberTheory.LucasLehmer | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → motive Lean.Level.zero → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
ZMod.exists_one_add_mul_pow_prime_eq | Mathlib.RingTheory.ZMod.UnitsCyclic | ∀ {R : Type u_1} [inst : CommSemiring R] {u v : R} {p : ℕ},
Nat.Prime p → v ∣ u → ↑p * u * v ∣ u ^ p → ∀ (x : R), ∃ y, (1 + u * x) ^ p = 1 + ↑p * u * (x + v * y) | null | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.IsTopologicalBasis.vietoris.match_1_3 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {B : Set (Set α)} (V : Set α) (u : Set (Set α))
(motive : (V, u) ∈ {p | IsOpen p.1 ∧ p.2.Finite ∧ p.2 ⊆ B ∧ ∀ U ∈ p.2, U ⊆ p.1} → Prop)
(h : (V, u) ∈ {p | IsOpen p.1 ∧ p.2.Finite ∧ p.2 ⊆ B ∧ ∀ U ∈ p.2, U ⊆ p.1}),
(∀ (hV : IsOpen (V, u).1) (hu : (V, u).2.Finite) (huB : ... | null | false |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A] (a b : Aᵐᵒᵖ), a + b = b + a | null | false |
LieSubmodule.iSupIndep_toSubmodule._simp_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {ι : Type u_1} {N : ι → LieSubmodule R L M},
(iSupIndep fun i => ↑(N i)) = iSupIndep N | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.opEquiv._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} (g : SSet.stdSimplex.obj { len := n + 1 } ⟶ X) (i : Fin (n + 2)),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ X i)) (SSet.yonedaEquiv g) =
SSet.yonedaEquiv (CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i) g) | null | false |
Fin.val_add_one_of_lt' | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} {i : Fin n}, ↑i + 1 < n → ↑(i + 1) = ↑i + 1 | null | true |
CochainComplex.truncateAugment_inv_f | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : CochainComplex V ℕ) {X : V} (f : X ⟶ C.X 0) (w : CategoryTheory.CategoryStruct.comp f (C.d 0 1) = 0) (i : ℕ),
(C.truncateAugment f w).inv.f i = CategoryTheory.CategoryStruct.id ((CochainComplex.truncate... | null | true |
_private.Lean.Meta.Match.MatcherApp.Transform.0.Lean.Meta.MatcherApp.forallAltTelescope' | Lean.Meta.Match.MatcherApp.Transform | {n : Type → Type u_1} →
[Monad n] →
[MonadControlT Lean.MetaM n] →
{α : Type} → Lean.Expr → Lean.Meta.Match.AltParamInfo → (Array Lean.Expr → Array Lean.Expr → n α) → n α | `Match.forallAltTelescope` lifted to a monad transformer
(and only passing those arguments that we care about below)
| true |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.typesEqvForBoxing | Lean.Compiler.LCNF.ExplicitBoxing | Lean.Expr → Lean.Expr → Bool | null | true |
UniformSpaceCat.extension_comp_hom | Mathlib.Topology.Category.UniformSpace | ∀ {X : UniformSpaceCat} {Y : CpltSepUniformSpace}
(f : (↧(UniformSpace.Completion X.carrier)).toUniformSpace ⟶ Y.toUniformSpace),
(UniformSpaceCat.extensionHom (CategoryTheory.CategoryStruct.comp X.completionHom f)).hom = f | null | true |
ProbabilityTheory.Kernel.iIndepFun.indepFun_finset₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : ι → Type u_8}
{m : (i : ι) → MeasurableSpace (β i)} {f : (i : ι) → Ω → β i} (S T : Finset ι),
Disjoint S T →
ProbabilityTheory.Kernel.iIndepFun... | null | true |
MinTropical.instTop | Mathlib.Algebra.Tropical.Basic | {R : Type u} → [Top R] → Top (MinTropical R) | null | true |
Aesop.Frontend.Parser.showStats | Aesop.Frontend.Command | Lean.ParserDescr | null | true |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.ξ | Mathlib.NumberTheory.NumberField.House | (K : Type u_1) →
[inst : Field K] → [NumberField K] → {β : Type u_3} → (β × (K →+* ℂ) → ℤ) → β → NumberField.RingOfIntegers K | `ξ` is the product of `x (l, r)` and the `r`-th basis element of the newBasis of `K`. | true |
Measurable.stronglyMeasurable_add | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_5} {E : Type u_6} {x : MeasurableSpace α} [inst : AddCancelMonoid E] [inst_1 : TopologicalSpace E]
[inst_2 : MeasurableSpace E] [BorelSpace E] [ContinuousAdd E] [TopologicalSpace.PseudoMetrizableSpace E]
{g f : α → E}, Measurable g → MeasureTheory.StronglyMeasurable f → Measurable (f + g) | In a normed vector space, the addition of a strongly measurable function and a measurable
function is measurable. Note that this is not true without further second-countability assumptions
for the addition of two measurable functions. | true |
_private.Init.Data.List.Sublist.0.List.prefix_iff_exists_eq_append._simp_1_2 | Init.Data.List.Sublist | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
_private.Mathlib.Analysis.Calculus.TangentCone.Basic.0.uniqueDiffWithinAt_closure._simp_1_1 | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ (R : Type u) {E : Type v} [inst : Semiring R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : TopologicalSpace E] (s : Set E) (x : E),
UniqueDiffWithinAt R s x = (Dense ↑(Submodule.span R (tangentConeAt R s x)) ∧ x ∈ closure s) | null | false |
Lean.Lsp.InlayHintKind.noConfusionType | Lean.Data.Lsp.LanguageFeatures | Sort v✝ → Lean.Lsp.InlayHintKind → Lean.Lsp.InlayHintKind → Sort v✝ | null | true |
CategoryTheory.Functor.natTransEquiv | Mathlib.CategoryTheory.Functor.FunctorHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
{F G : CategoryTheory.Functor C D} →
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C (Type (max v' v u))) ⟶
F.functorHom G) ≃... | Morphisms `(𝟙_ (C ⥤ Type max v' v u) ⟶ F.functorHom G)` are in bijection with
morphisms `F ⟶ G`. | true |
Lean.Meta.Grind.Arith.CommRing.Ring.mk.inj | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ∀ {id : ℕ} {type : Lean.Expr} {u : Lean.Level} {ringInst semiringInst : Lean.Expr} {charInst? : Option (Lean.Expr × ℕ)}
{addFn? mulFn? subFn? negFn? powFn? intCastFn? natCastFn? one? : Option Lean.Expr} {vars : Lean.PArray Lean.Expr}
{varMap : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Grind.CommRing.Var}
{denote :... | null | true |
IsPrimitiveRoot.isUnit_unit | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {ζ : M} {n : ℕ} (hn : n ≠ 0) (hζ : IsPrimitiveRoot ζ n), IsPrimitiveRoot ⋯.unit n | null | true |
CategoryTheory.Functor.RightExtension.coneAtFunctor_obj | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
(L : CategoryTheory.Functor C D) (F : CategoryTheory.Functor C H) (Y : D) (E : L.RightExtension F),
(CategoryTheory.Functor.R... | null | true |
Ordinal.one_add_natCast | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (m : ℕ), 1 + ↑m = ↑(Order.succ m) | null | true |
SSet.coconeN' | Mathlib.AlgebraicTopology.SimplicialSet.NonsingularColimit | (X : SSet) → [inst : X.Nonsingular] → CategoryTheory.Limits.Cocone X.functorN' | If `X` is a nonsingular simplicial set, this is the cocone consisting
of the (mono)morphisms `Δ[x.dim] ⟶ X` for all nondegenerate simplices `x : X.N`. | true |
descPochhammer_eval_eq_prod_range | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ {R : Type u_1} [inst : CommRing R] (n : ℕ) (r : R),
Polynomial.eval r (descPochhammer R n) = ∏ j ∈ Finset.range n, (r - ↑j) | null | true |
Cardinal.nsmul_lt_aleph0_iff_of_ne_zero | Mathlib.SetTheory.Cardinal.Basic | ∀ {n : ℕ} {a : Cardinal.{u_1}}, n ≠ 0 → (n • a < Cardinal.aleph0 ↔ a < Cardinal.aleph0) | See also `Cardinal.nsmul_lt_aleph0_iff` for a hypothesis-free version. | true |
Matroid.restrict_eq_freeOn_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.restrict I = Matroid.freeOn I ↔ M.Indep I | null | true |
_private.Mathlib.AlgebraicGeometry.FunctionField.0.AlgebraicGeometry.Scheme.algebraMap_germ_eq_germToFunctionField._simp_1_1 | Mathlib.AlgebraicGeometry.FunctionField | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {FC : outParam (C → C → Type u_1)} {CC : outParam (C → Type w)}
{inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))} [self : CategoryTheory.ConcreteCategory C FC]
{X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (x : CC X),
(CategoryTheory.ConcreteCategory.h... | null | false |
WithBot.image_coe_Iio | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, WithBot.some '' Set.Iio a = Set.Ioo ⊥ ↑a | null | true |
CategoryTheory.Limits.kernelSubobject_arrow | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasKernel f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernelSubobjectIso f).hom
(CategoryTheory.Limits.kernel.ι f) =
(Categor... | null | true |
CategoryTheory.GradedObject.Monoidal.braiding_naturality_right | Mathlib.CategoryTheory.GradedObject.Braiding | ∀ {I : Type u_1} [inst : AddCommMonoid I] {C : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.GradedObject I C)
{Y Z : CategoryTheory.GradedObject I C} [inst_3 : CategoryTheory.BraidedCategory C] [inst_4 : X.HasTensor Y]
[inst_5 : Y.HasTe... | null | true |
Std.HashMap.Raw.rec | Std.Data.HashMap.Raw | {α : Type u} →
{β : Type v} →
{motive : Std.HashMap.Raw α β → Sort u_1} →
((inner : Std.DHashMap.Raw α fun x => β) → motive { inner := inner }) → (t : Std.HashMap.Raw α β) → motive t | null | false |
LieSubmodule.instTop | Mathlib.Algebra.Lie.Submodule | {R : Type u} →
{L : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → [inst_4 : LieRingModule L M] → Top (LieSubmodule R L M) | null | true |
CharTwo.range_intCast | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : AddGroupWithOne R] [CharP R 2], Set.range Int.cast = {0, 1} | null | true |
SSet.Subcomplex.MulticoequalizerDiagram.isColimit._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.SubcomplexColimits | ∀ {X : SSet} {A : X.Subcomplex} {ι : Type u_2} {U : ι → X.Subcomplex} {V : ι → ι → X.Subcomplex},
A.MulticoequalizerDiagram U V → ∀ (n : SimplexCategoryᵒᵖ) (i j : ι), (V i j).obj n = (U i).obj n ⊓ (U j).obj n | null | false |
_private.Init.Data.Iterators.Combinators.Monadic.FlatMap.0.Std.IterM.flattenAfter | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} →
{m : Type w → Type w'} →
[Monad m] →
[Std.Iterator α m (Std.IterM m β)] →
[Std.Iterator α₂ m β] → Std.IterM m (Std.IterM m β) → Option (Std.IterM m β) → Std.IterM m β | Internal iterator combinator that is used to implement all `flatMap` variants
| true |
CategoryTheory.Adjunction.op._proof_6 | Mathlib.CategoryTheory.Adjunction.Opposites | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_2, u_1} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(h : G ⊣ F) {x x_1 : Dᵒᵖ} (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp ((G.op.comp F.op).map f) (h.unit.app (Opposite... | null | false |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.even_add_one._proof_1_1 | Mathlib.Algebra.Group.Nat.Even | ∀ {n : ℕ}, Even (n + 1) ↔ ¬Even n | null | false |
ProbabilityTheory.variance_linearMap_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} (L : ℝ →ₗ[ℝ] ℝ),
ProbabilityTheory.variance (⇑L) (ProbabilityTheory.gaussianReal μ v) = ↑(L 1 ^ 2).toNNReal * ↑v | null | true |
Subalgebra.mk.sizeOf_spec | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : SizeOf R]
[inst_4 : SizeOf A] (toSubsemiring : Subsemiring A)
(algebraMap_mem' : ∀ (r : R), (algebraMap R A) r ∈ toSubsemiring.carrier),
sizeOf { toSubsemiring := toSubsemiring, algebraMap_mem' := algebraMap... | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_eq_zero_iff_of_nonneg_ae._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ (x : ENNReal), (x.toReal = 0) = (x = 0 ∨ x = ⊤) | null | false |
Int.strongRec._proof_2 | Mathlib.Data.Int.Init | ∀ {m : ℤ} (n : ℤ), ¬n < m → n ≥ m | null | false |
Mathlib.Meta.Positivity.PositivityExt._sizeOf_1 | Mathlib.Tactic.Positivity.Core | Mathlib.Meta.Positivity.PositivityExt → ℕ | null | false |
CategoryTheory.Mod.X | Mathlib.CategoryTheory.Monoidal.Mod | {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.MonoidalLeftAction C D] →
{A : C} → [inst_4 : CategoryTheory.Mo... | The underlying object in the ambient category | true |
_private.Mathlib.GroupTheory.Goursat.0.Subgroup.goursat._simp_1_15 | Mathlib.GroupTheory.Goursat | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.CostructuredArrow.isoMk._proof_1 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {T : D} {S : CategoryTheory.Functor C D}
{f f' : CategoryTheory.CostructuredArrow S T}, f.right = f'.right | null | false |
Cardinal.mk_freeAbelianGroup | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Nonempty α], Cardinal.mk (FreeAbelianGroup α) = max (Cardinal.mk α) Cardinal.aleph0 | null | true |
Std.Http.Request.noConfusion | Std.Http.Data.Request | {P : Sort u} →
{t : Type} →
{t_1 : Std.Http.Request t} →
{t' : Type} → {t'_1 : Std.Http.Request t'} → t = t' → t_1 ≍ t'_1 → Std.Http.Request.noConfusionType P t_1 t'_1 | null | false |
Lean.FindMVar.visit | Lean.Util.FindMVar | (Lean.MVarId → Bool) → Lean.Expr → Lean.FindMVar.Visitor | null | true |
MeasureTheory.SimpleFunc.finite_range | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β), (Set.range ⇑f).Finite | null | true |
Std.HashMap.Raw.instInterOfBEqOfHashable | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → Inter (Std.HashMap.Raw α β) | null | true |
Lean.Syntax.SepArray._sizeOf_1 | Init.SizeOf | {sep : String} → Lean.Syntax.SepArray sep → ℕ | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.turanGraph_eq_top._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {a b : Prop}, (a = b) = (a ↔ b) | null | false |
CategoryTheory.Functor.PushoutObjObj.ofNatIso_inr | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₂ Y₂ : C₂} {f₂ : X₂ ⟶ Y₂}
(sq : F.P... | null | true |
_private.Mathlib.Analysis.Matrix.Normed.0.Matrix.linfty_opNNNorm_blockDiagonal._simp_1_1 | Mathlib.Analysis.Matrix.Normed | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β], Finset.univ = Finset.univ ×ˢ Finset.univ | null | false |
_private.Mathlib.Data.Option.Basic.0.Option.pmap_bind_id_eq_pmap_join._proof_1_2 | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {x : Option (Option α)} (val : Option α), some val = x → x = some val | null | false |
Std.Internal.List.minKey!_eraseKey_eq_iff_beq_minKey!_eq_false | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α},
(Std.Internal.List.eraseKey k l).isEmpty = false →
(Std.Internal.List.minKey! (Std.Internal.List.er... | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Adjunction.Basic.0.CategoryTheory.Bicategory.instIsIsoHomRightZigzagHom._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {g : b ⟶ a}
(η : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp f g)
(ε : CategoryTheory.CategoryStruct.comp g f ≅ CategoryTheory.CategoryStruct.id b),
CategoryTheory.IsIso (CategoryTheory.Bicategory.rightZigzag η... | null | false |
Complex.besselJ_zero | Mathlib.Analysis.SpecialFunctions.Bessel | ∀ (a : ℂ), Complex.besselJ a 0 = if a = 0 then 1 else 0 | null | true |
liminf_min._auto_5 | Mathlib.Order.LiminfLimsup | Lean.Syntax | null | false |
AlgebraicGeometry.QuasiSeparated.quasiCompact_diagonal._autoParam | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | Lean.Syntax | null | false |
List.forall₂_refl | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {Rₐ : α → α → Prop} [Std.Refl Rₐ] (l : List α), List.Forall₂ Rₐ l l | null | true |
CategoryTheory.Precoherent.mk | Mathlib.CategoryTheory.Sites.Coherent.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C],
(∀ {B₁ B₂ : C} (f : B₂ ⟶ B₁) (α : Type) [Finite α] (X₁ : α → C) (π₁ : (a : α) → X₁ a ⟶ B₁),
CategoryTheory.EffectiveEpiFamily X₁ π₁ →
∃ β,
∃ (_ : Finite β),
∃ X₂ π₂,
CategoryTheory.EffectiveEpiFamily X₂ π... | null | true |
FreeAbelianGroup.support_neg | Mathlib.Algebra.FreeAbelianGroup.Finsupp | ∀ {X : Type u_1} (a : FreeAbelianGroup X), (-a).support = a.support | null | true |
_private.Mathlib.LinearAlgebra.ExteriorPower.Basic.0.exteriorPower.presentation.relations.match_1.eq_3 | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ (R : Type u_1) (ι : Type u_2) (M : Type u_3) (motive : exteriorPower.presentation.Rels R ι M → Sort u_4) (m : ι → M)
(i j : ι) (hm : m i = m j) (hij : i ≠ j)
(h_1 : (m : ι → M) → (i : ι) → (x y : M) → motive (exteriorPower.presentation.Rels.add m i x y))
(h_2 : (m : ι → M) → (i : ι) → (r : R) → (x : M) → motive... | null | true |
_private.Mathlib.Combinatorics.Quiver.Path.Weight.0.PSigma.casesOn._arg_pusher | Mathlib.Combinatorics.Quiver.Path.Weight | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
Stream'.WSeq.coeList | Mathlib.Data.WSeq.Basic | {α : Type u} → Coe (List α) (Stream'.WSeq α) | null | true |
USize.toUInt8_add | Init.Data.UInt.Lemmas | ∀ (a b : USize), (a + b).toUInt8 = a.toUInt8 + b.toUInt8 | null | true |
Lean.Omega.IntList.sdiv_nil | Init.Omega.IntList | ∀ {g : ℤ}, Lean.Omega.IntList.sdiv [] g = [] | null | true |
SeminormedRing.noConfusion | Mathlib.Analysis.Normed.Ring.Basic | {P : Sort u} →
{α : Type u_5} →
{t : SeminormedRing α} →
{α' : Type u_5} → {t' : SeminormedRing α'} → α = α' → t ≍ t' → SeminormedRing.noConfusionType P t t' | null | false |
Array.foldr_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → β} {init : β}, Array.foldr f init #[] = init | null | true |
ProbabilityTheory.HasLaw.prodMk_of_hasCondDistrib | Mathlib.Probability.HasCondDistrib | ∀ {Ω : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_3} {mΩ : MeasurableSpace Ω} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} {P : MeasureTheory.Measure Ω} {X : Ω → 𝓧} {Y : Ω → 𝓨} {κ : ProbabilityTheory.Kernel 𝓧 𝓨}
{Q : MeasureTheory.Measure 𝓧},
ProbabilityTheory.HasLaw X Q P →
ProbabilityTheory.HasCon... | null | true |
Denumerable.nat._proof_1 | Mathlib.Basic.Denumerable | ∀ (x : ℕ), ∃ a ∈ Encodable.decode x, Encodable.encode a = x | null | false |
_private.Mathlib.NumberTheory.Padics.Hensel.0.calc_eval_z'._proof_3 | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {z z1 : ℤ_[p]}
(h1 : ‖↑((Polynomial.aeval z) F) / ↑((Polynomial.aeval z) (Polynomial.derivative F))‖ ≤ 1),
z1 = (↑((Polynomial.aeval z) F) / ↑((Polynomial.aeval z) (Polynomial.derivative F)... | null | false |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_3 | Mathlib.Analysis.MeanInequalities | ∀ {α : Type u_1} {s : Finset α} {f : α → ENNReal}, (∑ x ∈ s, f x = ⊤) = ∃ a ∈ s, f a = ⊤ | null | false |
AddLECancellable.add_le_add_iff_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : LE α] [inst_1 : Add α] [AddLeftMono α],
AddLECancellable a → (a + b ≤ a + c ↔ b ≤ c) | null | true |
_private.Std.Async.DNS.0.Std.Async.DNS.getAddrInfo.match_1 | Std.Async.DNS | (motive : Option Std.Net.AddressFamily → Sort u_1) →
(addrFamily : Option Std.Net.AddressFamily) →
(Unit → motive none) →
(Unit → motive (some Std.Net.AddressFamily.ipv4)) →
(Unit → motive (some Std.Net.AddressFamily.ipv6)) → motive addrFamily | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr.0.Lean.Grind.CommRing.Mon.denoteExpr.go._f | Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr | {M : Type → Type} →
[Monad M] →
[Lean.MonadError M] →
[MonadLiftT Lean.MetaM M] →
[Lean.Meta.Sym.Arith.MonadCanon M] →
[Lean.Meta.Grind.Arith.CommRing.MonadRing M] →
(m : Lean.Grind.CommRing.Mon) →
Lean.Grind.CommRing.Mon.below (motive := fun m => Lean.Expr → M Le... | null | false |
Representation.linHom.invariantsEquivRepHom._proof_5 | Mathlib.RepresentationTheory.Invariants | ∀ {k : Type u_2} [inst : CommRing k] {G : Type u_3} [inst_1 : Group G] (X Y : Rep.{u_1, u_2, u_3} k G)
(x x_1 : ↥(X.ρ.linHom Y.ρ).invariants) (g : G), ↑(x + x_1) ∘ₗ X.ρ g = Y.ρ g ∘ₗ ↑(x + x_1) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds.0.Real.lt_tan._simp_1_5 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulStrictMono R] [MulPosStrictMono R]
[AddLeftStrictMono R] [AddLeftReflectLT R] {a : R}, (0 < a * a) = (a ≠ 0) | null | false |
Lean.IR.FnBody.body | Lean.Compiler.IR.Basic | Lean.IR.FnBody → Lean.IR.FnBody | null | true |
TestFunction.instLineDerivTopENat._proof_3 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], IsScalarTower ℝ ℝ F | null | false |
Hypergraph.image_vertexSet | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_1} {β : Type u_2} (H : Hypergraph α) (f : α → β), (H.image f).vertexSet = f '' H.vertexSet | null | true |
Module.Basis.extend._proof_3 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_2} {V : Type u_1} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
(hs : LinearIndepOn K id s), ⊤ ≤ Submodule.span K (Set.range ((hs.extend ⋯).domRestrict id)) | null | false |
MeasureTheory.analyticSet_range_of_polishSpace | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {β : Type u_3} [inst_1 : TopologicalSpace β] [PolishSpace β] {f : β → α},
Continuous f → MeasureTheory.AnalyticSet (Set.range f) | null | true |
Nat.toList_rio_eq_nil_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...n).toList = [] ↔ n = 0 | null | true |
CategoryTheory.Bicategory.LeftLift.IsAbsKan | Mathlib.CategoryTheory.Bicategory.Kan.IsKan | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} → {f : b ⟶ a} → {g : c ⟶ a} → CategoryTheory.Bicategory.LeftLift f g → Type (max (max u v) w) | An absolute left Kan lift is a Kan lift such that every 1-morphism commutes with it. | true |
Std.DTreeMap.Internal.Impl.toListModel_balanceₘ | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.balanceₘ k v l r).toListModel = l.toListModel ++ ⟨k, v⟩ :: r.toListModel | null | true |
CategoryTheory.Lax.StrongTrans.mkOfLax | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
(η : CategoryTheory.Lax.LaxTrans F G) → η.StrongCore → CategoryTheory.Lax.StrongTrans F G | Construct a strong natural transformation from a lax natural transformation whose
naturality 2-morphism is an isomorphism. | true |
HomologicalComplex.cyclesIsoSc'_hom_iCycles | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j k : ι) (hi : c.prev j = i) (hk : c.next j = k)
[inst_2 : K.HasHomology j] [inst_3 : (K.sc' i j k).HasHomology],
CategoryTheory.Ca... | null | true |
exteriorPower.wedge_apply_of_not_disjoint | Mathlib.LinearAlgebra.ExteriorPower.WedgePairing | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {k l : ℕ}
{ι : Type u_3} [inst_3 : LinearOrder ι] (b : Module.Basis ι R M) {I : ↑(Set.powersetCard ι k)}
{J : ↑(Set.powersetCard ι l)},
¬Disjoint ↑I ↑J →
((exteriorPower.wedge R M k l) ((Module.Basis.exteriorPo... | null | true |
Std.DTreeMap.Internal.Impl.contains_insert!_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {k : α} {v : β k}, Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.insert! k v t) = true | null | true |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.Valid'.node4L_lemma₃._proof_1_1 | Mathlib.Data.Ordmap.Ordset | ∀ {b c d : ℕ}, 2 * d ≤ b + c + 1 → b ≤ 3 * c → d ≤ 3 * c | null | false |
MulOpposite.instNatCast.eq_1 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NatCast R], MulOpposite.instNatCast = { natCast := fun n => MulOpposite.op ↑n } | null | true |
ENNReal.toReal_eq_toReal_iff | Mathlib.Basic.ENNReal.Basic | ∀ (x y : ENNReal), x.toReal = y.toReal ↔ x = y ∨ x = 0 ∧ y = ⊤ ∨ x = ⊤ ∧ y = 0 | null | true |
BitVec.rotateRight_eq_rotateRightAux_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {r : ℕ}, r < w → x.rotateRight r = x.rotateRightAux r | `rotateRight` equals the bit fiddling definition of `rotateRightAux` when the rotation amount is
smaller than the bitwidth. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.