name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.PullbackShift.adjunction_counit | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] (φ : A →+ B) [inst_3 : CategoryTheory.HasShift C B] {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
{F : CategoryTheory.F... | true |
CategoryTheory.SmallObject.FunctorObjIndex.comm_assoc | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C}
(πX : X ⟶ S)
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX))
C]
[inst_2 :
CategoryTheory.Limits.HasPu... | true |
ContinuousLinearMap.IsIdempotentElem.ext | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : M →L[R] M},
IsIdempotentElem p → IsIdempotentElem q → (↑p).range = (↑q).range ∧ (↑p).ker = (↑q).ker → p = q | true |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.le_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ}, (↑m < ↑n) = (m < n) | false |
Pi.cancelMonoid._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → CancelMonoid (f i)], IsRightCancelMul ((i : I) → f i) | false |
ULift.forall | Mathlib.Data.ULift | ∀ {α : Type u} {p : ULift.{u_1, u} α → Prop}, (∀ (x : ULift.{u_1, u} α), p x) ↔ ∀ (x : α), p { down := x } | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.Action.hugeNumber | Lean.Meta.Tactic.Grind.Intro | ℕ | true |
MonoidHom.smulOneHom | Mathlib.Algebra.Group.Action.Hom | {M : Type u_4} →
{N : Type u_5} →
[inst : Monoid M] → [inst_1 : MulOneClass N] → [inst_2 : MulAction M N] → [IsScalarTower M N N] → M →* N | true |
Lean.Macro.State | Init.Prelude | Type | true |
List.perm_reverse | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse ↔ l₁.Perm l₂ | true |
CategoryTheory.EnrichedCat.bicategory._proof_3 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c : CategoryTheory.EnrichedCat V} {f g : CategoryTheory.EnrichedFunctor V ↑a ↑b}
{h i : CategoryTheory.EnrichedFunctor V ↑b ↑c} (α : f ⟶ g) (β : h ⟶ i),
CategoryTheory.CategoryStruct.comp (CategoryTheo... | false |
UInt16.toUInt32_and | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a &&& b).toUInt32 = a.toUInt32 &&& b.toUInt32 | true |
Lean.Grind.instToIntIntIi._proof_2 | Init.GrindInstances.ToInt | ∀ (x : ℤ), id x ∈ Lean.Grind.IntInterval.ii | false |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_support_count_tail_eq_one | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.IsHamiltonianCycle ↔ p.IsCycle ∧ ∀ (a_1 : α), List.count a_1 p.support.tail = 1 | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.brecOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive : Lean.Meta.Grind.Arith.CommRing.PolyDerivation → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
((t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.below t → motive t) →
motive t | false |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_10 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι} (hbc : b ≤ c) (val : ι)
(property : val ∈ Finset.Ioc a b), b ≤ b → ↑⟨b, ⋯⟩ ∈ Finset.Ioc a b | false |
_private.Mathlib.Analysis.Convex.Segment.0.insert_endpoints_openSegment._simp_1_1 | Mathlib.Analysis.Convex.Segment | ∀ {α : Type u} [inst : HasSubset α] {a b : α} [Std.Refl fun x1 x2 => x1 ⊆ x2] [Std.Antisymm fun x1 x2 => x1 ⊆ x2],
(a = b) = (a ⊆ b ∧ b ⊆ a) | false |
MeasureTheory.AEStronglyMeasurable.add_const | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : Add β] [ContinuousAdd β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : β), MeasureTheory.AEStronglyMeasurable (fun x => f x + c) μ | true |
Monoid.PushoutI.hom_ext_iff | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} {K : Type u_4} [inst : Monoid K] [inst_1 : (i : ι) → Monoid (G i)]
[inst_2 : Monoid H] {φ : (i : ι) → H →* G i} {f g : Monoid.PushoutI φ →* K},
f = g ↔
(∀ (i : ι), f.comp (Monoid.PushoutI.of i) = g.comp (Monoid.PushoutI.of i)) ∧
f.comp (Monoid.PushoutI.ba... | true |
_private.Aesop.Nanos.0.Aesop.instBEqNanos.beq.match_1 | Aesop.Nanos | (motive : Aesop.Nanos → Aesop.Nanos → Sort u_1) →
(x x_1 : Aesop.Nanos) →
((a b : ℕ) → motive { nanos := a } { nanos := b }) → ((x x_2 : Aesop.Nanos) → motive x x_2) → motive x x_1 | false |
HXor.mk.noConfusion | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : outParam (Type w)} →
{P : Sort u_1} → {hXor hXor' : α → β → γ} → { hXor := hXor } = { hXor := hXor' } → (hXor ≍ hXor' → P) → P | false |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_of_two_pow_le_and_two_pow_add_one_gt._proof_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n : ℕ} {i : ℕ}, ∀ i' ≥ i, ¬i = i' → ¬i + 1 ≤ i' → False | false |
CategoryTheory.MonObj.pow_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (f : X ⟶ M) (n : ℕ) (g : M ⟶ N)
[CategoryTheory.IsMonHom g], CategoryTheory.CategoryStruct.comp (f ^ n) g = CategoryThe... | true |
_private.Init.Data.List.Sort.Basic.0.List.merge.match_1 | Init.Data.List.Sort.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(xs ys : List α) →
((ys : List α) → motive [] ys) →
((xs : List α) → motive xs []) →
((x : α) → (xs : List α) → (y : α) → (ys : List α) → motive (x :: xs) (y :: ys)) → motive xs ys | false |
Polynomial.contentIdeal_le_span_content | Mathlib.RingTheory.Polynomial.ContentIdeal | ∀ {R : Type u_3} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] {p : Polynomial R},
p.contentIdeal ≤ Ideal.span {p.content} | true |
Mathlib.Tactic.LibraryRewrite.Kind.hypothesis.sizeOf_spec | Mathlib.Tactic.Widget.LibraryRewrite | sizeOf Mathlib.Tactic.LibraryRewrite.Kind.hypothesis = 1 | true |
exists_ne_mem_inter_of_not_pairwise_disjoint | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {ι : Type u_4} {f : ι → Set α},
¬Pairwise (Function.onFun Disjoint f) → ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.isAdmissible_iff_isChain_and_le._proof_1_20 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ {m : ℕ} (k : ℕ), m + (k + 1) ≤ m + 1 + k | false |
Std.DTreeMap.Equiv.getEntryGT_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ cmp x k = Ordering.gt → Prop) (x_1 : x ∈ t₁ ∧ cmp x k = Ordering.gt),
(∀ (h₁ : x ∈ t₁) (h₂ : cmp x k = Ordering.gt), motive ⋯) → motive x_1 | false |
CommGroupWithZero.toGroupWithZero | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → [self : CommGroupWithZero G₀] → GroupWithZero G₀ | true |
Lean.Grind.CommRing.Mon.sharesVar._unary | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | (_ : Lean.Grind.CommRing.Mon) ×' Lean.Grind.CommRing.Mon → Bool | false |
Aesop.NormalizationState.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.NormalizationState} → t = t' → Aesop.NormalizationState.noConfusionType P t t' | false |
CategoryTheory.CopyDiscardCategory.copy_tensor | Mathlib.CategoryTheory.CopyDiscardCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.CopyDiscardCategory C] (X Y : C),
CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.ComonObj.comul C... | true |
Lean.Meta.Try.collect | Lean.Meta.Tactic.Try.Collect | Lean.MVarId → Lean.Try.Config → Lean.MetaM Lean.Meta.Try.Info | true |
MeasureTheory.SimpleFunc.noConfusionType | Mathlib.MeasureTheory.Function.SimpleFunc | Sort u_1 →
{α : Type u} →
[inst : MeasurableSpace α] →
{β : Type v} →
MeasureTheory.SimpleFunc α β →
{α' : Type u} → [inst' : MeasurableSpace α'] → {β' : Type v} → MeasureTheory.SimpleFunc α' β' → Sort u_1 | false |
Std.ExtDTreeMap.eq_empty_iff_size_eq_zero | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
t = ∅ ↔ t.size = 0 | true |
Multiset.ssubset_singleton_iff | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, s ⊂ {a} ↔ s = 0 | true |
UpperSet.completeLattice | Mathlib.Order.UpperLower.CompleteLattice | {α : Type u_1} → [inst : LE α] → CompleteLattice (UpperSet α) | true |
QuotientGroup.dense_preimage_mk._simp_2 | Mathlib.Topology.Algebra.Group.Quotient | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] {N : Subgroup G}
{s : Set (G ⧸ N)}, Dense (QuotientGroup.mk ⁻¹' s) = Dense s | false |
NonarchAddGroupSeminorm.instZero._proof_3 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (x : E), 0 (-x) = 0 (-x) | false |
Std.Iter.toList_zip_of_finite_right | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Productive α₁ Id] [Std.Iterators.Finite α₂ Id],
(it₁.zip it₂).toList = (Std.Iter.take it₂.toList.length it₁).toList.zip it₂.toList | true |
Set.BijOn.surjOn | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → Set.SurjOn f s t | true |
MeasureTheory.Measure.FiniteAtFilter | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} → {_m0 : MeasurableSpace α} → MeasureTheory.Measure α → Filter α → Prop | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_4 | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (∃ c, b = a * c) = (a ∣ b) | false |
Lean.Parser.nameLitFn | Lean.Parser.Basic | Lean.Parser.ParserFn | true |
QuaternionAlgebra.instRing._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R] (x : QuaternionAlgebra R c₁ c₂ c₃), 0 * x = 0 | false |
ConditionallyCompletePartialOrderInf.isGLB_csInf_of_directed | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | ∀ {α : Type u_3} [self : ConditionallyCompletePartialOrderInf α] (s : Set α),
DirectedOn (fun x1 x2 => x1 ≥ x2) s → s.Nonempty → BddBelow s → IsGLB s (sInf s) | true |
CategoryTheory.Endofunctor.Algebra.Hom.mk.inj | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} {f : A₀.a ⟶ A₁.a}
{h :
autoParam (CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f)
CategoryTheory.Endofunctor.Algebra.H... | true |
CategoryTheory.Limits.PushoutCocone.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingSpan C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.PushoutCocone (F.map CategoryTheory.Limits.WalkingSpan.Hom.fst)
(F.map CategoryTheory.Limits.WalkingSpan.Hom.... | true |
LaurentSeries.coe_range_dense | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_2} [inst : Field K], DenseRange ⇑(algebraMap (RatFunc K) (LaurentSeries K)) | true |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.isCyclotomicExtension_iff_eq_adjoin._simp_1_9 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
WeierstrassCurve.Projective.addY_of_X_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P Q : Fin 3 → F},
W.Equation P →
W.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → W.addY P Q = WeierstrassCurve.Projective.addU P Q | true |
MeasureTheory.hittingBtwn.eq_1 | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Preorder ι] [inst_1 : InfSet ι] (u : ι → Ω → β) (s : Set β)
(n m : ι) (x : Ω),
MeasureTheory.hittingBtwn u s n m x = if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i | u i x ∈ s}) else m | true |
CategoryTheory.Functor.Faithful.mapMon | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] [F.Faithful], F.mapMon.Faithful | true |
Finset.inv_subset_inv | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Inv α] {s t : Finset α}, s ⊆ t → s⁻¹ ⊆ t⁻¹ | true |
Algebra.Extension.tensorCotangentInvFun._proof_5 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] {P : Algebra.Extension R S} {Q : Algebra.Extension R T}
[alg : Algebra P.Ring Q.Ring], IsScalarTower P.Ring Q.Ring ↥Q.ker | false |
groupHomology.coinfNatTrans._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k : Type u_1) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal] (n : ℕ)
{X Y : Rep.{u_1, u_1, u_1} k G} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((groupHomology.functor k G n).map φ)
(groupHomology.map (QuotientGroup.mk' S) (Y.toCoinvariantsMkQ S) n) =
Ca... | false |
Nat.odd_mul_odd_div_two | Mathlib.Data.Nat.ModEq | ∀ {m n : ℕ}, m % 2 = 1 → n % 2 = 1 → m * n / 2 = m * (n / 2) + m / 2 | true |
initFn._@.Lean.Elab.Tactic.TreeTacAttr.1721268732._hygCtx._hyg.2 | Lean.Elab.Tactic.TreeTacAttr | IO Lean.Meta.SimpExtension | false |
Computability.encodingNatBool | Mathlib.Computability.Encoding | Computability.Encoding ℕ | true |
Std.Do.Spec.modifyGet_StateT | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {σ α : Type u} {f : σ → α × σ}
{Q : Std.Do.PostCond α (Std.Do.PostShape.arg σ ps)} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps],
⦃fun s =>
have t := f s;
Q.1 t.1 t.2⦄
MonadStateOf.modifyGet f ⦃Q⦄ | true |
PartOrdEmb.instConcreteCategoryOrderEmbeddingCarrier._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y : PartOrdEmb} (f : ↑X ↪o ↑Y), { hom' := f }.hom' = f | false |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_56 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x head : α) (tail : List α),
¬([(head :: tail).getLast ⋯] ++ [x]).dropLast.isEmpty = true → ([(head :: tail).getLast ⋯] ++ [x]).dropLast ≠ [] | false |
Lean.VersoModuleDocs.snippets | Lean.DocString.Extension | Lean.VersoModuleDocs → Lean.PersistentArray Lean.VersoModuleDocs.Snippet | true |
Std.Time.instHSubOffsetOffset_22 | Std.Time.Date.Basic | HSub Std.Time.Minute.Offset Std.Time.Day.Offset Std.Time.Minute.Offset | true |
instMulPosMonoWithZeroOfMulRightMono | Mathlib.Algebra.Order.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulRightMono α], MulPosMono (WithZero α) | true |
CFC.nnrpow_two | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalRing A] [inst_2 : TopologicalSpace A] [inst_3 : StarRing A]
[inst_4 : Module ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : Nonneg... | true |
Std.ExtDHashMap.instInsertSigmaOfEquivBEqOfLawfulHashable.match_1 | Std.Data.ExtDHashMap.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{x : BEq α} →
{x_1 : Hashable α} →
(motive : (a : α) × β a → Std.ExtDHashMap α β → Sort u_3) →
(x_2 : (a : α) × β a) →
(x_3 : Std.ExtDHashMap α β) →
((a : α) → (b : β a) → (s : Std.ExtDHashMap α β) → motive ⟨a, b⟩ s) → motive ... | false |
CategoryTheory.Oplax.OplaxTrans.vcomp._proof_5 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.Oplax.OplaxTrans F G)
(θ : CategoryTheory.Oplax.OplaxTrans G H) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(C... | false |
Antitone.iSup_comp_tendsto_atBot | Mathlib.Order.Filter.AtTopBot.CompleteLattice | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : ConditionallyCompleteLattice γ]
[OrderTop γ] {l : Filter α} [l.NeBot] {f : β → γ},
Antitone f → ∀ {g : α → β}, Filter.Tendsto g l Filter.atBot → ⨆ a, f (g a) = ⨆ b, f b | true |
CategoryTheory.Mat.instAddCommGroupHom | Mathlib.CategoryTheory.Preadditive.Mat | (R : Type) → [inst : Ring R] → (X Y : CategoryTheory.Mat R) → AddCommGroup (X ⟶ Y) | true |
RingQuot.ringQuot_ext | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] {T : Type uT} [inst_1 : NonAssocSemiring T] {r : R → R → Prop}
(f g : RingQuot r →+* T), f.comp (RingQuot.mkRingHom r) = g.comp (RingQuot.mkRingHom r) → f = g | true |
CategoryTheory.Adjunction.compUliftCoyonedaIso_inv_app_app_down | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (X : Cᵒᵖ) (X_1 : D)
(a :
((CategoryTheory.uliftCoyoneda.{max w v₂, v₁, u₁}.comp
((CategoryTheory.F... | true |
AlgebraicGeometry.isIso_ΓSpec_adjunction_unit_app_basicOpen | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X : AlgebraicGeometry.Scheme} [CompactSpace ↥X] [QuasiSeparatedSpace ↥X] (f : ↑(X.presheaf.obj (Opposite.op ⊤))),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.app X.toSpecΓ (PrimeSpectrum.basicOpen f)) | true |
RingEquiv.toNonUnitalRingHom_trans | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} {S' : Type u_6} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring S'] (e₁ : R ≃+* S) (e₂ : S ≃+* S'),
(e₁.trans e₂).toNonUnitalRingHom = e₂.toNonUnitalRingHom.comp e₁.toNonUnitalRingHom | true |
AddSubgroup.single_mem_pi._simp_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → AddGroup (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → AddSubgroup (f i)} (i : η) (x : f i), (Pi.single i x ∈ AddSubgroup.pi I H) = (i ∈ I → x ∈ H i) | false |
Lean.Parser.«_aux_Init_Simproc___macroRules_Lean_Parser_command__Simproc__[_]_(_):=__1» | Init.Simproc | Lean.Macro | false |
Nat.exists_subseq_of_forall_mem_union | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {s t : Set α} (e : ℕ → α),
(∀ (n : ℕ), e n ∈ s ∪ t) → ∃ g, (∀ (n : ℕ), e (g n) ∈ s) ∨ ∀ (n : ℕ), e (g n) ∈ t | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.SavedState.mk.injEq | Lean.Elab.StructInst | ∀ (termState : Lean.Elab.Term.SavedState) (state : Lean.Elab.Term.StructInst.StructInstState✝)
(termState_1 : Lean.Elab.Term.SavedState) (state_1 : Lean.Elab.Term.StructInst.StructInstState✝¹),
({ termState := termState, state := state } = { termState := termState_1, state := state_1 }) =
(termState = termState... | true |
CategoryTheory.FreeMonoidalCategory.Hom.l_inv | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} → (X : CategoryTheory.FreeMonoidalCategory C) → X.Hom (CategoryTheory.FreeMonoidalCategory.unit.tensor X) | true |
HomotopyGroup.commGroup._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] [inst_2 : Nontrivial N],
EckmannHilton.IsUnital Mul.mul ⟦GenLoop.const⟧ | false |
hasStrictDerivAt_exp_smul_const_of_mem_ball | Mathlib.Analysis.SpecialFunctions.Exponential | ∀ {𝕂 : Type u_1} {𝔸 : Type u_3} [inst : NontriviallyNormedField 𝕂] [CharZero 𝕂] [inst_2 : NormedRing 𝔸]
[inst_3 : NormedAlgebra 𝕂 𝔸] [CompleteSpace 𝔸] (x : 𝔸) (t : 𝕂),
t • x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius →
HasStrictDerivAt (fun u => NormedSpace.exp (u • x)) (NormedSpace.exp (t ... | true |
CategoryTheory.Functor.ι_biproductComparison'_assoc | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {J : Type w₁}
(F : CategoryTheory.Functor C D) (f : J → C) [inst_4 : CategoryTheory.Limits.H... | true |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.initFn._@.Lean.Parser.Tactic.Doc.1176478476._hygCtx._hyg.2 | Lean.Parser.Tactic.Doc | IO Unit | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_le_length_insertEntry._proof_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} {l : List ((a : α) × β a)}, ¬l.length ≤ l.length + 1 → False | false |
String.rawStartPos_eq | Init.Data.String.Defs | ∀ {s : String}, s.rawStartPos = 0 | true |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.le_weightedOrder_subst_of_forall_ne_zero._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i | false |
CategoryTheory.congrArg_cast_hom_left | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (p : X = Y) (q : Y ⟶ Z),
cast ⋯ q = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) q | true |
Topology.IsInducing.mk | Mathlib.Topology.Defs.Induced | ∀ {X : Type u_1} {Y : Type u_2} [tX : TopologicalSpace X] [tY : TopologicalSpace Y] {f : X → Y},
tX = TopologicalSpace.induced f tY → Topology.IsInducing f | true |
WType.mk.injEq | Mathlib.Data.W.Basic | ∀ {α : Type u_1} {β : α → Type u_2} (a : α) (f : β a → WType β) (a_1 : α) (f_1 : β a_1 → WType β),
(WType.mk a f = WType.mk a_1 f_1) = (a = a_1 ∧ f ≍ f_1) | true |
Lean.Server.Test.Runner.Client.NormalizeState.mk.noConfusion | Lean.Server.Test.Runner | {P : Sort u} →
{freshPtr : USize} →
{knownPtrs : Std.TreeMap USize USize compare} →
{freshPtr' : USize} →
{knownPtrs' : Std.TreeMap USize USize compare} →
{ freshPtr := freshPtr, knownPtrs := knownPtrs } = { freshPtr := freshPtr', knownPtrs := knownPtrs' } →
(freshPtr = freshPt... | false |
NormedSpace.inclusionInDoubleDualWeak | Mathlib.Analysis.Normed.Module.DoubleDual | (𝕜 : Type u_1) →
[inst : NontriviallyNormedField 𝕜] →
(X : Type u_2) →
[inst_1 : SeminormedAddCommGroup X] → [inst_2 : NormedSpace 𝕜 X] → WeakSpace 𝕜 X →L[𝕜] WeakDual 𝕜 (StrongDual 𝕜 X) | true |
subset_interior_add_left | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : AddGroup α] [ContinuousConstVAdd αᵃᵒᵖ α] {s t : Set α},
interior s + t ⊆ interior (s + t) | true |
Lean.Parser.Term.doIfCond.parenthesizer | Lean.Parser.Do | Lean.PrettyPrinter.Parenthesizer | true |
MeasureTheory.SimpleFunc.range_const | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {β : Type u_2} (α : Type u_5) [inst : MeasurableSpace α] [Nonempty α] (b : β),
(MeasureTheory.SimpleFunc.const α b).range = {b} | true |
Lean.Quote.mk._flat_ctor | Init.Meta.Defs | {α : Type} → {k : optParam Lean.SyntaxNodeKind `term} → (α → Lean.TSyntax k) → Lean.Quote α k | false |
addMonoidAlgebraAlgEquivDirectSum._proof_4 | Mathlib.Algebra.MonoidAlgebra.ToDirectSum | ∀ {ι : Type u_2} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : (m : A) → Decidable (m ≠ 0)] (x y : AddMonoidAlgebra A ι),
addMonoidAlgebraRingEquivDirectSum.toFun (x + y) =
addMonoidAlgebraRingEquivDirectSum.toFun x + addMonoidAlgebraRingEquivDirectSum.toFun y | false |
LinearOrderedCommGroupWithZero.zpow | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} → [self : LinearOrderedCommGroupWithZero α] → ℤ → α → α | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.instIsCancelMulZeroOfIsCancelAdd._simp_15 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsRightCancelMulZero M₀] {a b c : M₀}, (a * c = b * c) = (a = b ∨ c = 0) | false |
ContinuousLinearMap.hasDerivWithinAt_of_bilinear | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {G : Type u_1}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : 𝕜} {s : Set 𝕜} {B : E →L[𝕜] F →L[𝕜... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.