name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.HashSet.Raw.get!_diff | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α]
[inst_4 : Inhabited α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ \ m₂).get! k = if k ∈ m₂ then default else m₁.get! k |
Std.DTreeMap.Internal.Impl.empty | Std.Data.DTreeMap.Internal.Operations | {α : Type u} → {β : α → Type v} → Std.DTreeMap.Internal.Impl α β |
ContinuousMapZero.nonUnitalStarAlgHom_precomp | Mathlib.Topology.ContinuousMap.ContinuousMapZero | {X : Type u_1} →
{Y : Type u_2} →
(R : Type u_4) →
[inst : Zero X] →
[inst_1 : Zero Y] →
[inst_2 : TopologicalSpace X] →
[inst_3 : TopologicalSpace Y] →
[inst_4 : TopologicalSpace R] →
[inst_5 : CommSemiring R] →
[inst_6 : StarRing R] →
[inst_7 : IsTopologicalSemiring R] →
[inst_8 : ContinuousStar R] →
ContinuousMapZero X Y → ContinuousMapZero Y R →⋆ₙₐ[R] ContinuousMapZero X R |
_private.Mathlib.SetTheory.Cardinal.NatCount.0.Nat.count_le_setENCard._simp_1_1 | Mathlib.SetTheory.Cardinal.NatCount | ∀ {c : Cardinal.{u}} {n : ℕ}, (↑n ≤ Cardinal.toENat c) = (↑n ≤ c) |
CategoryTheory.ObjectProperty.limitsClosure.below.of_mem | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)]
{motive : (a : C) → P.limitsClosure J a → Prop} (X : C) (hX : P X),
CategoryTheory.ObjectProperty.limitsClosure.below ⋯ |
Set.Icc_top | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, Set.Icc a ⊤ = Set.Ici a |
RatFunc._sizeOf_inst | Mathlib.FieldTheory.RatFunc.Defs | (K : Type u) → {inst : CommRing K} → [SizeOf K] → SizeOf (RatFunc K) |
Lean.Doc.PostponedName.mk.noConfusion | Lean.Elab.DocString.Builtin.Postponed | {P : Sort u} → {name name' : Lean.Name} → { name := name } = { name := name' } → (name = name' → P) → P |
RingCat.instConcreteCategoryRingHomCarrier._proof_4 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y Z : RingCat} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) |
Finset.iSup_singleton | Mathlib.Order.CompleteLattice.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (a : α) (s : α → β), ⨆ x ∈ {a}, s x = s a |
Std.ExtTreeMap.minKeyD_insertIfNew_of_isEmpty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t.isEmpty = true → ∀ {fallback : α}, (t.insertIfNew k v).minKeyD fallback = k |
minpoly.dvd_iff | Mathlib.FieldTheory.Minpoly.Field | ∀ {A : Type u_1} {B : Type u_2} [inst : Field A] [inst_1 : Ring B] [inst_2 : Algebra A B] {x : B} {p : Polynomial A},
minpoly A x ∣ p ↔ (Polynomial.aeval x) p = 0 |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_310 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.findIdxNth (fun x => decide (x = w)) [g (g a)] {g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g (g a)]).length →
List.findIdxNth (fun x => decide (x = w)) [g (g a)] {g (g a)}.card <
(List.findIdxs (fun x => decide (x = w_1)) [g (g a)]).length |
CategoryTheory.GradedObject.ι_mapBifunctorComp₂₃MapObjIso_hom_assoc | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[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_6, u_6} C₂₃] (F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄))
(G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9}
{J : Type u_10} {r : I₁ × I₂ × I₃ → J} (ρ₂₃ : CategoryTheory.GradedObject.BifunctorComp₂₃IndexData r)
(X₁ : CategoryTheory.GradedObject I₁ C₁) (X₂ : CategoryTheory.GradedObject I₂ C₂)
(X₃ : CategoryTheory.GradedObject I₃ C₃)
[inst_5 : (((CategoryTheory.GradedObject.mapBifunctor G₂₃ I₂ I₃).obj X₂).obj X₃).HasMap ρ₂₃.p]
[inst_6 :
(((CategoryTheory.GradedObject.mapBifunctor F I₁ ρ₂₃.I₂₃).obj X₁).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃)).HasMap
ρ₂₃.q]
[H : CategoryTheory.GradedObject.HasGoodTrifunctor₂₃Obj F G₂₃ ρ₂₃ X₁ X₂ X₃]
[inst_7 :
((((CategoryTheory.GradedObject.mapTrifunctor (CategoryTheory.bifunctorComp₂₃ F G₂₃) I₁ I₂ I₃).obj X₁).obj X₂).obj
X₃).HasMap
r]
(i₁ : I₁) (i₂ : I₂) (i₃ : I₃) (j : J) (h : r (i₁, i₂, i₃) = j) {Z : C₄}
(h_1 :
CategoryTheory.GradedObject.mapBifunctorMapObj F ρ₂₃.q X₁
(CategoryTheory.GradedObject.mapBifunctorMapObj G₂₃ ρ₂₃.p X₂ X₃) j ⟶
Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.ιMapTrifunctorMapObj (CategoryTheory.bifunctorComp₂₃ F G₂₃) r X₁ X₂ X₃ i₁ i₂ i₃ j h)
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.GradedObject.mapBifunctorComp₂₃MapObjIso F G₂₃ ρ₂₃ X₁ X₂ X₃).hom j) h_1) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.GradedObject.ιMapBifunctorBifunctor₂₃MapObj F G₂₃ ρ₂₃ X₁ X₂ X₃ i₁ i₂ i₃ j h) h_1 |
Derivation.mk'._proof_2 | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_3} [inst : CommSemiring R] {A : Type u_2} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {M : Type u_1}
[inst_3 : AddCancelCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M] (D : A →ₗ[R] M),
(∀ (a b : A), D (a * b) = a • D b + b • D a) → D 1 = 0 |
Set.biUnion_diff_biUnion_subset | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} (t : α → Set β) (s₁ s₂ : Set α), (⋃ x ∈ s₁, t x) \ ⋃ x ∈ s₂, t x ⊆ ⋃ x ∈ s₁ \ s₂, t x |
ContinuousLinearMap.module._proof_1 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} {R₃ : Type u_2} {S₃ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₃] [inst_2 : Semiring S₃]
{M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid M] [inst_5 : Module R M] {M₃ : Type u_4}
[inst_6 : TopologicalSpace M₃] [inst_7 : AddCommMonoid M₃] [inst_8 : Module R₃ M₃] [inst_9 : Module S₃ M₃]
[inst_10 : SMulCommClass R₃ S₃ M₃] [inst_11 : ContinuousConstSMul S₃ M₃] {σ₁₃ : R →+* R₃} [inst_12 : ContinuousAdd M₃]
(x x_1 : S₃) (x_2 : M →SL[σ₁₃] M₃), (x + x_1) • x_2 = x • x_2 + x_1 • x_2 |
Lean.Server.FileWorker.handleRpcKeepAlive | Lean.Server.FileWorker | Lean.Lsp.RpcKeepAliveParams → Lean.Server.FileWorker.WorkerM Unit |
Function.Periodic.map_vadd_multiples | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : AddCommMonoid α],
Function.Periodic f c → ∀ (a : ↥(AddSubmonoid.multiples c)) (x : α), f (a +ᵥ x) = f x |
integral_log_sin_zero_pi | Mathlib.Analysis.SpecialFunctions.Integrals.LogTrigonometric | ∫ (x : ℝ) in 0..Real.pi, Real.log (Real.sin x) = -Real.log 2 * Real.pi |
AddMonoidHom.coprod_inl_inr | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_6} {N : Type u_7} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N],
(AddMonoidHom.inl M N).coprod (AddMonoidHom.inr M N) = AddMonoidHom.id (M × N) |
ArithmeticFunction.sigma_one | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ (k : ℕ), (ArithmeticFunction.sigma k) 1 = 1 |
AddChar | Mathlib.Algebra.Group.AddChar | (A : Type u_1) → [AddMonoid A] → (M : Type u_2) → [Monoid M] → Type (max u_1 u_2) |
CategoryTheory.Pretriangulated.Triangle.rotate_mor₃ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C),
T.rotate.mor₃ = -(CategoryTheory.shiftFunctor C 1).map T.mor₁ |
MulAction.IsBlock.of_orbit | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {H : Subgroup G} {a : X},
MulAction.stabilizer G a ≤ H → MulAction.IsBlock G (MulAction.orbit (↥H) a) |
mul_neg_geom_sum | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] (x : R) (n : ℕ), (1 - x) * ∑ i ∈ Finset.range n, x ^ i = 1 - x ^ n |
CompletelyDistribLattice.mk._flat_ctor | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
(le lt : α → α → Prop) →
(le_refl : ∀ (a : α), le a a) →
(le_trans : ∀ (a b c : α), le a b → le b c → le a c) →
(lt_iff_le_not_ge : autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam) →
(le_antisymm : ∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(le_sup_left : ∀ (a b : α), le a (sup a b)) →
(le_sup_right : ∀ (a b : α), le b (sup a b)) →
(sup_le : ∀ (a b c : α), le a c → le b c → le (sup a b) c) →
(inf : α → α → α) →
(inf_le_left : ∀ (a b : α), le (inf a b) a) →
(inf_le_right : ∀ (a b : α), le (inf a b) b) →
(le_inf : ∀ (a b c : α), le a b → le a c → le a (inf b c)) →
(sSup : Set α → α) →
(∀ (s : Set α), ∀ a ∈ s, le a (sSup s)) →
(∀ (s : Set α) (a : α), (∀ b ∈ s, le b a) → le (sSup s) a) →
(sInf : Set α → α) →
(∀ (s : Set α), ∀ a ∈ s, le (sInf s) a) →
(∀ (s : Set α) (a : α), (∀ b ∈ s, le a b) → le a (sInf s)) →
(top : α) →
(∀ (a : α), le a top) →
(bot : α) →
(∀ (a : α), le bot a) →
(himp : α → α → α) →
(∀ (a b c : α), le a (himp b c) ↔ le (a ⊓ b) c) →
(compl : α → α) →
(∀ (a : α), himp a bot = compl a) →
(sdiff : α → α → α) →
(hnot : α → α) →
(∀ (a b c : α), le (sdiff a b) c ↔ le a (b ⊔ c)) →
(∀ (a : α), sdiff top a = hnot a) →
(∀ {ι : Type u} {κ : ι → Type u}
(f : (a : ι) → κ a → α),
⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a)) →
CompletelyDistribLattice α |
Lean.Meta.Grind.EMatch.State | Lean.Meta.Tactic.Grind.Types | Type |
Configuration.HasLines.rec | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} →
[inst : Membership P L] →
{motive : Configuration.HasLines P L → Sort u} →
([toNondegenerate : Configuration.Nondegenerate P L] →
(mkLine : {p₁ p₂ : P} → p₁ ≠ p₂ → L) →
(mkLine_ax : ∀ {p₁ p₂ : P} (h : p₁ ≠ p₂), p₁ ∈ mkLine h ∧ p₂ ∈ mkLine h) →
motive { toNondegenerate := toNondegenerate, mkLine := mkLine, mkLine_ax := mkLine_ax }) →
(t : Configuration.HasLines P L) → motive t |
CategoryTheory.Mod_.noConfusionType | Mathlib.CategoryTheory.Monoidal.Mod_ | Sort u →
{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.MonObj A] →
CategoryTheory.Mod_ D A →
{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.MonObj A'] → CategoryTheory.Mod_ D' A' → Sort u |
intervalIntegral.continuousOn_primitive_interval_left | Mathlib.MeasureTheory.Integral.DominatedConvergence | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
{f : ℝ → E} [MeasureTheory.NoAtoms μ],
MeasureTheory.IntegrableOn f (Set.uIcc a b) μ → ContinuousOn (fun x => ∫ (t : ℝ) in x..b, f t ∂μ) (Set.uIcc a b) |
IsPrimitiveRoot.toInteger_sub_one_dvd_prime' | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p : ℕ} {K : Type u} [inst : Field K] {ζ : K} [hp : Fact (Nat.Prime p)] [inst_1 : CharZero K]
[hcycl : IsCyclotomicExtension {p} ℚ K] (hζ : IsPrimitiveRoot ζ p), hζ.toInteger - 1 ∣ ↑p |
MulEquiv.coprodAssoc_apply_inl_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P] (x : M),
(MulEquiv.coprodAssoc M N P) (Monoid.Coprod.inl (Monoid.Coprod.inl x)) = Monoid.Coprod.inl x |
ModuleCat.projectiveResolution._proof_1 | Mathlib.Algebra.Category.ModuleCat.LeftResolution | ∀ (R : Type u_1) [inst : Ring R] (X : ModuleCat R),
CategoryTheory.isProjective (ModuleCat R) (((CategoryTheory.forget (ModuleCat R)).comp (ModuleCat.free R)).obj X) |
NumberField.mixedEmbedding.euclidean.instNontrivialMixedSpace | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [NumberField K], Nontrivial (NumberField.mixedEmbedding.euclidean.mixedSpace K) |
Matrix.detp_smul_add_adjp | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R]
{A B : Matrix n n R}, A * B = 1 → Matrix.detp 1 B • A + Matrix.adjp (-1) B = Matrix.detp (-1) B • A + Matrix.adjp 1 B |
Ordinal.preOmega_max | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o₁ o₂ : Ordinal.{u_1}), Ordinal.preOmega (max o₁ o₂) = max (Ordinal.preOmega o₁) (Ordinal.preOmega o₂) |
FiberBundleCore.fiberBundle | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
[inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → (Z : FiberBundleCore ι B F) → FiberBundle F Z.Fiber |
_private.Init.Data.List.TakeDrop.0.List.take_left.match_1_1 | Init.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (a : α) (tail x : List α), motive (a :: tail) x) → motive x x_1 |
Lean.Syntax.ident.elim | Init.Prelude | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
t.ctorIdx = 3 →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive_1 (Lean.Syntax.ident info rawVal val preresolved)) →
motive_1 t |
LinearMap.domRestrict₁₂_apply | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} [inst : Semiring R] {S : Type u_2} [inst_1 : Semiring S] {R₂ : Type u_3} [inst_2 : Semiring R₂]
{S₂ : Type u_4} [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_6} {P : Type u_7} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module S N]
[inst_9 : Module R₂ P] [inst_10 : Module S₂ P] [inst_11 : SMulCommClass S₂ R₂ P] {ρ₁₂ : R →+* R₂} {σ₁₂ : S →+* S₂}
(f : M →ₛₗ[ρ₁₂] N →ₛₗ[σ₁₂] P) (p : Submodule R M) (q : Submodule S N) (x : ↥p) (y : ↥q),
((f.domRestrict₁₂ p q) x) y = (f ↑x) ↑y |
Lean.Elab.Tactic.GuardMsgs.MessageOrdering._sizeOf_inst | Lean.Elab.GuardMsgs | SizeOf Lean.Elab.Tactic.GuardMsgs.MessageOrdering |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} (A : Type u') [inst_2 : CategoryTheory.Category.{v', u'} A]
[inst_3 : CategoryTheory.Functor.IsDenseSubsite J₀ J F] (data : (X : C) → F.OneHypercoverDenseData J₀ J X)
[CategoryTheory.Limits.HasLimitsOfSize.{w, w, v', u'} A], (F.sheafPushforwardContinuous A J₀ J).EssSurj |
HahnEmbedding.Partial.sSup | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
[inst_7 : Module K M] →
[inst_8 : IsOrderedModule K M] →
{R : Type u_3} →
[inst_9 : AddCommGroup R] →
[inst_10 : LinearOrder R] →
[inst_11 : Module K R] →
{seed : HahnEmbedding.Seed K M R} →
[IsOrderedAddMonoid R] →
{c : Set (HahnEmbedding.Partial seed)} →
c.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) c → HahnEmbedding.Partial seed |
_private.Mathlib.Algebra.Order.Field.Power.0.Mathlib.Meta.Positivity.evalZPow._proof_2 | Mathlib.Algebra.Order.Field.Power | ∀ {u : Lean.Level} {α : Q(Type u)} (pα : Q(PartialOrder «$α»)) (_a : Q(LinearOrder «$α»)),
«$pα» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder |
List.takeD | Batteries.Data.List.Basic | {α : Type u_1} → ℕ → List α → α → List α |
UInt16.lt_add_one | Init.Data.UInt.Lemmas | ∀ {c : UInt16}, c ≠ -1 → c < c + 1 |
Subring.rec | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} →
[inst : Ring R] →
{motive : Subring R → Sort u_1} →
((toSubsemiring : Subsemiring R) →
(neg_mem' : ∀ {x : R}, x ∈ toSubsemiring.carrier → -x ∈ toSubsemiring.carrier) →
motive { toSubsemiring := toSubsemiring, neg_mem' := neg_mem' }) →
(t : Subring R) → motive t |
UniformEquiv.piCongrLeft | Mathlib.Topology.UniformSpace.Equiv | {ι : Type u_4} →
{ι' : Type u_5} →
{β : ι' → Type u_6} →
[inst : (j : ι') → UniformSpace (β j)] → (e : ι ≃ ι') → ((i : ι) → β (e i)) ≃ᵤ ((j : ι') → β j) |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_liminf._simp_1_6 | Mathlib.Order.Filter.ENNReal | ∀ {q : NNReal}, (0 ≤ ↑q) = True |
Batteries.RBNode.Balanced.map | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {c : Batteries.RBColor} {n : ℕ} {α_1 : Type u_2} {f : α → α_1} {t : Batteries.RBNode α},
t.Balanced c n → (Batteries.RBNode.map f t).Balanced c n |
Lean.PersistentHashMap.isUnaryEntries | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → ℕ → Option (α × β) → Option (α × β) |
coe_setBasisOfLinearIndependentOfCardEqFinrank | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
[inst_3 : Nonempty ↑s] [inst_4 : Fintype ↑s] (lin_ind : LinearIndependent K Subtype.val)
(card_eq : s.toFinset.card = Module.finrank K V),
⇑(setBasisOfLinearIndependentOfCardEqFinrank lin_ind card_eq) = Subtype.val |
BoxIntegral.BoxAdditiveMap.rec | Mathlib.Analysis.BoxIntegral.Partition.Additive | {ι : Type u_3} →
{M : Type u_4} →
[inst : AddCommMonoid M] →
{I : WithTop (BoxIntegral.Box ι)} →
{motive : BoxIntegral.BoxAdditiveMap ι M I → Sort u} →
((toFun : BoxIntegral.Box ι → M) →
(sum_partition_boxes' :
∀ (J : BoxIntegral.Box ι),
↑J ≤ I → ∀ (π : BoxIntegral.Prepartition J), π.IsPartition → ∑ Ji ∈ π.boxes, toFun Ji = toFun J) →
motive { toFun := toFun, sum_partition_boxes' := sum_partition_boxes' }) →
(t : BoxIntegral.BoxAdditiveMap ι M I) → motive t |
Lean.Environment.containsOnBranch | Lean.Environment | Lean.Environment → Lean.Name → Bool |
Std.DTreeMap.Internal.Impl.Balanced.one_le | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {sz : ℕ} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
(Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced → 1 ≤ sz |
TwoSidedIdeal.orderIsoRingCon_apply | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (self : TwoSidedIdeal R),
TwoSidedIdeal.orderIsoRingCon self = self.ringCon |
CategoryTheory.Limits.HasCountableLimits.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Countable | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C],
(∀ (J : Type) [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.CountableCategory J],
CategoryTheory.Limits.HasLimitsOfShape J C) →
CategoryTheory.Limits.HasCountableLimits C |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.add_mul_ediv_right.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ (motive : (c : ℤ) → (∃ n, c = ↑n + 1) → ℤ → 0 < c → Prop) (c : ℤ) (x : ∃ n, c = ↑n + 1) (b : ℤ) (H : 0 < c),
(∀ (w a : ℕ) (H : 0 < ↑w + 1), motive (↑w + 1) ⋯ (Int.ofNat a) H) →
(∀ (k n : ℕ) (H : 0 < ↑k + 1), motive (↑k + 1) ⋯ (Int.negSucc n) H) → motive c x b H |
_private.Mathlib.Order.GaloisConnection.Basic.0.isLUB_image2_of_isLUB_isLUB._simp_1_3 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {p : γ → Prop},
(∀ z ∈ Set.image2 f s t, p z) = ∀ x ∈ s, ∀ y ∈ t, p (f x y) |
Matrix.single_apply_of_ne | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α] (i : m)
(j : n) (c : α) (i' : m) (j' : n), ¬(i = i' ∧ j = j') → Matrix.single i j c i' j' = 0 |
Lean.Lsp.instFromJsonPrepareRenameParams | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.PrepareRenameParams |
Std.TreeMap.Raw.maxKey?_eq_none_iff._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → (t.maxKey? = none) = (t.isEmpty = true) |
Lean.Elab.Term.ElabElimInfo.ctorIdx | Lean.Elab.App | Lean.Elab.Term.ElabElimInfo → ℕ |
Polynomial.isSplittingField_C | Mathlib.FieldTheory.SplittingField.IsSplittingField | ∀ {K : Type v} [inst : Field K] (a : K), Polynomial.IsSplittingField K K (Polynomial.C a) |
Std.DHashMap.size_inter_le_size_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α], (m₁ ∩ m₂).size ≤ m₂.size |
RingHom.liftOfRightInverse._proof_5 | Mathlib.RingTheory.Ideal.Maps | ∀ {A : Type u_3} {B : Type u_1} {C : Type u_2} [inst : Ring A] [inst_1 : Ring B] [inst_2 : Ring C] (f : A →+* B)
(f_inv : B → A) (hf : Function.RightInverse f_inv ⇑f) (φ : B →+* C),
(fun g => f.liftOfRightInverseAux f_inv hf ↑g ⋯) ((fun φ => ⟨φ.comp f, ⋯⟩) φ) = φ |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValueCast_mem._simp_1_5 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {x y : Sigma β}, (x = y) = (x.fst = y.fst ∧ x.snd ≍ y.snd) |
AlgebraicTopology.DoldKan.HigherFacesVanish.induction | Mathlib.AlgebraicTopology.DoldKan.Faces | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X : CategoryTheory.SimplicialObject C} {Y : C} {n q : ℕ} {φ : Y ⟶ X.obj (Opposite.op (SimplexCategory.mk (n + 1)))},
AlgebraicTopology.DoldKan.HigherFacesVanish q φ →
AlgebraicTopology.DoldKan.HigherFacesVanish (q + 1)
(CategoryTheory.CategoryStruct.comp φ
((CategoryTheory.CategoryStruct.id (AlgebraicTopology.AlternatingFaceMapComplex.obj X) +
AlgebraicTopology.DoldKan.Hσ q).f
(n + 1))) |
Lean.Parser.Term.open.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer |
LinearMap.mkContinuous_coe | Mathlib.Analysis.Normed.Operator.ContinuousLinearMap | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_3} {F : Type u_4} [inst : Ring 𝕜] [inst_1 : Ring 𝕜₂]
[inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 E] [inst_5 : Module 𝕜₂ F]
{σ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ] F) (C : ℝ) (h : ∀ (x : E), ‖f x‖ ≤ C * ‖x‖), ↑(f.mkContinuous C h) = f |
hnot_sup_self | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α] (a : α), ￢a ⊔ a = ⊤ |
CategoryTheory.NatTrans.mk.injEq | Mathlib.CategoryTheory.NatTrans | ∀ {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} (app : (X : C) → F.obj X ⟶ G.obj X)
(naturality :
autoParam
(∀ ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (app Y) = CategoryTheory.CategoryStruct.comp (app X) (G.map f))
CategoryTheory.NatTrans.naturality._autoParam)
(app_1 : (X : C) → F.obj X ⟶ G.obj X)
(naturality_1 :
autoParam
(∀ ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (app_1 Y) = CategoryTheory.CategoryStruct.comp (app_1 X) (G.map f))
CategoryTheory.NatTrans.naturality._autoParam),
({ app := app, naturality := naturality } = { app := app_1, naturality := naturality_1 }) = (app = app_1) |
fwdDiff_const | Mathlib.Algebra.Group.ForwardDiff | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommGroup G] (h : M) (g : G),
(fwdDiff h fun x => g) = fun x => 0 |
Nat.sSup_mem | Mathlib.Data.Nat.Lattice | ∀ {s : Set ℕ}, s.Nonempty → BddAbove s → sSup s ∈ s |
Lean.Elab.Term.Do.attachJPs | Lean.Elab.Do.Legacy | Array Lean.Elab.Term.Do.JPDecl → Lean.Elab.Term.Do.Code → Lean.Elab.Term.Do.Code |
_private.Lean.Meta.LevelDefEq.0.Lean.Meta.strictOccursMax | Lean.Meta.LevelDefEq | Lean.Level → Lean.Level → Bool |
_private.Init.Grind.Ordered.Module.0.Lean.Grind.OrderedAdd.zsmul_le_zsmul._simp_1_1 | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.AddCommGroup M] [Lean.Grind.OrderedAdd M]
{a b : M}, (0 ≤ a - b) = (b ≤ a) |
CategoryTheory.ShortComplex.isoMk._auto_3 | Mathlib.Algebra.Homology.ShortComplex.Basic | Lean.Syntax |
SubAddAction.instInhabited.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : VAdd R M], SubAddAction.instInhabited = { default := ⊥ } |
Std.DTreeMap.Raw.Const.ofList._auto_1 | Std.Data.DTreeMap.Raw.Basic | Lean.Syntax |
RingHom.map_iterate_frobenius | Mathlib.Algebra.CharP.Frobenius | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (g : R →+* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p] (x : R) (n : ℕ),
g ((⇑(frobenius R p))^[n] x) = (⇑(frobenius S p))^[n] (g x) |
PFunctor.Idx | Mathlib.Data.PFunctor.Univariate.Basic | PFunctor.{uA, uB} → Type (max uA uB) |
Lean.Meta.Try.Collector.OrdSet.insert | Lean.Meta.Tactic.Try.Collect | {α : Type} → {x : Hashable α} → {x_1 : BEq α} → Lean.Meta.Try.Collector.OrdSet α → α → Lean.Meta.Try.Collector.OrdSet α |
_private.Mathlib.Data.Multiset.DershowitzManna.0.Multiset.transGen_oneStep_of_isDershowitzMannaLT._simp_1_1 | Mathlib.Data.Multiset.DershowitzManna | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α},
(a ∈ Multiset.filter p s) = (a ∈ s ∧ p a) |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.discharge?.match_1 | Lean.Meta.Tactic.Grind.Main | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((p : Lean.Expr) → motive (some p)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift |
ContinuousMap.instNonUnitalCommCStarAlgebra._proof_6 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_1} {A : Type u_2} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : NonUnitalCommCStarAlgebra A] (a b c : C(α, A)), a * (b + c) = a * b + a * c |
Mathlib.Tactic.Monoidal.instMkEvalWhiskerLeftMonoidalM.match_1 | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | (ctx : Mathlib.Tactic.Monoidal.Context) →
(motive : Option Q(CategoryTheory.MonoidalCategory unknown_1) → Sort u_1) →
(x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) →
((_monoidal : Q(CategoryTheory.MonoidalCategory unknown_1)) → motive (some _monoidal)) →
((x : Option Q(CategoryTheory.MonoidalCategory unknown_1)) → motive x) → motive x |
isClosed_Ioo_iff | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a b : α},
IsClosed (Set.Ioo a b) ↔ b ≤ a |
_private.Mathlib.Algebra.Module.Submodule.Union.0.Submodule.iUnion_ssubset_of_forall_ne_top_of_card_lt._simp_1_1 | Mathlib.Algebra.Module.Submodule.Union | ∀ {α : Type u} {s : Set α}, (s ⊂ Set.univ) = (s ≠ Set.univ) |
Submonoid.smulDistribClass | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_4} {S : Type u_5} [inst : SMul M' α] [inst_1 : SMul M' β]
[inst_2 : SMul α β] [inst_3 : SetLike S M'] [h : SMulDistribClass M' α β] (N' : S), SMulDistribClass (↥N') α β |
UInt8.mod_eq_of_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a < b → a % b = a |
Aesop.RuleBuilderInput.noConfusion | Aesop.Builder.Basic | {P : Sort u} → {t t' : Aesop.RuleBuilderInput} → t = t' → Aesop.RuleBuilderInput.noConfusionType P t t' |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.replace.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a : α) (b : β a) (a_1 : α) (b_1 : β a_1)
(es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.replace a b (Std.DHashMap.Internal.AssocList.cons a_1 b_1 es) =
bif a_1 == a then Std.DHashMap.Internal.AssocList.cons a b es
else Std.DHashMap.Internal.AssocList.cons a_1 b_1 (Std.DHashMap.Internal.AssocList.replace a b es) |
CategoryTheory.Dial.rightUnitorImpl._proof_1 | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X : CategoryTheory.Dial C),
(X.tensorObjImpl CategoryTheory.Dial.tensorUnitImpl).rel =
(CategoryTheory.Subobject.pullback
(CategoryTheory.Limits.prod.map (CategoryTheory.Limits.prod.rightUnitor X.src).hom
(CategoryTheory.Limits.prod.rightUnitor X.tgt).hom)).obj
X.rel |
NumberField.mixedEmbedding.convexBodySum_volume_eq_zero_of_le_zero | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {B : ℝ},
B ≤ 0 → MeasureTheory.volume (NumberField.mixedEmbedding.convexBodySum K B) = 0 |
iUnion_Iic_eq_Iio_of_lt_of_tendsto | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {ι : Type u_1} {F : Filter ι} [F.NeBot] [inst : ConditionallyCompleteLinearOrder α]
[inst_1 : TopologicalSpace α] [ClosedIicTopology α] {a : α} {f : ι → α},
(∀ (i : ι), f i < a) → Filter.Tendsto f F (nhds a) → ⋃ i, Set.Iic (f i) = Set.Iio a |
CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : CategoryTheory.Limits.HasBiproductsOfShape J C]
(X : CategoryTheory.Functor (CategoryTheory.Discrete J) C),
CategoryTheory.Limits.HasBiproductsOfShape.colimIsoLim.inv.app X =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Pi.isoLimit X).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biproduct.lift (CategoryTheory.Limits.Pi.π fun j => X.obj { as := j }))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.biproduct.desc (CategoryTheory.Limits.Sigma.ι fun j => X.obj { as := j }))
(CategoryTheory.Limits.Sigma.isoColimit X).hom)) |
MonadControlT | Init.Control.Basic | (Type u → Type v) → (Type u → Type w) → Type (max (max (u + 1) v) w) |
Matrix.conjTranspose_reindex | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {l : Type u_1} {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} [inst : Star α] (eₘ : m ≃ l) (eₙ : n ≃ o)
(M : Matrix m n α), ((Matrix.reindex eₘ eₙ) M).conjTranspose = (Matrix.reindex eₙ eₘ) M.conjTranspose |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.