name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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) → ∀ (x y : M) (b : β), (x + y) +ᵥ b = x +ᵥ y +ᵥ b |
_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 := ⋯ } |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.SimpleGroundValue.uint8.sizeOf_spec | Lean.Compiler.IR.SimpleGroundExpr | ∀ (val : UInt8), sizeOf (Lean.IR.SimpleGroundValue.uint8✝ val) = 1 + sizeOf val |
CategoryTheory.Limits.FormalCoproduct.cechFunctor | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteProducts C] →
CategoryTheory.Functor (CategoryTheory.Limits.FormalCoproduct C)
(CategoryTheory.SimplicialObject (CategoryTheory.Limits.FormalCoproduct C)) |
Mathlib.Tactic.Conv.Path.brecOn | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} →
(t : Mathlib.Tactic.Conv.Path) →
((t : Mathlib.Tactic.Conv.Path) → Mathlib.Tactic.Conv.Path.below t → motive t) → motive t |
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 |
Std.Iter.foldM_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β δ : Type w} {n : Type w → Type w''} {o : Type w → Type w'''} [inst : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
[inst_6 : Monad o] [LawfulMonad o] [inst_8 : Std.IteratorLoop α Id n] [inst_9 : Std.IteratorLoop α Id o]
[Std.LawfulIteratorLoop α Id n] [Std.LawfulIteratorLoop α Id o] [inst_12 : MonadLiftT n o] [LawfulMonadLiftT n o]
{f : β → n (ULift.{w, 0} Bool)} {g : δ → β → o δ} {init : δ} {it : Std.Iter β},
Std.IterM.foldM g init (Std.Iter.filterM f it) =
Std.Iter.foldM
(fun d b => do
let __do_lift ← liftM (f b)
if __do_lift.down = true then g d b else pure d)
init it |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunctionRecurrence._unary._proof_5 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : ByteArray) (stackPos : ℕ) (hst : stackPos < pat.size) (guess : ℕ) (hg : guess < stackPos)
(this : String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝ pat (guess - 1) ⋯ < guess),
String.Slice.Pattern.Model.ForwardSliceSearcher.prefixFunction✝¹ pat (guess - 1) ⋯ < stackPos |
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 | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.TraverseFVar (Lean.Compiler.LCNF.Arg pu) |
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) |
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 |
Ordering.swap.eq_3 | Std.Data.DTreeMap.Internal.Model | Ordering.gt.swap = Ordering.lt |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.