name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.UniformSpace.HeineCantor.0.Continuous.tendstoUniformly.match_1_1 | Mathlib.Topology.UniformSpace.HeineCantor | ∀ {α : Type u_1} [inst : UniformSpace α] (x : α) (motive : (∃ s, IsCompact s ∧ s ∈ nhds x) → Prop)
(x_1 : ∃ s, IsCompact s ∧ s ∈ nhds x), (∀ (K : Set α) (hK : IsCompact K) (hxK : K ∈ nhds x), motive ⋯) → motive x_1 | null | false |
Lean.Grind.CommRing.Power.denote_eq | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (p : Lean.Grind.CommRing.Power),
Lean.Grind.CommRing.Power.denote ctx p = Lean.Grind.CommRing.Var.denote ctx p.x ^ p.k | null | true |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.Extension.twoCocycleAux._abel_2 | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_2} {L : Type u_4} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing M] [inst_4 : LieAlgebra R M] (E : LieAlgebra.Extension R M L) {s : L →ₗ[R] E.L} (x y x_1 : L),
⁅s x, s x_1⁆ + ⁅s y, s x_1⁆ - (s ⁅x, x_1⁆ + s ⁅y, x_1⁆) = ⁅s x, s x_1⁆ - s ⁅x, x_1⁆ + (⁅s... | null | false |
LinearPMap.eqLocus_zero | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {f : E →ₛₗ.[σ] F},
f.eqLocus 0 = f.ker | null | true |
ProbabilityTheory.Kernel.prodMkLeft_apply' | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (ca : γ × α) (s : Set β),
((ProbabilityTheory.Kernel.prodMkLeft γ κ) ca) s = (κ ca.2) s | null | true |
List.le_minIdxOn_of_apply_getElem_lt_apply_getElem._proof_2 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {xs : List α} {i : ℕ}, i < xs.length → ∀ j < i, j < xs.length | null | false |
_private.Mathlib.Algebra.Order.Algebra.0.Mathlib.Meta.Positivity.evalAlgebraMap._proof_5 | Mathlib.Algebra.Order.Algebra | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | null | false |
LinearIsometry.one_def | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {E : Type u_4} [inst : Semiring R] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module R E],
1 = LinearIsometry.id | null | true |
BitVec.reduceShiftLeftShiftLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | null | true |
Submonoid.unitClosedBall.congr_simp | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ (𝕜 : Type u_2) [inst : SeminormedRing 𝕜] [inst_1 : NormOneClass 𝕜],
Submonoid.unitClosedBall 𝕜 = Submonoid.unitClosedBall 𝕜 | null | true |
Group.IsVirtuallyCyclic.mk | Mathlib.GroupTheory.SpecificGroups.VirtuallyCyclic | ∀ {G : Type u_3} [inst : Group G], (∃ H, IsCyclic ↥H ∧ H.FiniteIndex) → Group.IsVirtuallyCyclic G | null | true |
UpperSet.mem_Ioi_iff._simp_2 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (b ∈ UpperSet.Ioi a) = (a < b) | null | false |
Std.Sat.CNF.Clause.unit_ne_empty | Std.Sat.CNF.Unit | ∀ {α : Type u_1} {pol : Bool} {atom : α}, Std.Sat.CNF.Clause.unit atom pol ≠ Std.Sat.CNF.Clause.empty | null | true |
HomologicalComplex.extend.X.eq_2 | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c), HomologicalComplex.extend.X K none = 0 | null | true |
Std.DHashMap.Raw.Const.getD_eq_getD | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : LawfulBEq α], m.WF → ∀ {a : α} {fallback : β}, Std.DHashMap.Raw.Const.getD m a fallback = m.getD a fallback | null | true |
CategoryTheory.Limits.isColimitMapCoconeCoforkEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Equalizers | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D) {X Y Z : C} {f g : X ⟶ Y} {h : Y ⟶ Z}
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h),
CategoryTheory.CategoryStruct.... | null | false |
LinearMap.exact_zero_iff_injective._simp_1 | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_8} [inst : Ring R] {M : Type u_12} {N : Type u_13} (P : Type u_14) [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommMonoid P] [inst_4 : Module R N] [inst_5 : Module R M] [inst_6 : Module R P]
(f : M →ₗ[R] N), Function.Exact ⇑0 ⇑f = Function.Injective ⇑f | null | false |
Lean.Meta.Grind.Arith.Cutsat.State.dvds._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.PersistentArray (Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) | null | false |
AlgebraicGeometry.IsReduced.component_reduced | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme} [self : AlgebraicGeometry.IsReduced X] (U : X.Opens),
IsReduced ↑(X.presheaf.obj (Opposite.op U)) | null | true |
LieHom.quotKerEquivRange_invFun | Mathlib.Algebra.Lie.Quotient | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (f : L →ₗ⁅R⁆ L') (a : ↥(↑f).range),
f.quotKerEquivRange.invFun a = (↑f).quotKerEquivRange.invFun a | null | true |
Batteries.Tactic.Lint.checkAllSimpTheoremInfos | Batteries.Tactic.Lint.Simp | Lean.Expr →
(Batteries.Tactic.Lint.SimpTheoremInfo → Lean.MetaM (Option Lean.MessageData)) → Lean.MetaM (Option Lean.MessageData) | Constructs a message from all the simp theorems encoded in the given type. | true |
ULift.up_compare | Mathlib.Order.ULift | ∀ {α : Type u} [inst : Ord α] (a b : α), compare { down := a } { down := b } = compare a b | null | true |
FreeGroup.Red.decidableRel._proof_1 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1}, FreeGroup.Red [] [] | null | false |
CategoryTheory.ComposableArrows.homMkSucc_app_zero | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) (β : F.δ₀ ⟶ G.δ₀)
(w :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheo... | null | true |
CategoryTheory.Limits.BinaryFan.associatorOfLimitCone | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(L : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) →
(X Y Z : C) → (L (L X Y).cone.pt Z).cone.pt ≅ (L X (L Y Z).cone.pt).cone.pt | Given a fixed family of limit data for every pair `X Y`, we obtain an associator. | true |
SimpleGraph.Walk.IsPath.mk' | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, p.support.Nodup → p.IsPath | null | true |
CategoryTheory.Functor.CommShift.ofComp | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D ... | Given an isomorphism `e : F ⋙ G ≅ H` where `G` is fully faithful,
the functor `F` commutes with shifts by `A` if `G` and `H` do. | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceEIntProdNatCoreE₂CohomologicalNat._proof_10 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (p q p' q' : ℕ), ↑q - 1 + r = ↑q' → ↑(p', q').2 + (r, 1 - r).2 = ↑(p, q).2 | null | false |
Lean.Doc.MarkdownM.InlineCtx.inLink._default | Lean.DocString.Markdown | Bool | null | false |
SimpleGraph.between.eq_1 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} (s t : Set V) (G : SimpleGraph V),
SimpleGraph.between s t G =
{ Adj := fun v w => G.Adj v w ∧ (v ∈ s ∧ w ∈ t ∨ v ∈ t ∧ w ∈ s), symm := ⋯, loopless := ⋯ } | null | true |
CategoryTheory.Limits.ChosenPullback.LiftStruct.f_p₁ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X₁ X₂ S : C} {f₁ : X₁ ⟶ S} {f₂ : X₂ ⟶ S}
{h : CategoryTheory.Limits.ChosenPullback f₁ f₂} {Y : C} {g₁ : Y ⟶ X₁} {g₂ : Y ⟶ X₂} {b : Y ⟶ S}
(self : h.LiftStruct g₁ g₂ b), CategoryTheory.CategoryStruct.comp self.f h.p₁ = g₁ | null | true |
StarAlgEquiv.ofInjective._proof_3 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : StarRing A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : StarRing B] (f : A →⋆ₐ[R] B)
(hf : Function.Injective ⇑f) (x y : A),
(AlgEquiv.ofInjective (↑f) hf).toFun (x * y) =
(... | null | false |
AlgHom.toRingHom_injective | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], Function.Injective RingHomClass.toRingHom | null | true |
Nat.multinomial_pos | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} (s : Finset α) (f : α → ℕ), 0 < Nat.multinomial s f | null | true |
_private.Batteries.Data.Vector.Basic.0.Vector.scanrMFast.loop._unary._proof_9 | Batteries.Data.Vector.Basic | ∀ {n : ℕ} (n_usize : USize),
n_usize.toNat = n → ∀ (i : USize), i.toNat ≤ n → 0 < i.toNat → (i - 1).toNat = i.toNat - 1 → (i - 1).toNat < n | null | false |
WithLp.fstₗ._proof_2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_3) (α : Type u_2) (β : Type u_1) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : 𝕜) (x_1 : WithLp p (α × β)),
(x • x_1).fst = (x • x_1).fst | null | false |
AlgebraicGeometry.instConnectedSpaceCarrierCarrierCommRingCatFiberOfGeometricallyConnected | Mathlib.AlgebraicGeometry.Geometrically.Connected | ∀ {X S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (s : ↥S) [AlgebraicGeometry.GeometricallyConnected f],
ConnectedSpace ↥(AlgebraicGeometry.Scheme.Hom.fiber f s) | null | true |
CategoryTheory.NatTrans.Equifibered.op | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] {F G : CategoryTheory.Functor J C} {α : F ⟶ G},
CategoryTheory.NatTrans.Equifibered α → CategoryTheory.NatTrans.Coequifibered (CategoryTheory.NatTrans.op α) | null | true |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._proof_1_28 | Mathlib.Algebra.Lie.CartanExists | ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L],
AddMemClass (LieSubalgebra K L) L | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_44 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls : ℕ)
(ll_1 lr_1 : Std.DTreeMap.Internal.Impl α β),
ll_1.Balanced ∧
lr_1.Balanced ∧
(ll_1.size + lr_1.size ≤ 1 ∨ ll_1.size ≤ 3 * lr_1.size ∧ lr_1.size ≤ 3 * ll_1.size) ∧
ls = ll_1.size + 1 + lr_1.size →
... | null | false |
RootPairing.GeckConstruction.basis._proof_7 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K] [inst_1 : CharZero K] {ι : Type u_2} {M : Type u_3} {N : Type u_4}
[inst_2 : Fintype ι] [inst_3 : DecidableEq ι] [inst_4 : AddCommGroup M] [inst_5 : Module K M]
[inst_6 : AddCommGroup N] [inst_7 : Module K N] {P : RootPairing ι K M N} [P.IsReduced]
[inst_9 : P.IsCrystallographic]... | null | false |
Lean.SimpleScopedEnvExtension.Descr.mk.inj | Lean.ScopedEnvExtension | ∀ {α σ : Type} {name : autoParam Lean.Name Lean.SimpleScopedEnvExtension.Descr.name._autoParam} {addEntry : σ → α → σ}
{initial : σ} {finalizeImport : σ → σ} {exportEntry? : Lean.Environment → α → Lean.OLeanEntries (Option α)}
{name_1 : autoParam Lean.Name Lean.SimpleScopedEnvExtension.Descr.name._autoParam} {addEn... | null | true |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.exists_cons_of_mem.match_1_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a : α} (l : List α) (motive : (∃ s t, l = s ++ a :: t) → Prop) (x : ∃ s t, l = s ++ a :: t),
(∀ (l₁ l₂ : List α) (e : l = l₁ ++ a :: l₂), motive ⋯) → motive x | null | false |
CategoryTheory.Lax.OplaxTrans.Hom.ext | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {x y : CategoryTheory.Lax.OplaxTrans.Hom η θ}, x.as = y.as → x = y | null | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._proof_257 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬0 ≤ 2 → False | null | false |
Order.isPredPrelimit_iff_isMax | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : PredOrder α] [IsPredArchimedean α],
Order.IsPredPrelimit a ↔ IsMax a | null | true |
IsLocalizedModule.Away.iff_of_associated | Mathlib.Algebra.Module.LocalizedModule.Away | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} {N : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {f : M →ₗ[R] N} {r r' : R},
Associated r r' → (IsLocalizedModule.Away r f ↔ IsLocalizedModule.Away r' f) | null | true |
CategoryTheory.Limits.colimitLimitIso.congr_simp | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
[inst_4 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_5 : CategoryTheory.Li... | null | true |
and_or_left._simp_2 | Mathlib.Tactic.Push | ∀ {a b c : Prop}, (a ∧ b ∨ a ∧ c) = (a ∧ (b ∨ c)) | null | false |
IsTopologicalGroup.tendstoUniformlyOn_iff | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Group G] [u : UniformSpace G] [inst_1 : IsTopologicalGroup G]
(F : ι → α → G) (f : α → G) (p : Filter ι) (s : Set α),
IsTopologicalGroup.rightUniformSpace G = u →
(TendstoUniformlyOn F f p s ↔ ∀ u_1 ∈ nhds 1, ∀ᶠ (i : ι) in p, ∀ a ∈ s, F i a / f a ∈ u_1) | null | true |
BooleanSubalgebra.map_le_iff_le_comap | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {L : BooleanSubalgebra α}
{f : BoundedLatticeHom α β} {M : BooleanSubalgebra β}, BooleanSubalgebra.map f L ≤ M ↔ L ≤ BooleanSubalgebra.comap f M | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0._regBuiltin.BitVec.reduceToInt.declare_223._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.2509174877._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_39 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | null | false |
CategoryTheory.MorphismProperty.of_pushout_inr_of_codescendsAlong | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {Z X Y : C}
{f : Z ⟶ X} {g : Z ⟶ Y} [P.CodescendsAlong Q] [inst_2 : CategoryTheory.Limits.HasPushout f g],
Q g → P (CategoryTheory.Limits.pushout.inr f g) → P f | null | true |
Lean.OLeanLevel.exported | Lean.Environment | Lean.OLeanLevel | Information from exported contexts. | true |
Finset.singletonAddMonoidHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : AddZeroClass α] → α →+ Finset α | The singleton operation as an `AddMonoidHom`. | true |
DFinsupp.instIsBotZeroClass | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} (α : ι → Type u_2) [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), IsBotZeroClass (α i)], IsBotZeroClass (Π₀ (i : ι), α i) | null | true |
FP.ofPosRatDn | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → ℕ+ → ℕ+ → FP.Float × Bool | null | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.Path.zoom_ins.match_1_10 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {path : RBTree.RBNode.Path α} (a : RBTree.RBNode α) (y : α) (b : RBTree.RBNode α)
(motive :
(path' : RBTree.RBNode.Path α) →
(t' : RBTree.RBNode α) → (RBTree.RBNode.node RBTree.RBColor.black a y b, path) = (t', path') → Prop)
(path' : RBTree.RBNode.Path α) (t' : RBTree.RBNode α)
(x : (R... | null | false |
Set.inter_singleton_eq_empty._simp_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ∩ {a} = ∅) = (a ∉ s) | null | false |
IsRelUpperSet.sInter | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α] {S : Set (Set α)},
S.Nonempty → (∀ s ∈ S, IsRelUpperSet s P) → IsRelUpperSet (⋂₀ S) P | null | true |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.suffix_of_getLast_mem_of_infix._proof_1_5 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l₁ l₂ : List α} {hne : l₂ ≠ []} (w w_1 : List α), w ++ l₁ ++ w_1 = l₂ → ¬w ++ l₁ ++ w_1 = [] | null | false |
Lean.mkFreshId | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadNameGenerator m] → m Lean.Name | Creates a globally unique `Name`, without any semantic interpretation.
The names are not intended to be user-visible.
With the default name generator, names use `_uniq` as a base and have a numeric suffix.
This is used for example by `Lean.mkFreshFVarId`, `Lean.mkFreshMVarId`, and `Lean.mkFreshLMVarId`.
To create fres... | true |
CategoryTheory.IsKernelPair.lift'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C}
(k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X)
(w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f),
CategoryTheory.CategoryStruct.comp (k.lift p q w) a = p ∧ Catego... | null | false |
CategoryTheory.SplitEpi.mk.congr_simp | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} (section_ section__1 : Y ⟶ X)
(e_section_ : section_ = section__1)
(id : CategoryTheory.CategoryStruct.comp section_ f = CategoryTheory.CategoryStruct.id Y),
{ section_ := section_, id := id } = { section_ := section__1, id := ⋯ } | null | true |
UniformFun.instPseudoMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace β] (x x_1 : UniformFun α β),
0 ≤ ⨆ i, dist (UniformFun.toFun x i) (UniformFun.toFun x_1 i) | null | false |
instCoeTCSpectralMapOfSpectralMapClass | Mathlib.Topology.Spectral.Hom | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : FunLike F α β] → [SpectralMapClass F α β] → CoeTC F (SpectralMap α β) | null | true |
eq_rec_inj | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {a a' : α} (h : a = a') {C : α → Type u_3} (x y : C a), h ▸ x = h ▸ y ↔ x = y | null | true |
SSet.stdSimplex.instFullSimplexCategory | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | CategoryTheory.Functor.Full SSet.stdSimplex | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.isOffsetPattern?.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Expr → Sort u_1) →
(k : Lean.Expr) → ((k : ℕ) → motive (Lean.Expr.lit (Lean.Literal.natVal k))) → ((x : Lean.Expr) → motive x) → motive k | null | false |
USize.lt_irrefl | Init.Data.UInt.Lemmas | ∀ (a : USize), ¬a < a | null | true |
CategoryTheory.GrothendieckTopology.yonedaEquiv_symm_naturality_right | Mathlib.CategoryTheory.Sites.Subcanonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] (X : C) {F F' : CategoryTheory.Sheaf J (Type v)} (f : F ⟶ F')
(x : F.obj.obj (Opposite.op X)),
CategoryTheory.CategoryStruct.comp (J.yonedaEquiv.symm x) f =
J.yonedaEquiv.symm ((Categ... | null | true |
Polynomial.quo_add_sum_rem_mul_pow_inverse_unique | Mathlib.Algebra.Polynomial.PartialFractions | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : CommRing K] [inst_2 : Algebra (Polynomial R) K]
[FaithfulSMul (Polynomial R) K] {ι : Type u_3} {s : Finset ι} {g : ι → Polynomial R},
(∀ i ∈ s, (g i).Monic) →
((↑s).Pairwise fun i j => IsCoprime (g i) (g j)) →
∀ {n : ι → ℕ} {gi : ι → K},
... | Let `R` be a commutative ring and `f : R[X]`. Let `s` be a finite index set.
Let `g i` be a collection of monic and pairwise coprime polynomials indexed by `s`,
and for each `g i` let `n i` be a natural number.
Let `K` be an algebra over `R[X]` containing inverses `gi i` for each `g i`.
Then a fraction of the form `f *... | true |
MeasureTheory.Measure.ae_sum_eq | Mathlib.MeasureTheory.Measure.Sum | ∀ {α : Type u_1} {ι : Type u_2} {mα : MeasurableSpace α} [Countable ι] (μ : ι → MeasureTheory.Measure α),
MeasureTheory.ae (MeasureTheory.Measure.sum μ) = ⨆ i, MeasureTheory.ae (μ i) | null | true |
CategoryTheory.Functor.isContinuous_id | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C),
(CategoryTheory.Functor.id C).IsContinuous J J | null | true |
SimpleGraph.eq_singletonSubgraph_iff_verts_eq | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (H : G.Subgraph) {v : V}, H = G.singletonSubgraph v ↔ H.verts = {v} | null | true |
CategoryTheory.MorphismProperty.Comma.mapLeftId._proof_5 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | null | false |
UInt8.instNonUnitalCommRing | Mathlib.Data.UInt | NonUnitalCommRing UInt8 | null | true |
IsRightRegular.subsingleton | Mathlib.Algebra.GroupWithZero.Regular | ∀ {R : Type u_1} [inst : MulZeroClass R], IsRightRegular 0 → Subsingleton R | The element `0` is right-regular if and only if `R` is trivial. | true |
LinearMap.compl₁₂ | Mathlib.LinearAlgebra.BilinearMap | {R₁ : Type u_3} →
{R₂ : Type u_4} →
[inst : Semiring R₁] →
[inst_1 : Semiring R₂] →
{Mₗ : Type u_6} →
{N : Type u_7} →
{Pₗ : Type u_9} →
{Qₗ : Type u_10} →
{Qₗ' : Type u_11} →
[inst_2 : AddCommMonoid Mₗ] →
[ins... | Composing linear maps `Q → M` and `Q' → N` with a bilinear map `M → N → P` to
form a bilinear map `Q → Q' → P`. | true |
AddSubmonoid.center.addCommMonoid'._proof_3 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b c : ↥(AddSubsemigroup.center M)), a + b + c = a + (b + c) | null | false |
CategoryTheory.Limits.Bicone.toCoconeFunctor._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {x x_1 : CategoryTheory.Limits.Bicone F}
(F_1 : x ⟶ x_1) (x_2 : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (x.ι x_2.as) F_1.hom = x_1.ι x_2.as | null | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.withProtectedMCtx.main | Lean.Meta.Tactic.Grind.Main | {m : Type → Type} →
{α : Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] →
[MonadLiftT Lean.MetaM m] → Lean.Grind.Config → (Lean.MVarId → m α) → Lean.MVarId → m α | null | true |
NumberField.RingOfIntegers.instAlgebra_1._proof_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] (r : NumberField.RingOfIntegers K) (x : K),
(NumberField.RingOfIntegers.instAlgebra._aux_3 K) r * x = x * (NumberField.RingOfIntegers.instAlgebra._aux_3 K) r | null | false |
Std.DTreeMap.Internal.Impl.Const.minKey_alter_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k : α} {f : Option β → Option β} {he : (Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.isEmpty = false},
(Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.minKey he = k ↔
(f (Std.DT... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_not._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, ¬2 ^ w - 1 - x.toNat < 2 ^ w → False | null | false |
CategoryTheory.RingObjCat.forget | Mathlib.CategoryTheory.Monoidal.Ring | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.Functor (CategoryTheory.RingObjCat C) C | The forgetful functor from the category of ring objects in `C` to `C`. | true |
AlgebraicGeometry.Scheme.AffineCover.mk.inj | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {S : AlgebraicGeometry.Scheme} {I₀ : Type v}
{X : I₀ → CommRingCat} {f : (j : I₀) → AlgebraicGeometry.Spec (X j) ⟶ S} {idx : ↥S → I₀}
{covers : ∀ (x : ↥S), x ∈ Set.range ⇑(f (idx x))}
{map_prop : autoParam (∀ (j : I₀), P (f j)) AlgebraicGeometry.Sch... | null | true |
OrderIso.setIsotypicComponents._proof_4 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSemisimpleModule R M]
(m : ↥(fullyInvariantSubmodule R M)) (S : Submodule R M),
IsSimpleModule R ↥S → S ≤ ↑m → isotypicComponent R M ↥S ≤ ↑(⨆ i ∈ (fun m => {c | ↑c ≤ ↑m}) m, ⟨↑i, ⋯⟩) | null | false |
HomologicalComplex.xNextIso | Mathlib.Algebra.Homology.HomologicalComplex | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{c : ComplexShape ι} → (C : HomologicalComplex V c) → {i j : ι} → c.Rel i j → (C.xNext i ≅ C.X j) | If `c.Rel i j`, then `C.xNext i` is isomorphic to `C.X j`. | true |
String.rawEndPos_ofList | Batteries.Data.String.Lemmas | ∀ (cs : List Char), (String.ofList cs).rawEndPos = { byteIdx := String.utf8Len cs } | null | true |
Lean.LeanOptionValue.noConfusion | Lean.Util.LeanOptions | {P : Sort u} → {t t' : Lean.LeanOptionValue} → t = t' → Lean.LeanOptionValue.noConfusionType P t t' | null | false |
GaloisCoinsertion.u_l_le | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(self : GaloisCoinsertion l u) (x : α), u (l x) ≤ x | Main property of a Galois coinsertion. | true |
RestrictedProduct.instMonoidCoeOfSubmonoidClass._proof_5 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)]
(x x_1 : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕), ⇑(x * x_1) = ⇑(x * x_1) | null | false |
AlgebraicGeometry.Scheme.RationalMap.equivFunctionFieldOver._proof_3 | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y S : AlgebraicGeometry.Scheme} [inst : X.Over S] [inst_1 : Y.Over S],
(fun f => f.compHom (Y ↘ S) = AlgebraicGeometry.Scheme.Hom.toRationalMap (X ↘ S)) = fun f =>
AlgebraicGeometry.Scheme.RationalMap.IsOver S f | null | false |
LightCondensed.lanLightCondSet._proof_1 | Mathlib.Condensed.Discrete.Colimit | ∀ (X : Type u_1),
CategoryTheory.Presheaf.IsSheaf (CategoryTheory.coherentTopology LightProfinite)
(LightCondensed.lanPresheaf (LightCondensed.locallyConstantPresheaf X)) | null | false |
CategoryTheory.MorphismProperty.Over.mk_left | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) {X A : T} (f : A ⟶ X) (hf : P f),
(CategoryTheory.MorphismProperty.Over.mk Q f hf).left = A | null | true |
ContDiffBump.neg | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : HasContDiffBump E]
(f : ContDiffBump 0) (x : E), ↑f (-x) = ↑f x | null | true |
Polynomial.mahlerMeasure_one | Mathlib.Analysis.Polynomial.MahlerMeasure | Polynomial.mahlerMeasure 1 = 1 | null | true |
ContinuousMap.instNormOneClassOfNonempty | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] [Nonempty α] [inst_4 : One E] [NormOneClass E], NormOneClass C(α, E) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.