name
string | module
string | type
string |
|---|---|---|
Std.ExtDTreeMap.minKey!_insert_le_self
|
Std.Data.ExtDTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited Ξ±] {k : Ξ±} {v : Ξ² k}, (cmp (t.insert k v).minKey! k).isLE = true
|
Lean.Lsp.SemanticTokenModifier.declaration.elim
|
Lean.Data.Lsp.LanguageFeatures
|
{motive : Lean.Lsp.SemanticTokenModifier β Sort u} β
(t : Lean.Lsp.SemanticTokenModifier) β t.ctorIdx = 0 β motive Lean.Lsp.SemanticTokenModifier.declaration β motive t
|
Fin.rev_sub
|
Mathlib.Algebra.Group.Fin.Basic
|
β {n : β} (a b : Fin n), (a - b).rev = a.rev + b
|
Finset.sum_eq_zero
|
Mathlib.Algebra.BigOperators.Group.Finset.Basic
|
β {ΞΉ : Type u_1} {M : Type u_4} {s : Finset ΞΉ} [inst : AddCommMonoid M] {f : ΞΉ β M},
(β x β s, f x = 0) β β x β s, f x = 0
|
TopModuleCat.withModuleTopologyAdj._proof_1
|
Mathlib.Algebra.Category.ModuleCat.Topology.Basic
|
β (R : Type u_2) [inst : Ring R] [inst_1 : TopologicalSpace R] β¦X Y : TopModuleCat Rβ¦ (f : X βΆ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forgetβ (TopModuleCat R) (ModuleCat R)).comp (TopModuleCat.withModuleTopology R)).map f)
(TopModuleCat.ofHom { toLinearMap := LinearMap.id, cont := β― }) =
CategoryTheory.CategoryStruct.comp (TopModuleCat.ofHom { toLinearMap := LinearMap.id, cont := β― })
((CategoryTheory.Functor.id (TopModuleCat R)).map f)
|
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.cons._proof_1_3
|
Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms
|
β (head : β) (tail : List β), 1 β€ (head :: tail).length β 0 < (head :: tail).length
|
isOpen.dynEntourage
|
Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage
|
β {X : Type u_1} {U : SetRel X X} [inst : TopologicalSpace X] {T : X β X},
Continuous T β IsOpen U β β (n : β), IsOpen (Dynamics.dynEntourage T U n)
|
ContinuousLinearMap
|
Mathlib.Topology.Algebra.Module.LinearMap
|
{R : Type u_1} β
{S : Type u_2} β
[inst : Semiring R] β
[inst_1 : Semiring S] β
(R β+* S) β
(M : Type u_3) β
[TopologicalSpace M] β
[inst_3 : AddCommMonoid M] β
(Mβ : Type u_4) β
[TopologicalSpace Mβ] β
[inst_5 : AddCommMonoid Mβ] β [Module R M] β [Module S Mβ] β Type (max u_3 u_4)
|
Std.Rco.instForIn'InferInstanceMembershipOfLawfulUpwardEnumerableOfLawfulUpwardEnumerableLEOfLawfulUpwardEnumerableLTOfMonadOfFiniteIteratorId.congr_simp
|
Init.Data.Range.Polymorphic.Lemmas
|
β {Ξ± : Type u} {m : Type u β Type u_1} [inst : Std.PRange.UpwardEnumerable Ξ±] [inst_1 : LE Ξ±] [inst_2 : LT Ξ±]
[inst_3 : DecidableLT Ξ±] [inst_4 : Std.PRange.LawfulUpwardEnumerable Ξ±]
[inst_5 : Std.PRange.LawfulUpwardEnumerableLE Ξ±] [inst_6 : Std.PRange.LawfulUpwardEnumerableLT Ξ±] [inst_7 : Monad m]
[inst_8 : Std.Iterators.Finite (Std.Rxo.Iterator Ξ±) Id],
Std.Rco.instForIn'InferInstanceMembershipOfLawfulUpwardEnumerableOfLawfulUpwardEnumerableLEOfLawfulUpwardEnumerableLTOfMonadOfFiniteIteratorId =
Std.Rco.instForIn'InferInstanceMembershipOfLawfulUpwardEnumerableOfLawfulUpwardEnumerableLEOfLawfulUpwardEnumerableLTOfMonadOfFiniteIteratorId
|
Relation.ReflGen.mono
|
Mathlib.Logic.Relation
|
β {Ξ± : Type u_1} {r p : Ξ± β Ξ± β Prop},
(β (a b : Ξ±), r a b β p a b) β β {a b : Ξ±}, Relation.ReflGen r a b β Relation.ReflGen p a b
|
AddSubgroup.map_injective
|
Mathlib.Algebra.Group.Subgroup.Ker
|
β {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {f : G β+ N},
Function.Injective βf β Function.Injective (AddSubgroup.map f)
|
MonoidHom.toHomPerm_apply_symm_apply
|
Mathlib.Algebra.Group.End
|
β {Ξ± : Type u_4} {G : Type u_7} [inst : Group G] (f : G β* Function.End Ξ±) (a : G),
β(Equiv.symm (f.toHomPerm a)) = β(f.toHomUnits a)β»ΒΉ
|
Lean.Grind.CommRing.Expr.pow.inj
|
Init.Grind.Ring.CommSolver
|
β {a : Lean.Grind.CommRing.Expr} {k : β} {a_1 : Lean.Grind.CommRing.Expr} {k_1 : β},
a.pow k = a_1.pow k_1 β a = a_1 β§ k = k_1
|
PresheafOfModules.toPresheaf._proof_3
|
Mathlib.Algebra.Category.ModuleCat.Presheaf
|
β {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (R : CategoryTheory.Functor Cα΅α΅ RingCat)
(X : PresheafOfModules R),
{
app := fun X_1 =>
AddCommGrpCat.ofHom
(AddMonoidHom.mk' β(CategoryTheory.ConcreteCategory.hom ((CategoryTheory.CategoryStruct.id X).app X_1)) β―),
naturality := β― } =
CategoryTheory.CategoryStruct.id X.presheaf
|
CategoryTheory.MonadHom.app_ΞΌ_assoc
|
Mathlib.CategoryTheory.Monad.Basic
|
β {C : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] {Tβ Tβ : CategoryTheory.Monad C}
(self : CategoryTheory.MonadHom Tβ Tβ) (X : C) {Z : C} (h : Tβ.obj X βΆ Z),
CategoryTheory.CategoryStruct.comp (Tβ.ΞΌ.app X) (CategoryTheory.CategoryStruct.comp (self.app X) h) =
CategoryTheory.CategoryStruct.comp (Tβ.map (self.app X))
(CategoryTheory.CategoryStruct.comp (self.app (Tβ.obj X)) (CategoryTheory.CategoryStruct.comp (Tβ.ΞΌ.app X) h))
|
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_500
|
Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital
|
Lean.Syntax
|
_private.Mathlib.MeasureTheory.Measure.Map.0.MeasurableEquiv.map_ae._simp_1_1
|
Mathlib.MeasureTheory.Measure.Map
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Filter Ξ±} {m : Ξ± β Ξ²} {t : Set Ξ²}, (t β Filter.map m f) = (m β»ΒΉ' t β f)
|
Lean.Widget.GetWidgetSourceParams.mk.injEq
|
Lean.Widget.UserWidget
|
β (hash : UInt64) (pos : Lean.Lsp.Position) (hash_1 : UInt64) (pos_1 : Lean.Lsp.Position),
({ hash := hash, pos := pos } = { hash := hash_1, pos := pos_1 }) = (hash = hash_1 β§ pos = pos_1)
|
MeasurableEmbedding.schroederBernstein._proof_3
|
Mathlib.MeasureTheory.MeasurableSpace.Embedding
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Ξ²} {g : Ξ² β Ξ±} (A : Set Ξ±),
(fun A => (g '' (f '' A)αΆ)αΆ) A = A β AαΆ = g '' (f '' A)αΆ
|
Rep.coindResAdjunction_counit_app
|
Mathlib.RepresentationTheory.FiniteIndex
|
β {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel β(QuotientGroup.rightRel S)] [inst_3 : S.FiniteIndex] (B : Rep k G),
(Rep.coindResAdjunction k S).counit.app B =
CategoryTheory.CategoryStruct.comp (Rep.indCoindIso ((Action.res (ModuleCat k) S.subtype).obj B)).inv
((Rep.indResAdjunction k S.subtype).counit.app B)
|
IsPreconnected.intermediate_value_Ioc
|
Mathlib.Topology.Order.IntermediateValue
|
β {X : Type u} {Ξ± : Type v} [inst : TopologicalSpace X] [inst_1 : LinearOrder Ξ±] [inst_2 : TopologicalSpace Ξ±]
[OrderClosedTopology Ξ±] {s : Set X},
IsPreconnected s β
β {a : X} {l : Filter X},
a β s β
β [l.NeBot],
l β€ Filter.principal s β
β {f : X β Ξ±}, ContinuousOn f s β β {v : Ξ±}, Filter.Tendsto f l (nhds v) β Set.Ioc v (f a) β f '' s
|
CochainComplex.ConnectData.d_sub_one_zero
|
Mathlib.Algebra.Homology.Embedding.Connect
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C β} {L : CochainComplex C β} (h : CochainComplex.ConnectData K L), h.d (-1) 0 = h.dβ
|
Set.injOn_iff_injective
|
Mathlib.Data.Set.Restrict
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {s : Set Ξ±} {f : Ξ± β Ξ²}, Set.InjOn f s β Function.Injective (s.restrict f)
|
Turing.TM2to1.stmtStRec._unsafe_rec
|
Mathlib.Computability.TuringMachine
|
{K : Type u_1} β
{Ξ : K β Type u_2} β
{Ξ : Type u_3} β
{Ο : Type u_4} β
{motive : Turing.TM2.Stmt Ξ Ξ Ο β Sort l} β
((k : K) β
(s : Turing.TM2to1.StAct K Ξ Ο k) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β motive q β motive (Turing.TM2to1.stRun s q)) β
((a : Ο β Ο) β (q : Turing.TM2.Stmt Ξ Ξ Ο) β motive q β motive (Turing.TM2.Stmt.load a q)) β
((p : Ο β Bool) β
(qβ qβ : Turing.TM2.Stmt Ξ Ξ Ο) β motive qβ β motive qβ β motive (Turing.TM2.Stmt.branch p qβ qβ)) β
((l : Ο β Ξ) β motive (Turing.TM2.Stmt.goto l)) β
motive Turing.TM2.Stmt.halt β (n : Turing.TM2.Stmt Ξ Ξ Ο) β motive n
|
Lean.Doc.MarkdownInline.mk
|
Lean.DocString.Markdown
|
{i : Type u} β
((Lean.Doc.Inline i β Lean.Doc.MarkdownM Unit) β i β Array (Lean.Doc.Inline i) β Lean.Doc.MarkdownM Unit) β
Lean.Doc.MarkdownInline i
|
Lean.Linter.LinterOptions.noConfusionType
|
Lean.Linter.Basic
|
Sort u β Lean.Linter.LinterOptions β Lean.Linter.LinterOptions β Sort u
|
CategoryTheory.Pretriangulated.shortComplexOfDistTriangleIsoOfIso._proof_3
|
Mathlib.CategoryTheory.Triangulated.Pretriangulated
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C β€]
{T T' : CategoryTheory.Pretriangulated.Triangle C} (e : T β
T'),
CategoryTheory.CategoryStruct.comp e.hom.homβ T'.morβ = CategoryTheory.CategoryStruct.comp T.morβ e.hom.homβ
|
SubalgebraClass.toAlgebra._proof_1
|
Mathlib.Algebra.Algebra.Subalgebra.Basic
|
β {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
(algebraMap R A) 1 = 1
|
ContinuousSqrt.mk.noConfusion
|
Mathlib.Topology.ContinuousMap.StarOrdered
|
{R : Type u_1} β
{inst : LE R} β
{inst_1 : NonUnitalSemiring R} β
{inst_2 : TopologicalSpace R} β
{P : Sort u} β
{sqrt : R Γ R β R} β
{continuousOn_sqrt : ContinuousOn sqrt {x | x.1 β€ x.2}} β
{sqrt_nonneg : β (x : R Γ R), x.1 β€ x.2 β 0 β€ sqrt x} β
{sqrt_mul_sqrt : β (x : R Γ R), x.1 β€ x.2 β x.2 = x.1 + sqrt x * sqrt x} β
{sqrt' : R Γ R β R} β
{continuousOn_sqrt' : ContinuousOn sqrt' {x | x.1 β€ x.2}} β
{sqrt_nonneg' : β (x : R Γ R), x.1 β€ x.2 β 0 β€ sqrt' x} β
{sqrt_mul_sqrt' : β (x : R Γ R), x.1 β€ x.2 β x.2 = x.1 + sqrt' x * sqrt' x} β
{ sqrt := sqrt, continuousOn_sqrt := continuousOn_sqrt, sqrt_nonneg := sqrt_nonneg,
sqrt_mul_sqrt := sqrt_mul_sqrt } =
{ sqrt := sqrt', continuousOn_sqrt := continuousOn_sqrt', sqrt_nonneg := sqrt_nonneg',
sqrt_mul_sqrt := sqrt_mul_sqrt' } β
(sqrt β sqrt' β P) β P
|
Nat.Primes.prodNatEquiv_apply
|
Mathlib.Data.Nat.Factorization.PrimePow
|
β (p : Nat.Primes) (k : β), Nat.Primes.prodNatEquiv (p, k) = β¨βp ^ (k + 1), β―β©
|
FiniteField.X_pow_card_sub_X_natDegree_eq
|
Mathlib.FieldTheory.Finite.Basic
|
β (K' : Type u_3) [inst : Field K'] {p : β}, 1 < p β (Polynomial.X ^ p - Polynomial.X).natDegree = p
|
Lean.Meta.EtaStructMode
|
Init.MetaTypes
|
Type
|
nonzero_span_atom
|
Mathlib.LinearAlgebra.Basis.VectorSpace
|
β {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (v : V),
v β 0 β IsAtom (K β v)
|
Polynomial.exists_multiset_roots._unary
|
Mathlib.Algebra.Polynomial.RingDivision
|
β {R : Type u} [inst : CommRing R] [IsDomain R] [inst_2 : DecidableEq R] (_x : (p : Polynomial R) Γ' p β 0),
β s, βs.card β€ _x.1.degree β§ β (a : R), Multiset.count a s = Polynomial.rootMultiplicity a _x.1
|
_private.Mathlib.Data.Nat.GCD.BigOperators.0.Nat.coprime_list_prod_left_iff._simp_1_1
|
Mathlib.Data.Nat.GCD.BigOperators
|
β {m n k : β}, (m * n).Coprime k = (m.Coprime k β§ n.Coprime k)
|
CategoryTheory.Abelian.coimageIsoImage'
|
Mathlib.CategoryTheory.Abelian.Basic
|
{C : Type u} β
[inst : CategoryTheory.Category.{v, u} C] β
[inst_1 : CategoryTheory.Abelian C] β
{X Y : C} β (f : X βΆ Y) β CategoryTheory.Abelian.coimage f β
CategoryTheory.Limits.image f
|
String.Slice.Pattern.ForwardCharPredSearcher.noConfusion
|
Init.Data.String.Pattern.Pred
|
{P : Sort u} β
{p : Char β Bool} β
{s : String.Slice} β
{t : String.Slice.Pattern.ForwardCharPredSearcher p s} β
{p' : Char β Bool} β
{s' : String.Slice} β
{t' : String.Slice.Pattern.ForwardCharPredSearcher p' s'} β
p = p' β s = s' β t β t' β String.Slice.Pattern.ForwardCharPredSearcher.noConfusionType P t t'
|
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_12
|
Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph
|
β {V : Type u_1} {G : SimpleGraph V} {v u : V} {p : G.Walk u v}, β i' < p.length, i' + 1 β€ p.length
|
Rep.indCoindIso._proof_3
|
Mathlib.RepresentationTheory.FiniteIndex
|
β {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel β(QuotientGroup.rightRel S)] (A : Rep k β₯S) [inst_3 : S.FiniteIndex],
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom A.indToCoind) (ModuleCat.ofHom A.coindToInd) =
CategoryTheory.CategoryStruct.id (Rep.ind S.subtype A).V
|
LinearMap.coe_prod
|
Mathlib.LinearAlgebra.Prod
|
β {R : Type u} {M : Type v} {Mβ : Type w} {Mβ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid Mβ] [inst_3 : AddCommMonoid Mβ] [inst_4 : Module R M] [inst_5 : Module R Mβ]
[inst_6 : Module R Mβ] (f : M ββ[R] Mβ) (g : M ββ[R] Mβ), β(f.prod g) = Pi.prod βf βg
|
CategoryTheory.Aut.instGroup._proof_7
|
Mathlib.CategoryTheory.Endomorphism
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) (x x_1 x_2 : CategoryTheory.Aut X),
x_2 βͺβ« x_1 βͺβ« x = (x_2 βͺβ« x_1) βͺβ« x
|
AddMonoidHom.coe_toZModLinearMap
|
Mathlib.Algebra.Module.ZMod
|
β (n : β) {M : Type u_1} {Mβ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup Mβ] [inst_2 : Module (ZMod n) M]
[inst_3 : Module (ZMod n) Mβ] (f : M β+ Mβ), β(AddMonoidHom.toZModLinearMap n f) = βf
|
OrderMonoidHom.toMonoidHom
|
Mathlib.Algebra.Order.Hom.Monoid
|
{Ξ± : Type u_6} β
{Ξ² : Type u_7} β
[inst : Preorder Ξ±] β
[inst_1 : Preorder Ξ²] β [inst_2 : MulOneClass Ξ±] β [inst_3 : MulOneClass Ξ²] β (Ξ± β*o Ξ²) β Ξ± β* Ξ²
|
RingTheory.Sequence.IsWeaklyRegular.of_flat
|
Mathlib.RingTheory.Regular.Flat
|
β {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Module.Flat R S]
{rs : List R},
RingTheory.Sequence.IsWeaklyRegular R rs β RingTheory.Sequence.IsWeaklyRegular S (List.map (β(algebraMap R S)) rs)
|
_private.Mathlib.RingTheory.Idempotents.0.CompleteOrthogonalIdempotents.bijective_pi._simp_1_1
|
Mathlib.RingTheory.Idempotents
|
β {Ξ± : Sort u} {Ξ² : Ξ± β Sort v} {f g : (x : Ξ±) β Ξ² x}, (f = g) = β (x : Ξ±), f x = g x
|
Lean.Elab.MacroStackElem.mk.sizeOf_spec
|
Lean.Elab.Util
|
β (before after : Lean.Syntax), sizeOf { before := before, after := after } = 1 + sizeOf before + sizeOf after
|
Int.land_bit
|
Mathlib.Data.Int.Bitwise
|
β (a : Bool) (m : β€) (b : Bool) (n : β€), (Int.bit a m).land (Int.bit b n) = Int.bit (a && b) (m.land n)
|
LinearMap.SeparatingLeft.toMatrixβ
|
Mathlib.LinearAlgebra.Matrix.SesquilinearForm
|
β {Rβ : Type u_2} {Mβ : Type u_6} {ΞΉ : Type u_15} [inst : CommRing Rβ] [inst_1 : AddCommMonoid Mβ]
[inst_2 : Module Rβ Mβ] [inst_3 : DecidableEq ΞΉ] [inst_4 : Fintype ΞΉ] {B : Mβ ββ[Rβ] Mβ ββ[Rβ] Rβ},
B.SeparatingLeft β β (b : Module.Basis ΞΉ Rβ Mβ), ((LinearMap.toMatrixβ b b) B).Nondegenerate
|
NormedAddGroupHom.normNoninc_of_isometry
|
Mathlib.Analysis.Normed.Group.Hom
|
β {V : Type u_1} {W : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
{f : NormedAddGroupHom V W}, Isometry βf β f.NormNoninc
|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_eq_minKeyD_default._simp_1_1
|
Std.Data.DTreeMap.Internal.Lemmas
|
β {Ξ± : Type u} {x : Ord Ξ±} {x_1 : BEq Ξ±} [Std.LawfulBEqOrd Ξ±] {a b : Ξ±}, (compare a b = Ordering.eq) = ((a == b) = true)
|
CategoryTheory.StrongEpi.mk._flat_ctor
|
Mathlib.CategoryTheory.Limits.Shapes.StrongEpi
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : C} {f : P βΆ Q},
CategoryTheory.Epi f β
(β β¦X Y : Cβ¦ (z : X βΆ Y) [CategoryTheory.Mono z], CategoryTheory.HasLiftingProperty f z) β
CategoryTheory.StrongEpi f
|
_private.Init.Data.List.Impl.0.List.erasePTR.go._unsafe_rec
|
Init.Data.List.Impl
|
{Ξ± : Type u_1} β (Ξ± β Bool) β List Ξ± β List Ξ± β Array Ξ± β List Ξ±
|
SubfieldClass.toDivisionRing._proof_4
|
Mathlib.Algebra.Field.Subfield.Defs
|
β {K : Type u_1} (S : Type u_2) [inst : SetLike S K] (s : S), Function.Injective fun a => βa
|
List.nextOr_singleton
|
Mathlib.Data.List.Cycle
|
β {Ξ± : Type u_1} [inst : DecidableEq Ξ±] (x y d : Ξ±), [y].nextOr x d = d
|
SimpleGraph.EdgeLabeling.pairwise_disjoint_labelGraph
|
Mathlib.Combinatorics.SimpleGraph.EdgeLabeling
|
β {V : Type u_1} {G : SimpleGraph V} {K : Type u_3} {C : G.EdgeLabeling K},
Pairwise fun k l => Disjoint (C.labelGraph k) (C.labelGraph l)
|
Mathlib.Tactic.Hint._aux_Mathlib_Tactic_Hint___elabRules_Mathlib_Tactic_Hint_registerHintStx_1
|
Mathlib.Tactic.Hint
|
Lean.Elab.Command.CommandElab
|
BitVec.toInt_ushiftRight_of_lt
|
Init.Data.BitVec.Lemmas
|
β {w : β} {x : BitVec w} {n : β}, 0 < n β (x >>> n).toInt = β(x.toNat >>> n)
|
Mathlib.Tactic.BicategoryLike.MonadMorβ.homM
|
Mathlib.Tactic.CategoryTheory.Coherence.Datatypes
|
{m : Type β Type} β
[self : Mathlib.Tactic.BicategoryLike.MonadMorβ m] β
Mathlib.Tactic.BicategoryLike.MorβIso β m Mathlib.Tactic.BicategoryLike.Morβ
|
Std.Iterators.PostconditionT.operation_lift
|
Init.Data.Iterators.PostconditionMonad
|
β {m : Type w β Type w'} [inst : Functor m] {Ξ± : Type w} {x : m Ξ±},
(Std.Iterators.PostconditionT.lift x).operation = (fun x_1 => β¨x_1, β―β©) <$> x
|
Algebra.TensorProduct.algEquivOfLinearEquivTripleTensorProduct._proof_1
|
Mathlib.RingTheory.TensorProduct.Maps
|
β {R : Type u_5} {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C]
[inst_6 : Semiring D] [inst_7 : Algebra R D] [inst_8 : Algebra R C]
(f : TensorProduct R (TensorProduct R A B) C ββ[R] D),
(β (aβ aβ : A) (bβ bβ : B) (cβ cβ : C),
f ((aβ * aβ) ββ[R] (bβ * bβ) ββ[R] (cβ * cβ)) = f (aβ ββ[R] bβ ββ[R] cβ) * f (aβ ββ[R] bβ ββ[R] cβ)) β
(LinearMap.mul R (TensorProduct R (TensorProduct R A B) C)).comprβ βf = (LinearMap.mul R D ββ βf).complβ βf
|
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjective_localRingHom_iff._simp_1_4
|
Mathlib.RingTheory.SurjectiveOnStalks
|
β {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {xβ xβ : R} {yβ yβ : β₯M},
(IsLocalization.mk' S xβ yβ = IsLocalization.mk' S xβ yβ) =
((algebraMap R S) (βyβ * xβ) = (algebraMap R S) (βyβ * xβ))
|
AffineIsometry.id._proof_1
|
Mathlib.Analysis.Normed.Affine.Isometry
|
β {π : Type u_2} {V : Type u_1} {P : Type u_3} [inst : NormedField π] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace π V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] (x : V),
β(AffineMap.id π P).linear xβ = β(AffineMap.id π P).linear xβ
|
ContinuousMap.Homotopy.prodMap
|
Mathlib.Topology.Homotopy.Basic
|
{X : Type u} β
{Y : Type v} β
{Z : Type w} β
{Z' : Type x} β
[inst : TopologicalSpace X] β
[inst_1 : TopologicalSpace Y] β
[inst_2 : TopologicalSpace Z] β
[inst_3 : TopologicalSpace Z'] β
{fβ fβ : C(X, Y)} β
{gβ gβ : C(Z, Z')} β fβ.Homotopy fβ β gβ.Homotopy gβ β (fβ.prodMap gβ).Homotopy (fβ.prodMap gβ)
|
Std.Iterators.IteratorLoop.finiteForIn'
|
Init.Data.Iterators.Consumers.Monadic.Loop
|
{m : Type w β Type w'} β
{n : Type x β Type x'} β
{Ξ± Ξ² : Type w} β
[inst : Std.Iterators.Iterator Ξ± m Ξ²] β
[Std.Iterators.IteratorLoop Ξ± m n] β
[Monad n] β
((Ξ³ : Type w) β (Ξ΄ : Type x) β (Ξ³ β n Ξ΄) β m Ξ³ β n Ξ΄) β
ForIn' n (Std.IterM m Ξ²) Ξ² { mem := fun it out => it.IsPlausibleIndirectOutput out }
|
MonoidHom.noncommPiCoprodEquiv._proof_6
|
Mathlib.GroupTheory.NoncommPiCoprod
|
β {M : Type u_3} [inst : Monoid M] {ΞΉ : Type u_1} [inst_1 : Fintype ΞΉ] {N : ΞΉ β Type u_2}
[inst_2 : (i : ΞΉ) β Monoid (N i)] [inst_3 : DecidableEq ΞΉ] (f : ((i : ΞΉ) β N i) β* M),
MonoidHom.noncommPiCoprod ββ¨fun i => f.comp (MonoidHom.mulSingle N i), β―β© β― = f
|
ContinuousLinearEquiv.equivOfRightInverse
|
Mathlib.Topology.Algebra.Module.Equiv
|
{R : Type u_1} β
[inst : Ring R] β
{M : Type u_3} β
[inst_1 : TopologicalSpace M] β
[inst_2 : AddCommGroup M] β
[inst_3 : Module R M] β
{Mβ : Type u_4} β
[inst_4 : TopologicalSpace Mβ] β
[inst_5 : AddCommGroup Mβ] β
[inst_6 : Module R Mβ] β
[IsTopologicalAddGroup M] β
(fβ : M βL[R] Mβ) β
(fβ : Mβ βL[R] M) β Function.RightInverse βfβ βfβ β M βL[R] Mβ Γ β₯(LinearMap.ker fβ)
|
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT_neg_mem._simp_1_5
|
Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody
|
β (p : True β Prop), (β (x : True), p x) = p True.intro
|
AlternatingMap.coe_injective
|
Mathlib.LinearAlgebra.Alternating.Basic
|
β {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ΞΉ : Type u_7}, Function.Injective DFunLike.coe
|
SimpleGraph.cycleGraph_zero_eq_bot
|
Mathlib.Combinatorics.SimpleGraph.Circulant
|
SimpleGraph.cycleGraph 0 = β₯
|
Function.Injective.divisionMonoid
|
Mathlib.Algebra.Group.InjSurj
|
{Mβ : Type u_1} β
{Mβ : Type u_2} β
[inst : Mul Mβ] β
[inst_1 : One Mβ] β
[inst_2 : Pow Mβ β] β
[inst_3 : Inv Mβ] β
[inst_4 : Div Mβ] β
[inst_5 : Pow Mβ β€] β
[inst_6 : DivisionMonoid Mβ] β
(f : Mβ β Mβ) β
Function.Injective f β
f 1 = 1 β
(β (x y : Mβ), f (x * y) = f x * f y) β
(β (x : Mβ), f xβ»ΒΉ = (f x)β»ΒΉ) β
(β (x y : Mβ), f (x / y) = f x / f y) β
(β (x : Mβ) (n : β), f (x ^ n) = f x ^ n) β
(β (x : Mβ) (n : β€), f (x ^ n) = f x ^ n) β DivisionMonoid Mβ
|
Multiset.disjoint_map_map
|
Mathlib.Data.Multiset.UnionInter
|
β {Ξ± : Type u_1} {Ξ² : Type v} {Ξ³ : Type u_2} {f : Ξ± β Ξ³} {g : Ξ² β Ξ³} {s : Multiset Ξ±} {t : Multiset Ξ²},
Disjoint (Multiset.map f s) (Multiset.map g t) β β a β s, β b β t, f a β g b
|
List.Vector.ofFn.match_1
|
Mathlib.Data.Vector.Defs
|
{Ξ± : Type u_2} β
(motive : (x : β) β (Fin x β Ξ±) β Sort u_1) β
(x : β) β
(x_1 : Fin x β Ξ±) β
((x : Fin 0 β Ξ±) β motive 0 x) β ((n : β) β (f : Fin (n + 1) β Ξ±) β motive n.succ f) β motive x x_1
|
Lean.Meta.Match.Example.arrayLit.injEq
|
Lean.Meta.Match.Basic
|
β (a a_1 : List Lean.Meta.Match.Example),
(Lean.Meta.Match.Example.arrayLit a = Lean.Meta.Match.Example.arrayLit a_1) = (a = a_1)
|
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.grind.match_6
|
Lean.Elab.Tactic.Grind.Main
|
(motive : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq) β Sort u_1) β
(seq? : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq)) β
((seq : Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq) β motive (some seq)) β
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq)) β motive x) β motive seq?
|
Std.DTreeMap.Internal.Impl.Const.get!.eq_1
|
Std.Data.DTreeMap.Internal.Model
|
β {Ξ± : Type u} {Ξ΄ : Type w} [inst : Ord Ξ±] [inst_1 : Inhabited Ξ΄] (k : Ξ±),
Std.DTreeMap.Internal.Impl.Const.get! Std.DTreeMap.Internal.Impl.leaf k =
panicWithPosWithDecl "Std.Data.DTreeMap.Internal.Queries" "Std.DTreeMap.Internal.Impl.Const.get!" 221 13
"Key is not present in map"
|
SchwartzMap.mkLM._proof_4
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β {π : Type u_5} {D : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace β E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace β F] [inst_4 : NormedField π]
[inst_5 : NormedAddCommGroup D] [inst_6 : NormedSpace β D] [inst_7 : NormedSpace π E] [inst_8 : SMulCommClass β π E]
[inst_9 : NormedAddCommGroup G] [inst_10 : NormedSpace β G] (A : SchwartzMap D E β F β G),
(β (f g : SchwartzMap D E) (x : F), A (f + g) x = A f x + A g x) β
β (hsmooth : β (f : SchwartzMap D E), ContDiff β (ββ€) (A f))
(hbound :
β (n : β Γ β),
β s C,
0 β€ C β§
β (f : SchwartzMap D E) (x : F),
βxβ ^ n.1 * βiteratedFDeriv β n.2 (A f) xβ β€ C * (s.sup (schwartzSeminormFamily π D E)) f)
(f g : SchwartzMap D E),
{ toFun := A (f + g), smooth' := β―, decay' := β― } =
{ toFun := A f, smooth' := β―, decay' := β― } + { toFun := A g, smooth' := β―, decay' := β― }
|
AlgEquiv.toLinearEquiv_symm
|
Mathlib.Algebra.Algebra.Equiv
|
β {R : Type uR} {Aβ : Type uAβ} {Aβ : Type uAβ} [inst : CommSemiring R] [inst_1 : Semiring Aβ] [inst_2 : Semiring Aβ]
[inst_3 : Algebra R Aβ] [inst_4 : Algebra R Aβ] (e : Aβ ββ[R] Aβ), e.symm.toLinearEquiv = e.toLinearEquiv.symm
|
Lean.Parser.Command.syntaxCat._regBuiltin.Lean.Parser.Command.syntaxCat.formatter_17
|
Lean.Parser.Syntax
|
IO Unit
|
_private.Mathlib.Combinatorics.Matroid.Rank.Finite.0.Matroid.isRkFinite_inter_ground_iff.match_1_1
|
Mathlib.Combinatorics.Matroid.Rank.Finite
|
β {Ξ± : Type u_1} {M : Matroid Ξ±} {X : Set Ξ±} (motive : (β I, M.IsBasis' I X) β Prop) (x : β I, M.IsBasis' I X),
(β (_I : Set Ξ±) (hI : M.IsBasis' _I X), motive β―) β motive x
|
Pi.instPosSMulReflectLE
|
Mathlib.Algebra.Order.Module.Defs
|
β {Ξ± : Type u_1} {ΞΉ : Type u_3} {Ξ² : ΞΉ β Type u_4} [inst : Zero Ξ±] [inst_1 : Preorder Ξ±]
[inst_2 : (i : ΞΉ) β Preorder (Ξ² i)] [inst_3 : (i : ΞΉ) β SMul Ξ± (Ξ² i)] [β (i : ΞΉ), PosSMulReflectLE Ξ± (Ξ² i)],
PosSMulReflectLE Ξ± ((i : ΞΉ) β Ξ² i)
|
ContinuousMultilinearMap.instInhabited
|
Mathlib.Topology.Algebra.Module.Multilinear.Basic
|
{R : Type u} β
{ΞΉ : Type v} β
{Mβ : ΞΉ β Type wβ} β
{Mβ : Type wβ} β
[inst : Semiring R] β
[inst_1 : (i : ΞΉ) β AddCommMonoid (Mβ i)] β
[inst_2 : AddCommMonoid Mβ] β
[inst_3 : (i : ΞΉ) β Module R (Mβ i)] β
[inst_4 : Module R Mβ] β
[inst_5 : (i : ΞΉ) β TopologicalSpace (Mβ i)] β
[inst_6 : TopologicalSpace Mβ] β Inhabited (ContinuousMultilinearMap R Mβ Mβ)
|
_private.Mathlib.Algebra.Category.Ring.Basic.0.CommSemiRingCat.Hom.mk
|
Mathlib.Algebra.Category.Ring.Basic
|
{R S : CommSemiRingCat} β (βR β+* βS) β R.Hom S
|
CategoryTheory.ComposableArrows.sc'._proof_7
|
Mathlib.Algebra.Homology.ExactSequence
|
β {n : β} (i j k : β), i + 1 = j β j + 1 = k β k β€ n β i < n + 1
|
CategoryTheory.StructuredArrow.ofCommaSndEquivalenceInverse_map_right_right
|
Mathlib.CategoryTheory.Comma.Over.Basic
|
β {T : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} T] {D : Type uβ} [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
{C : Type uβ} [inst_2 : CategoryTheory.Category.{vβ, uβ} C] (F : CategoryTheory.Functor C T)
(G : CategoryTheory.Functor D T) (c : C) {X Y : CategoryTheory.Comma ((CategoryTheory.Under.forget c).comp F) G}
(g : X βΆ Y), ((CategoryTheory.StructuredArrow.ofCommaSndEquivalenceInverse F G c).map g).right.right = g.right
|
Aesop.MVarCluster.setState
|
Aesop.Tree.Data
|
Aesop.NodeState β Aesop.MVarCluster β Aesop.MVarCluster
|
sup_congr_left
|
Mathlib.Order.Lattice
|
β {Ξ± : Type u} [inst : SemilatticeSup Ξ±] {a b c : Ξ±}, b β€ a β c β c β€ a β b β a β b = a β c
|
ONote.NFBelow.rec
|
Mathlib.SetTheory.Ordinal.Notation
|
β {motive : (a : ONote) β (a_1 : Ordinal.{0}) β a.NFBelow a_1 β Prop},
(β {b : Ordinal.{0}}, motive 0 b β―) β
(β {e : ONote} {n : β+} {a : ONote} {eb b : Ordinal.{0}} (a_1 : e.NFBelow eb) (a_2 : a.NFBelow e.repr)
(a_3 : e.repr < b), motive e eb a_1 β motive a e.repr a_2 β motive (e.oadd n a) b β―) β
β {a : ONote} {a_1 : Ordinal.{0}} (t : a.NFBelow a_1), motive a a_1 t
|
Std.TreeSet.Raw.min?_toList
|
Std.Data.TreeSet.Raw.Lemmas
|
β {Ξ± : Type u} {cmp : Ξ± β Ξ± β Ordering} {t : Std.TreeSet.Raw Ξ± cmp} [Std.TransCmp cmp] [inst : Min Ξ±] [inst_1 : LE Ξ±]
[Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin Ξ±] [Std.LawfulOrderLeftLeaningMin Ξ±] [Std.LawfulEqCmp cmp],
t.WF β t.toList.min? = t.min?
|
Std.DTreeMap.Raw.get!_union_of_not_mem_left
|
Std.Data.DTreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.DTreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
tβ.WF β tβ.WF β β {k : Ξ±} [inst_1 : Inhabited (Ξ² k)], k β tβ β (tβ βͺ tβ).get! k = tβ.get! k
|
Std.DTreeMap.Raw.get_alter_self
|
Std.Data.DTreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.DTreeMap.Raw Ξ± Ξ² cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] (h : t.WF) {k : Ξ±} {f : Option (Ξ² k) β Option (Ξ² k)} {hc : k β t.alter k f},
(t.alter k f).get k hc = (f (t.get? k)).get β―
|
Fin.consEquivL._proof_3
|
Mathlib.Topology.Algebra.Module.Equiv
|
β {n : β} (M : Fin n.succ β Type u_1) [inst : (i : Fin n.succ) β TopologicalSpace (M i)],
Continuous fun a => Fin.cons (id a).1 a.2
|
CategoryTheory.Functor.PreservesRightKanExtension.mk_of_preserves_isRightKanExtension
|
Mathlib.CategoryTheory.Functor.KanExtension.Preserves
|
β {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B)
(L : CategoryTheory.Functor A C) (F' : CategoryTheory.Functor C B) (Ξ± : L.comp F' βΆ F) [F'.IsRightKanExtension Ξ±],
(F'.comp G).IsRightKanExtension
(CategoryTheory.CategoryStruct.comp (L.associator F' G).inv (CategoryTheory.Functor.whiskerRight Ξ± G)) β
G.PreservesRightKanExtension F L
|
_private.Mathlib.Analysis.SpecialFunctions.Log.NegMulLog.0.Real.continuous_mul_log._simp_1_2
|
Mathlib.Analysis.SpecialFunctions.Log.NegMulLog
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {f : Ξ± β Ξ²} {xβ xβ : Filter Ξ±} {y : Filter Ξ²},
Filter.Tendsto f (xβ β xβ) y = (Filter.Tendsto f xβ y β§ Filter.Tendsto f xβ y)
|
Lean.Grind.instAddIntIi
|
Init.GrindInstances.ToInt
|
Lean.Grind.ToInt.Add β€ Lean.Grind.IntInterval.ii
|
_private.Init.Data.BitVec.Bitblast.0.BitVec.getElem_sdiv.match_1.eq_4
|
Init.Data.BitVec.Bitblast
|
β (motive : Bool β Bool β Sort u_1) (h_1 : Unit β motive false false) (h_2 : Unit β motive false true)
(h_3 : Unit β motive true false) (h_4 : Unit β motive true true),
(match true, true with
| false, false => h_1 ()
| false, true => h_2 ()
| true, false => h_3 ()
| true, true => h_4 ()) =
h_4 ()
|
Int.noConfusionType
|
Init.Data.Int.Basic
|
Sort u β β€ β β€ β Sort u
|
_private.Init.Data.Vector.Algebra.0.Vector.add_hmul._proof_1_2
|
Init.Data.Vector.Algebra
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {Ξ³ : Type u_1} {n : β} [inst : Add Ξ±] [inst_1 : Add Ξ³] [inst_2 : HMul Ξ± Ξ² Ξ³],
(β (c d : Ξ±) (x : Ξ²), (c + d) * x = c * x + d * x) β β (c d : Ξ±) (xs : Vector Ξ² n), (c + d) * xs = c * xs + d * xs
|
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_flatMap_eq_false._simp_1_1
|
Std.Data.Internal.List.Associative
|
β {x y : Bool}, ((x || y) = false) = (x = false β§ y = false)
|
CategoryTheory.Functor.IsDense.mk
|
Mathlib.CategoryTheory.Functor.KanExtension.Dense
|
β {C : Type uβ} {D : Type uβ} [inst : CategoryTheory.Category.{vβ, uβ} C] [inst_1 : CategoryTheory.Category.{vβ, uβ} D]
{F : CategoryTheory.Functor C D}, (β (Y : D), F.isDenseAt Y) β F.IsDense
|
Finset.disjiUnion_cons
|
Mathlib.Data.Finset.Union
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} (a : Ξ±) (s : Finset Ξ±) (ha : a β s) (f : Ξ± β Finset Ξ²)
(H : (β(Finset.cons a s ha)).PairwiseDisjoint f),
(Finset.cons a s ha).disjiUnion f H = (f a).disjUnion (s.disjiUnion f β―) β―
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.