name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
QuaternionAlgebra.Basis.k_compHom
|
Mathlib.Algebra.QuaternionBasis
|
β {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {cβ cβ cβ : R} (q : QuaternionAlgebra.Basis A cβ cβ cβ) (F : A ββ[R] B),
(q.compHom F).k = F q.k
|
Std.Tactic.BVDecide.BVExpr.bitblast.goCache._mutual._proof_53
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr
|
β (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (w w_1 n : β) (h : w = w_1 * n)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (expr : aig_1.RefVec w_1)
(haig : aig.decls.size β€ { aig := aig_1, vec := expr }.aig.decls.size),
(ββ¨{ aig := aig_1, vec := expr }, haigβ©).aig.decls.size β€
(Std.Tactic.BVDecide.BVExpr.bitblast.blastReplicate (ββ¨{ aig := aig_1, vec := expr }, haigβ©).aig
{ w := w_1, n := n, inner := expr, h := h }).aig.decls.size
|
Std.Time.Month.Ordinal.january
|
Std.Time.Date.Unit.Month
|
Std.Time.Month.Ordinal
|
Aesop.RuleResult.ctorIdx
|
Aesop.Search.Expansion
|
Aesop.RuleResult β β
|
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd._proof_4
|
Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add
|
β {w : β}, β curr < w, curr + 1 β€ w
|
CategoryTheory.ShortComplex.LeftHomologyData.ofEpiOfIsIsoOfMono'._proof_4
|
Mathlib.Algebra.Homology.ShortComplex.LeftHomology
|
β {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{Sβ Sβ : CategoryTheory.ShortComplex C} (Ο : Sβ βΆ Sβ) (h : Sβ.LeftHomologyData) [CategoryTheory.Epi Ο.Οβ]
[inst_3 : CategoryTheory.IsIso Ο.Οβ]
(wi : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv Ο.Οβ)) Sβ.g = 0)
(hi :
CategoryTheory.Limits.IsLimit
(CategoryTheory.Limits.KernelFork.ofΞΉ (CategoryTheory.CategoryStruct.comp h.i (CategoryTheory.inv Ο.Οβ)) wi)),
hi.lift (CategoryTheory.Limits.KernelFork.ofΞΉ Sβ.f β―) = CategoryTheory.CategoryStruct.comp Ο.Οβ h.f' β
β {Z' : C} (x : h.K βΆ Z'),
CategoryTheory.CategoryStruct.comp (hi.lift (CategoryTheory.Limits.KernelFork.ofΞΉ Sβ.f β―)) x = 0 β
CategoryTheory.CategoryStruct.comp h.f' x = 0
|
Subsemiring.instTop._proof_2
|
Mathlib.Algebra.Ring.Subsemiring.Defs
|
β {R : Type u_1} [inst : NonAssocSemiring R], 0 β β€.carrier
|
_private.Mathlib.Algebra.Module.Submodule.Lattice.0.Submodule.mem_finsetInf._simp_1_2
|
Mathlib.Algebra.Module.Submodule.Lattice
|
β {Ξ± : Type u} {ΞΉ : Sort v} {x : Ξ±} {s : ΞΉ β Set Ξ±}, (x β β i, s i) = β (i : ΞΉ), x β s i
|
RootPairing.Hom.comp._proof_3
|
Mathlib.LinearAlgebra.RootSystem.Hom
|
β {ΞΉ : Type u_6} {R : Type u_4} {M : Type u_7} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ΞΉβ : Type u_8} {Mβ : Type u_9} {Nβ : Type u_5}
{ΞΉβ : Type u_1} {Mβ : Type u_10} {Nβ : Type u_3} [inst_5 : AddCommGroup Mβ] [inst_6 : Module R Mβ]
[inst_7 : AddCommGroup Nβ] [inst_8 : Module R Nβ] [inst_9 : AddCommGroup Mβ] [inst_10 : Module R Mβ]
[inst_11 : AddCommGroup Nβ] [inst_12 : Module R Nβ] {P : RootPairing ΞΉ R M N} {Pβ : RootPairing ΞΉβ R Mβ Nβ}
{Pβ : RootPairing ΞΉβ R Mβ Nβ} (g : Pβ.Hom Pβ) (f : P.Hom Pβ),
β(f.coweightMap ββ g.coweightMap) β βPβ.coroot = βP.coroot β β(f.indexEquiv.trans g.indexEquiv).symm
|
SchwartzMap.compCLM._proof_3
|
Mathlib.Analysis.Distribution.SchwartzSpace
|
β (k n l : β) (C : β),
0 β€ C β
β (kg : β) (Cg : β), 1 β€ 1 + Cg β 0 β€ (1 + Cg) ^ (k + l * n) * ((C + 1) ^ n * βn.factorial * 2 ^ (kg * (k + l * n)))
|
CategoryTheory.MorphismProperty.precoverage_monotone
|
Mathlib.CategoryTheory.Sites.MorphismProperty
|
β {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C},
P β€ Q β P.precoverage β€ Q.precoverage
|
RingHom.formallyEtale_algebraMap
|
Mathlib.RingTheory.Etale.Basic
|
β {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(algebraMap R S).FormallyEtale β Algebra.FormallyEtale R S
|
Order.Ideal.coe_sup_eq
|
Mathlib.Order.Ideal
|
β {P : Type u_1} [inst : DistribLattice P] {I J : Order.Ideal P}, β(I β J) = {x | β i β I, β j β J, x = i β j}
|
ContinuousMultilinearMap.smulRight_apply
|
Mathlib.Topology.Algebra.Module.Multilinear.Basic
|
β {R : Type u} {ΞΉ : Type v} {Mβ : ΞΉ β Type wβ} {Mβ : Type wβ} [inst : CommSemiring 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 : TopologicalSpace R] [inst_6 : (i : ΞΉ) β TopologicalSpace (Mβ i)]
[inst_7 : TopologicalSpace Mβ] [inst_8 : ContinuousSMul R Mβ] (f : ContinuousMultilinearMap R Mβ R) (z : Mβ)
(a : (i : ΞΉ) β Mβ i), (f.smulRight z) a = f a β’ z
|
Int.negOnePow_two_mul_add_one
|
Mathlib.Algebra.Ring.NegOnePow
|
β (n : β€), (2 * n + 1).negOnePow = -1
|
Lean.Server.Watchdog.CallHierarchyItemData
|
Lean.Server.Watchdog
|
Type
|
Std.Time.FormatPart.noConfusionType
|
Std.Time.Format.Basic
|
Sort u β Std.Time.FormatPart β Std.Time.FormatPart β Sort u
|
Nat.testBit_ofBits_lt
|
Batteries.Data.Nat.Lemmas
|
β {n : β} (f : Fin n β Bool) (i : β) (h : i < n), (Nat.ofBits f).testBit i = f β¨i, hβ©
|
HahnSeries.leadingCoeff_abs
|
Mathlib.RingTheory.HahnSeries.Lex
|
β {Ξ : Type u_1} {R : Type u_2} [inst : LinearOrder Ξ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[IsOrderedAddMonoid R] (x : Lex (HahnSeries Ξ R)), (ofLex |x|).leadingCoeff = |(ofLex x).leadingCoeff|
|
isOpenMap_sigmaMk
|
Mathlib.Topology.Constructions
|
β {ΞΉ : Type u_5} {Ο : ΞΉ β Type u_7} [inst : (i : ΞΉ) β TopologicalSpace (Ο i)] {i : ΞΉ}, IsOpenMap (Sigma.mk i)
|
SimpleGraph.TripartiteFromTriangles.NoAccidental.mk._flat_ctor
|
Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} {Ξ³ : Type u_3} {t : Finset (Ξ± Γ Ξ² Γ Ξ³)},
(β β¦a a' : Ξ±β¦ β¦b b' : Ξ²β¦ β¦c c' : Ξ³β¦, (a', b, c) β t β (a, b', c) β t β (a, b, c') β t β a = a' β¨ b = b' β¨ c = c') β
SimpleGraph.TripartiteFromTriangles.NoAccidental t
|
Int64.right_eq_add
|
Init.Data.SInt.Lemmas
|
β {a b : Int64}, b = a + b β a = 0
|
Std.TreeMap.Raw.mem_union_of_left
|
Std.Data.TreeMap.Raw.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {cmp : Ξ± β Ξ± β Ordering} {tβ tβ : Std.TreeMap.Raw Ξ± Ξ² cmp} [Std.TransCmp cmp],
tβ.WF β tβ.WF β β {k : Ξ±}, k β tβ β k β tβ βͺ tβ
|
_private.Mathlib.Computability.TuringMachine.0.Turing.TM2.stepAux.match_1.splitter
|
Mathlib.Computability.TuringMachine
|
{K : Type u_1} β
{Ξ : K β Type u_2} β
{Ξ : Type u_3} β
{Ο : Type u_4} β
(motive : Turing.TM2.Stmt Ξ Ξ Ο β Ο β ((k : K) β List (Ξ k)) β Sort u_5) β
(x : Turing.TM2.Stmt Ξ Ξ Ο) β
(x_1 : Ο) β
(x_2 : (k : K) β List (Ξ k)) β
((k : K) β
(f : Ο β Ξ k) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.push k f q) v S) β
((k : K) β
(f : Ο β Option (Ξ k) β Ο) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.peek k f q) v S) β
((k : K) β
(f : Ο β Option (Ξ k) β Ο) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.pop k f q) v S) β
((a : Ο β Ο) β
(q : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.load a q) v S) β
((f : Ο β Bool) β
(qβ qβ : Turing.TM2.Stmt Ξ Ξ Ο) β
(v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.branch f qβ qβ) v S) β
((f : Ο β Ξ) β (v : Ο) β (S : (k : K) β List (Ξ k)) β motive (Turing.TM2.Stmt.goto f) v S) β
((v : Ο) β (S : (k : K) β List (Ξ k)) β motive Turing.TM2.Stmt.halt v S) β motive x x_1 x_2
|
CompletelyDistribLattice.top_sdiff
|
Mathlib.Order.CompleteBooleanAlgebra
|
β {Ξ± : Type u} [self : CompletelyDistribLattice Ξ±] (a : Ξ±), β€ \ a = οΏ’a
|
IsInvariantSubring.toMulSemiringAction._proof_1
|
Mathlib.Algebra.Ring.Action.Invariant
|
β (M : Type u_2) {R : Type u_1} [inst : Monoid M] [inst_1 : Ring R] [inst_2 : MulSemiringAction M R] (S : Subring R)
[IsInvariantSubring M S] (m : M) (x : β₯S), m β’ βx β S
|
Lean.Widget.GetInteractiveDiagnosticsParams.mk.sizeOf_spec
|
Lean.Server.FileWorker.WidgetRequests
|
β (lineRange? : Option Lean.Lsp.LineRange), sizeOf { lineRange? := lineRange? } = 1 + sizeOf lineRange?
|
Std.Net.SocketAddress
|
Std.Net.Addr
|
Type
|
IsClosedMap.specializingMap
|
Mathlib.Topology.Inseparable
|
β {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X β Y},
IsClosedMap f β SpecializingMap f
|
CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc_comp_assoc
|
Mathlib.CategoryTheory.Abelian.Projective.Resolution
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C}
{P : CategoryTheory.ProjectiveResolution Y} {Q : CategoryTheory.ProjectiveResolution Z} (f : P.complex βΆ Q.complex)
(n : β) (g : P.complex.X n βΆ Q.complex.X (n + 1)) (g' : P.complex.X (n + 1) βΆ Q.complex.X (n + 2))
(w :
f.f (n + 1) =
CategoryTheory.CategoryStruct.comp (P.complex.d (n + 1) n) g +
CategoryTheory.CategoryStruct.comp g' (Q.complex.d (n + 2) (n + 1)))
{Z_1 : C} (h : Q.complex.X (n + 2) βΆ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.liftHomotopyZeroSucc f n g g' w)
(CategoryTheory.CategoryStruct.comp (Q.complex.d (n + 3) (n + 2)) h) =
CategoryTheory.CategoryStruct.comp
(f.f (n + 2) - CategoryTheory.CategoryStruct.comp (P.complex.d (n + 2) (n + 1)) g') h
|
CategoryTheory.Functor.IsEventuallyConstantFrom.isIso_ΞΉ_of_isColimit'
|
Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant
|
β {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C} {iβ : J},
F.IsEventuallyConstantFrom iβ β
β [CategoryTheory.IsFiltered J] {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(j : J) (ΞΉ : iβ βΆ j), CategoryTheory.IsIso (c.ΞΉ.app j)
|
_private.Lean.Syntax.0.Lean.Syntax.findStack?.go.match_3
|
Lean.Syntax
|
(motive : Option (Option Lean.Syntax.Stack) β Sort u_1) β
(x : Option (Option Lean.Syntax.Stack)) β
(Unit β motive none) β ((a : Option Lean.Syntax.Stack) β motive (some a)) β motive x
|
PUnit.inv_eq
|
Mathlib.Algebra.Group.PUnit
|
β (x : PUnit.{u_1 + 1}), xβ»ΒΉ = PUnit.unit
|
CategoryTheory.Functor.mapCoconeβ_pt
|
Mathlib.CategoryTheory.Limits.Preserves.Bifunctor
|
β {Jβ : Type u_1} {Jβ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} Jβ]
[inst_1 : CategoryTheory.Category.{v_2, u_2} Jβ] {Cβ : Type u_3} {Cβ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{v_3, u_3} Cβ] [inst_3 : CategoryTheory.Category.{v_4, u_4} Cβ]
[inst_4 : CategoryTheory.Category.{v_5, u_5} C] (G : CategoryTheory.Functor Cβ (CategoryTheory.Functor Cβ C))
{Kβ : CategoryTheory.Functor Jβ Cβ} {Kβ : CategoryTheory.Functor Jβ Cβ} (cβ : CategoryTheory.Limits.Cocone Kβ)
(cβ : CategoryTheory.Limits.Cocone Kβ), (G.mapCoconeβ cβ cβ).pt = (G.obj cβ.pt).obj cβ.pt
|
CauSeq.equiv_lim
|
Mathlib.Algebra.Order.CauSeq.Completion
|
β {Ξ± : Type u_1} [inst : Field Ξ±] [inst_1 : LinearOrder Ξ±] [inst_2 : IsStrictOrderedRing Ξ±] {Ξ² : Type u_2}
[inst_3 : Ring Ξ²] {abv : Ξ² β Ξ±} [inst_4 : IsAbsoluteValue abv] [inst_5 : CauSeq.IsComplete Ξ² abv] (s : CauSeq Ξ² abv),
s β CauSeq.const abv s.lim
|
MontelSpace.rec
|
Mathlib.Analysis.LocallyConvex.Montel
|
{π : Type u_4} β
{E : Type u_5} β
[inst : SeminormedRing π] β
[inst_1 : Zero E] β
[inst_2 : SMul π E] β
[inst_3 : TopologicalSpace E] β
{motive : MontelSpace π E β Sort u} β
((heine_borel : β (s : Set E), IsClosed s β Bornology.IsVonNBounded π s β IsCompact s) β motive β―) β
(t : MontelSpace π E) β motive t
|
Subgroup.pi
|
Mathlib.Algebra.Group.Subgroup.Basic
|
{Ξ· : Type u_7} β
{f : Ξ· β Type u_8} β [inst : (i : Ξ·) β Group (f i)] β Set Ξ· β ((i : Ξ·) β Subgroup (f i)) β Subgroup ((i : Ξ·) β f i)
|
Set.zero_notMem_sub_iff
|
Mathlib.Algebra.Group.Pointwise.Set.Basic
|
β {Ξ± : Type u_2} [inst : AddGroup Ξ±] {s t : Set Ξ±}, 0 β s - t β Disjoint s t
|
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.processImplicitArg
|
Lean.Elab.App
|
Lean.Name β Lean.Elab.Term.ElabAppArgs.M Lean.Expr
|
List.Subset.antisymm_of_sortedLT
|
Mathlib.Data.List.Sort
|
β {Ξ± : Type u_1} [inst : PartialOrder Ξ±] {lβ lβ : List Ξ±}, lβ β lβ β lβ β lβ β lβ.SortedLT β lβ.SortedLT β lβ = lβ
|
Aesop.GoalWithMVars.recOn
|
Aesop.Script.GoalWithMVars
|
{motive : Aesop.GoalWithMVars β Sort u} β
(t : Aesop.GoalWithMVars) β
((goal : Lean.MVarId) β (mvars : Std.HashSet Lean.MVarId) β motive { goal := goal, mvars := mvars }) β motive t
|
Std.ExtDTreeMap.getKey?_maxKey
|
Std.Data.ExtDTreeMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Ξ± β Type v} {cmp : Ξ± β Ξ± β Ordering} {t : Std.ExtDTreeMap Ξ± Ξ² cmp} [inst : Std.TransCmp cmp]
{he : t β β
}, t.getKey? (t.maxKey he) = some (t.maxKey he)
|
Concept.extent_sup
|
Mathlib.Order.Concept
|
β {Ξ± : Type u_2} {Ξ² : Type u_3} {r : Ξ± β Ξ² β Prop} (c d : Concept Ξ± Ξ² r),
(c β d).extent = lowerPolar r (c.intent β© d.intent)
|
SimpleGraph.Subgraph._sizeOf_1
|
Mathlib.Combinatorics.SimpleGraph.Subgraph
|
{V : Type u} β {G : SimpleGraph V} β [SizeOf V] β G.Subgraph β β
|
Function.Surjective.addAction._proof_1
|
Mathlib.Algebra.Group.Action.Defs
|
β {M : Type u_2} {Ξ± : Type u_3} {Ξ² : Type u_1} [inst : AddMonoid M] [inst_1 : AddAction M Ξ±] [inst_2 : VAdd M Ξ²]
(f : Ξ± β Ξ²),
Function.Surjective f β
(β (c : M) (x : Ξ±), f (c +α΅₯ x) = c +α΅₯ f x) β β (a a_1 : M) (y : Ξ²), (a + a_1) +α΅₯ y = a +α΅₯ a_1 +α΅₯ y
|
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitDeclAux.match_1
|
Lean.Compiler.IR.EmitLLVM
|
(motive : Lean.IR.Decl β Sort u_1) β
(d : Lean.IR.Decl) β
((f : Lean.IR.FunId) β
(xs : Array Lean.IR.Param) β
(t : Lean.IR.IRType) β
(b : Lean.IR.FnBody) β (info : Lean.IR.DeclInfo) β motive (Lean.IR.Decl.fdecl f xs t b info)) β
((x : Lean.IR.Decl) β motive x) β motive d
|
Matrix.center_eq_range
|
Mathlib.Data.Matrix.Basis
|
β {n : Type u_3} (R : Type u_5) [inst : DecidableEq n] [inst_1 : Fintype n] [inst_2 : CommSemiring R],
Set.center (Matrix n n R) = Set.range β(Matrix.scalar n)
|
AddMonoidHom.range_eq_top_of_surjective
|
Mathlib.Algebra.Group.Subgroup.Ker
|
β {G : Type u_1} [inst : AddGroup G] {N : Type u_7} [inst_1 : AddGroup N] (f : G β+ N),
Function.Surjective βf β f.range = β€
|
Real.convergent_zero
|
Mathlib.NumberTheory.DiophantineApproximation.Basic
|
β (ΞΎ : β), ΞΎ.convergent 0 = ββΞΎβ
|
CategoryTheory.Bicategory.conjugateIsoEquiv_apply_inv
|
Mathlib.CategoryTheory.Bicategory.Adjunction.Mate
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {c d : B} {lβ lβ : c βΆ d} {rβ rβ : d βΆ c}
(adjβ : CategoryTheory.Bicategory.Adjunction lβ rβ) (adjβ : CategoryTheory.Bicategory.Adjunction lβ rβ) (Ξ± : lβ β
lβ),
((CategoryTheory.Bicategory.conjugateIsoEquiv adjβ adjβ) Ξ±).inv =
(CategoryTheory.Bicategory.conjugateEquiv adjβ adjβ) Ξ±.inv
|
mapsTo_gaugeRescale_closure
|
Mathlib.Analysis.Convex.GaugeRescale
|
β {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module β E] [inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousSMul β E] {s t : Set E},
Convex β s β s β nhds 0 β Convex β t β 0 β t β Absorbent β t β Set.MapsTo (gaugeRescale s t) (closure s) (closure t)
|
Std.HashMap.mem_alter_of_beq
|
Std.Data.HashMap.Lemmas
|
β {Ξ± : Type u} {Ξ² : Type v} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {m : Std.HashMap Ξ± Ξ²} [EquivBEq Ξ±] [LawfulHashable Ξ±]
{k k' : Ξ±} {f : Option Ξ² β Option Ξ²}, (k == k') = true β (k' β m.alter k f β (f m[k]?).isSome = true)
|
Monotone.forall
|
Mathlib.Order.BoundedOrder.Monotone
|
β {Ξ± : Type u} {Ξ² : Type v} [inst : Preorder Ξ±] {P : Ξ² β Ξ± β Prop},
(β (x : Ξ²), Monotone (P x)) β Monotone fun y => β (x : Ξ²), P x y
|
Std.Time.Duration.mk._flat_ctor
|
Std.Time.Duration
|
(second : Std.Time.Second.Offset) β
(nano : Std.Time.Nanosecond.Span) β second.val β₯ 0 β§ βnano β₯ 0 β¨ second.val β€ 0 β§ βnano β€ 0 β Std.Time.Duration
|
FBinopElab.instInhabitedSRec
|
Mathlib.Tactic.FBinop
|
Inhabited FBinopElab.SRec
|
CategoryTheory.Meq.congr_apply
|
Mathlib.CategoryTheory.Sites.ConcreteSheafification
|
β {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D] {FD : D β D β Type u_1} {CD : D β Type t}
[inst_2 : (X Y : D) β FunLike (FD X Y) (CD X) (CD Y)] [inst_3 : CategoryTheory.ConcreteCategory D FD] {X : C}
{P : CategoryTheory.Functor Cα΅α΅ D} {S : J.Cover X} (x : CategoryTheory.Meq P S) {Y : C} {f g : Y βΆ X} (h : f = g)
(hf : (βS).arrows f), βx { Y := Y, f := f, hf := hf } = βx { Y := Y, f := g, hf := β― }
|
Std.ExtDHashMap.get_union_of_not_mem_left
|
Std.Data.ExtDHashMap.Lemmas
|
β {Ξ± : Type u} {x : BEq Ξ±} {x_1 : Hashable Ξ±} {Ξ² : Ξ± β Type v} {mβ mβ : Std.ExtDHashMap Ξ± Ξ²} [inst : LawfulBEq Ξ±]
{k : Ξ±} (not_mem : k β mβ) {h' : k β mβ βͺ mβ}, (mβ βͺ mβ).get k h' = mβ.get k β―
|
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.core
|
Lean.Meta.Tactic.Grind.Arith.Linear.Types
|
Lean.Expr β
Lean.Expr β
Lean.Meta.Grind.Arith.Linear.LinExpr β
Lean.Meta.Grind.Arith.Linear.LinExpr β Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof
|
CategoryTheory.Bicategory.Adjunction.mk.injEq
|
Mathlib.CategoryTheory.Bicategory.Adjunction.Basic
|
β {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a βΆ b} {g : b βΆ a}
(unit : CategoryTheory.CategoryStruct.id a βΆ CategoryTheory.CategoryStruct.comp f g)
(counit : CategoryTheory.CategoryStruct.comp g f βΆ CategoryTheory.CategoryStruct.id b)
(left_triangle :
autoParam
(CategoryTheory.Bicategory.leftZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit counit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam)
(unit_1 : CategoryTheory.CategoryStruct.id a βΆ CategoryTheory.CategoryStruct.comp f g)
(counit_1 : CategoryTheory.CategoryStruct.comp g f βΆ CategoryTheory.CategoryStruct.id b)
(left_triangle_1 :
autoParam
(CategoryTheory.Bicategory.leftZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor f).hom
(CategoryTheory.Bicategory.rightUnitor f).inv)
CategoryTheory.Bicategory.Adjunction.left_triangle._autoParam)
(right_triangle_1 :
autoParam
(CategoryTheory.Bicategory.rightZigzag unit_1 counit_1 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor g).hom
(CategoryTheory.Bicategory.leftUnitor g).inv)
CategoryTheory.Bicategory.Adjunction.right_triangle._autoParam),
({ unit := unit, counit := counit, left_triangle := left_triangle, right_triangle := right_triangle } =
{ unit := unit_1, counit := counit_1, left_triangle := left_triangle_1, right_triangle := right_triangle_1 }) =
(unit = unit_1 β§ counit = counit_1)
|
Mathlib.Tactic.ITauto.Proof.em
|
Mathlib.Tactic.ITauto
|
Bool β Lean.Name β Mathlib.Tactic.ITauto.Proof
|
Finset.isPWO_sup
|
Mathlib.Order.WellFoundedSet
|
β {ΞΉ : Type u_1} {Ξ± : Type u_2} [inst : Preorder Ξ±] (s : Finset ΞΉ) {f : ΞΉ β Set Ξ±},
(s.sup f).IsPWO β β i β s, (f i).IsPWO
|
Lean.NameMapExtension.find?
|
Batteries.Lean.NameMapAttribute
|
{Ξ± : Type} β Lean.NameMapExtension Ξ± β Lean.Environment β Lean.Name β Option Ξ±
|
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbs.sizeOf_spec
|
Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr
|
sizeOf Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.natAbsβ = 1
|
CategoryTheory.ComonObj.comul
|
Mathlib.CategoryTheory.Monoidal.Comon_
|
{C : Type uβ} β
{inst : CategoryTheory.Category.{vβ, uβ} C} β
{inst_1 : CategoryTheory.MonoidalCategory C} β
{X : C} β [self : CategoryTheory.ComonObj X] β X βΆ CategoryTheory.MonoidalCategoryStruct.tensorObj X X
|
PointedCone.mem_closure
|
Mathlib.Analysis.Convex.Cone.Closure
|
β {π : Type u_1} [inst : Semiring π] [inst_1 : PartialOrder π] [inst_2 : IsOrderedRing π] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module π E]
[inst_7 : ContinuousConstSMul π E] {K : PointedCone π E} {a : E}, a β K.closure β a β closure βK
|
Continuous.fourier_inversion
|
Mathlib.Analysis.Fourier.Inversion
|
β {V : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace β V]
[inst_2 : MeasurableSpace V] [inst_3 : BorelSpace V] [inst_4 : FiniteDimensional β V] [inst_5 : NormedAddCommGroup E]
[inst_6 : NormedSpace β E] {f : V β E} [CompleteSpace E],
Continuous f β
MeasureTheory.Integrable f MeasureTheory.volume β
MeasureTheory.Integrable (FourierTransform.fourier f) MeasureTheory.volume β
FourierTransformInv.fourierInv (FourierTransform.fourier f) = f
|
SeparationQuotient.instRing._proof_12
|
Mathlib.Topology.Algebra.SeparationQuotient.Basic
|
β {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R] (x : R),
SeparationQuotient.mk (-x) = -SeparationQuotient.mk x
|
Prod.instBornology._proof_1
|
Mathlib.Topology.Bornology.Constructions
|
β {Ξ± : Type u_1} {Ξ² : Type u_2} [inst : Bornology Ξ±] [inst_1 : Bornology Ξ²],
(Bornology.cobounded Ξ±).coprod (Bornology.cobounded Ξ²) β€ Filter.cofinite
|
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Removal.0.Mathlib.Meta.Positivity.evalTriangleRemovalBound.match_4
|
Mathlib.Combinatorics.SimpleGraph.Triangle.Removal
|
(Ξ± : Q(Type)) β
(_zΞ± : Q(Zero Β«$Ξ±Β»)) β
(_pΞ± : Q(PartialOrder Β«$Ξ±Β»)) β
(Ξ΅ : Q(β)) β
(motive : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) Ξ΅ β Sort u_1) β
(__discr : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) Ξ΅) β
((hΞ΅ : Q(0 < Β«$Ρ»)) β motive (Mathlib.Meta.Positivity.Strictness.positive hΞ΅)) β
((x : Mathlib.Meta.Positivity.Strictness q(inferInstance) q(inferInstance) Ξ΅) β motive x) β motive __discr
|
Lean.Compiler.LCNF.instTraverseFVarArg
|
Lean.Compiler.LCNF.FVarUtil
|
Lean.Compiler.LCNF.TraverseFVar Lean.Compiler.LCNF.Arg
|
Nat.mem_divisors_self
|
Mathlib.NumberTheory.Divisors
|
β (n : β), n β 0 β n β n.divisors
|
CochainComplex.mappingCone.Ξ΄_descCochain._proof_2
|
Mathlib.Algebra.Homology.HomotopyCategory.MappingCone
|
β {n : β€} (n' : β€), n + 1 = n' β 1 + n = n'
|
AlgebraicGeometry.Scheme.Cover.Over
|
Mathlib.AlgebraicGeometry.Cover.Over
|
(S : AlgebraicGeometry.Scheme) β
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} β
[P.IsStableUnderBaseChange] β
[AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] β
{X : AlgebraicGeometry.Scheme} β
[X.Over S] β AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X β Type (max u u_1)
|
Ordering.swap.eq_3
|
Std.Data.DTreeMap.Internal.Model
|
Ordering.gt.swap = Ordering.lt
|
ValuativeRel.ValueGroupWithZero.exact
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
β {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x y : R} {t s : β₯(ValuativeRel.posSubmonoid R)},
ValuativeRel.ValueGroupWithZero.mk x t = ValuativeRel.ValueGroupWithZero.mk y s β x * βs β€α΅₯ y * βt β§ y * βt β€α΅₯ x * βs
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.