name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Ric.pairwise_toList_le | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Ric α} [inst : LE α] [inst_1 : DecidableLE α] [LT α] [inst_3 : Std.PRange.Least? α]
[inst_4 : Std.PRange.UpwardEnumerable α] [inst_5 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_8 : Std.Rxc.IsAlwaysFinite α... | null | true |
Std.PRange.UpwardEnumerable.le_iff_lt_or_eq | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LE a b ↔ Std.PRange.UpwardEnumerable.LT a b ∨ a = b | null | true |
Matroid.Indep.diff | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → ∀ (X : Set α), M.Indep (I \ X) | **Alias** of `Matroid.Indep.sdiff`. | true |
CategoryTheory.GradedObject.mapBifunctorObjObjSingle₀Iso | Mathlib.CategoryTheory.GradedObject.Unitor | {C : Type u_1} →
{D : Type u_2} →
{I : Type u_3} →
{J : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : Zero I] →
[inst_3 : DecidableEq I] →
[inst_4 : CategoryTheory.Limits.Has... | Given `F : D ⥤ C ⥤ D`, `Y : C`, `e : F.flip.obj X ≅ 𝟭 D` and `X : GradedObject J D`,
this is the isomorphism `((mapBifunctor F J I).obj X).obj ((single₀ I).obj Y) a ≅ Y a.2`
when `a : J × I` is such that `a.2 = 0`. | true |
Nat.RecursiveIn.below.right | Mathlib.Computability.RecursiveIn | ∀ {O : Set (ℕ →. ℕ)} {motive : (a : ℕ →. ℕ) → Nat.RecursiveIn O a → Prop}, Nat.RecursiveIn.below ⋯ | null | true |
Bundle.instInnerProductSpaceReal | Mathlib.Topology.VectorBundle.Riemannian | {B : Type u_7} →
{E : B → Type u_8} →
[inst : (b : B) → TopologicalSpace (E b)] →
[inst_1 : (b : B) → AddCommGroup (E b)] →
[inst_2 : (b : B) → Module ℝ (E b)] →
[h : Bundle.RiemannianBundle E] →
[inst_3 : ∀ (b : B), IsTopologicalAddGroup (E b)] →
[inst_4 : ∀ (b :... | A fiber in a bundle satisfying the `[RiemannianBundle E]` typeclass inherits
an `InnerProductSpace ℝ` structure.
The normal priority for an instance which always applies like this one should be 100.
We use 80 as this is rather specialized, so we want other paths to be tried first typically.
As this instance is quite s... | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.heapifyDown_children_of_ge_subtree._proof_1_5 | Batteries.Data.BinaryHeap.Lemmas | ∀ {sz : ℕ} {k : Fin sz}, 2 * ↑k + 2 ≤ sz → 2 * ↑k + 1 < sz | null | false |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Iic_top._simp_1_3 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
CategoryTheory.Equivalence.cancel_counitInv_right_assoc._simp_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {W X X' Y : D} (f : W ⟶ X) (g : X ⟶ Y) (f' : W ⟶ X') (g' : X' ⟶ Y),
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g (e.counitInv.app Y)) =
CategoryThe... | null | false |
AlgCat.limitSemiring._proof_22 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections],
autoParam
(∀ (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (Categ... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_le_maxKey_insert._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Submodule.inductionOnRankAux._proof_1 | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
(N : Submodule R M), ∀ x ∈ ⊥, (∀ (c : R), ∀ y ∈ N, c • x + y = 0 → c = 0) → False | null | false |
DistribMulActionHom.mk.injEq | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_10}
[inst_2 : AddMonoid A] [inst_3 : DistribMulAction M A] {B : Type u_11} [inst_4 : AddMonoid B]
[inst_5 : DistribMulAction N B] (toMulActionHom : A →ₑ[⇑φ] B) (map_zero' : toMulActionHom.toFun 0 = 0)
(map_add' : ∀ (x y... | null | true |
Std.Internal.List.getValueCast?_eq_none | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.containsKey a l = false → Std.Internal.List.getValueCast? a l = none | null | true |
LieSubmodule.Quotient.actionAsEndoMap._proof_5 | Mathlib.Algebra.Lie.Quotient | ∀ {R : Type u_1} {L : Type u_3} {M : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M), IsScalarTower R R (M ⧸ N) | null | false |
CategoryTheory.PreOneHypercover.casesOn | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{motive : CategoryTheory.PreOneHypercover S → Sort u_1} →
(t : CategoryTheory.PreOneHypercover S) →
((toPreZeroHypercover : CategoryTheory.PreZeroHypercover S) →
(I₁ : toPreZeroHypercover.I₀ → toPreZeroHyper... | null | false |
Diffeology.IsPlot | Mathlib.Geometry.Diffeology.Basic | {X : Type u_1} → [DiffeologicalSpace X] → {n : ℕ} → (EuclideanSpace ℝ (Fin n) → X) → Prop | A map `p : EuclideanSpace ℝ (Fin n) → X` is called a plot iff it is part of the diffeology on
`X`. This is equivalent to `p` being smooth with respect to the standard diffeology on
`EuclideanSpace ℝ (Fin n)`. | true |
_private.Mathlib.Topology.LocallyFinsupp.0.Function.locallyFinsuppWithin.eq_zero_codiscreteWithin._simp_1_2 | Mathlib.Topology.LocallyFinsupp | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
Lean.Elab.Tactic.TacticParsedSnapshotInner._sizeOf_1 | Lean.Elab.Term.TermElabM | {α : Type} → [SizeOf α] → Lean.Elab.Tactic.TacticParsedSnapshotInner α → ℕ | null | false |
NumberField.mixedEmbedding.latticeBasis._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
LinearIndependent ℝ (⇑(NumberField.mixedEmbedding.commMap K) ∘ ⇑(NumberField.canonicalEmbedding.latticeBasis K)) | null | false |
_private.Init.Data.Array.Lemmas.0.Array.size_reverse.go._unary | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (_x : (as : Array α) ×' (_ : ℕ) ×' Fin as.size),
(Array.reverse.loop _x.1 _x.2.1 _x.2.2).size = _x.1.size | null | false |
Submodule.equivSubtypeMap._proof_2 | Mathlib.Algebra.Module.Submodule.Equiv | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M)
(q : Submodule R ↥p),
Function.LeftInverse (fun a => Subtype.casesOn a fun x hx => ⟨⟨x, ⋯⟩, ⋯⟩)
(LinearMap.codRestrict (Submodule.map p.subtype q) (p.subtype.domRestrict q) ⋯).toFun | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.Term.structInst._regBuiltin.Lean.Parser.Term.structInst.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
instPartialOrderEReal._aux_1 | Mathlib.Data.EReal.Basic | EReal → EReal → Prop | null | false |
CategoryTheory.FreeMonoidalCategory.Hom.id | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} → (X : CategoryTheory.FreeMonoidalCategory C) → X.Hom X | null | true |
List.mem_rtakeWhile_imp | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} {p : α → Bool} {l : List α} {x : α}, x ∈ List.rtakeWhile p l → p x = true | null | true |
Representation.equivOfIso._proof_3 | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u_2} {G : Type u_3} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{u_1, u_2, u_3} k G} (i : A ≅ B)
(x y : ↑A), (Rep.Hom.hom i.hom).toFun (x + y) = (Rep.Hom.hom i.hom).toFun x + (Rep.Hom.hom i.hom).toFun y | null | false |
_private.Mathlib.Algebra.Module.ZLattice.Covolume.0._auto_22 | Mathlib.Algebra.Module.ZLattice.Covolume | Lean.Syntax | null | false |
WeierstrassCurve.IsCharNeTwoNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | {R : Type u_1} → [CommRing R] → WeierstrassCurve R → Prop | A `WeierstrassCurve` is in normal form of characteristic ≠ 2, if its `a₁, a₃ = 0`.
In other words it is `Y² = X³ + a₂X² + a₄X + a₆`. | true |
ULift.up_lt | Mathlib.Order.ULift | ∀ {α : Type u} [inst : LT α] {a b : α}, { down := a } < { down := b } ↔ a < b | null | true |
Bundle.Trivialization.prod._proof_5 | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] {F₁ : Type u_2} [inst_1 : TopologicalSpace F₁] {E₁ : B → Type u_3}
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [inst_3 : TopologicalSpace F₂]
{E₂ : B → Type u_5} [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
(e₁ : Bundle.Trivialization... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft.go._unary._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} {aig : Std.Sat.AIG α} (input : aig.RefVec w)
(distance curr : ℕ) (hcurr : curr ≤ w) (s : aig.RefVec curr) (hcurr1 : curr < w) (hcurr2 : curr < distance % w),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.case... | null | false |
map_add_neg | Mathlib.Algebra.Group.Hom.Defs | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (a b : G), f (a + -b) = f a + -f b | Additive group homomorphisms preserve subtraction. | true |
Mathlib.Tactic.Linarith.nlinarithExtras | Mathlib.Tactic.Linarith.Preprocessing | Mathlib.Tactic.Linarith.GlobalPreprocessor | `nlinarithExtras` is the preprocessor corresponding to the `nlinarith` tactic.
* For every term `t` such that `t^2` or `t*t` appears in the input, adds a proof of `t^2 ≥ 0`
or `t*t ≥ 0`.
* For every pair of comparisons `t1 R1 0` and `t2 R2 0`, adds a proof of `t1*t2 R 0`.
This preprocessor is typically run last, af... | true |
MeasureTheory.OuterMeasure.isCaratheodory_empty | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α), m.IsCaratheodory ∅ | null | true |
CategoryTheory.ComposableArrows.isoMk₄_inv | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 4}
(app₀ : f.obj' 0 _proof_369✝ ≅ g.obj' 0 _proof_369✝)
(app₁ :
f.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₄₁₂._proof_2 ≅
g.obj' 1 CategoryTheory.ComposableArrows.Precomp.map₄₁₂._proof_2)
(ap... | null | true |
coe_mul_coe | Mathlib.Algebra.Group.Submonoid.Pointwise | ∀ {M : Type u_3} {S : Type u_4} [inst : Monoid M] [inst_1 : SetLike S M] [SubmonoidClass S M] (H : S), ↑H * ↑H = ↑H | null | true |
MeasureTheory.leastGE.eq_1 | Mathlib.Probability.Martingale.BorelCantelli | ∀ {ι : Type u_1} {Ω : Type u_2} {β : Type u_3} [inst : Preorder ι] [inst_1 : OrderBot ι] [inst_2 : InfSet ι]
[inst_3 : Preorder β] (f : ι → Ω → β) (r : β), MeasureTheory.leastGE f r = MeasureTheory.hittingAfter f (Set.Ici r) ⊥ | null | true |
_private.Lean.Meta.Sym.AbstractS.0.Lean.Meta.Sym.abstractFVarsRange._proof_1 | Lean.Meta.Sym.AbstractS | ∀ (start : ℕ) (xs : Array Lean.Expr), ∀ i < xs.size, ¬i - 1 < xs.size → False | null | false |
USize.toBitVec_ofNatLT | Init.Data.UInt.Lemmas | ∀ {n : ℕ} (hn : n < USize.size), (USize.ofNatLT n hn).toBitVec = n#'hn | null | true |
CategoryTheory.Join.mapWhiskerRight._proof_1 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_7, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_8, u_2} D] {E : Type u_5} [inst_2 : CategoryTheory.Category.{u_3, u_5} E]
{E' : Type u_6} [inst_3 : CategoryTheory.Category.{u_4, u_6} E'] {Fₗ Gₗ : CategoryTheory.Functor C E} (α : Fₗ ⟶ Gₗ)
(H : Cate... | null | false |
_private.Mathlib.Geometry.Euclidean.Sphere.Basic.0.EuclideanGeometry.Sphere.dist_center_lt_radius_of_sbtw._simp_1_1 | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
Aesop.Percent.instMul | Aesop.Percent | Mul Aesop.Percent | null | true |
Ideal.lcm_eq_inf | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {A : Type u_2} [inst : CommRing A] [inst_1 : IsDedekindDomain A] (I J : Ideal A), lcm I J = I ⊓ J | null | true |
Lean.Grind.Field.mul_inv_cancel | Init.Grind.Ring.Field | ∀ {α : Type u} [self : Lean.Grind.Field α] {a : α}, a ≠ 0 → a * a⁻¹ = 1 | The inverse of a non-zero element is a right inverse. | true |
CategoryTheory.Comma.mapLeftIso_counitIso_inv_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ : CategoryTheory.Functor A T} (i : L₁ ≅ L₂) (X : CategoryTheory.Comma L₂ R),
((CategoryTheory.... | null | true |
Nat.min_zero | Init.Data.Nat.MinMax | ∀ (a : ℕ), min a 0 = 0 | null | true |
_private.Mathlib.Order.Prod.Lex.Basic.0.Prod.Lex.toLex_le_toLex'._simp_1_2 | Mathlib.Order.Prod.Lex.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
ContinuousMultilinearMap.domDomCongrEquiv_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₂ : Type w₂} {M₃ : Type w₃} [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : TopologicalSpace M₂]
[inst_6 : TopologicalSpace M₃] {ι' : Type u_1} (e : ι ≃ ι') (f : ContinuousMultilinearMap R (fun x => M₂)... | null | true |
ENNReal.ofReal_le_ofReal_iff._simp_1 | Mathlib.Basic.ENNReal.Real | ∀ {p q : ℝ}, 0 ≤ q → (ENNReal.ofReal p ≤ ENNReal.ofReal q) = (p ≤ q) | null | false |
Equiv.Perm.perm_mapsTo_inl_iff_mapsTo_inr | Mathlib.GroupTheory.Perm.Finite | ∀ {m : Type u_1} {n : Type u_2} [Finite m] [Finite n] (σ : Equiv.Perm (m ⊕ n)),
Set.MapsTo (⇑σ) (Set.range Sum.inl) (Set.range Sum.inl) ↔ Set.MapsTo (⇑σ) (Set.range Sum.inr) (Set.range Sum.inr) | null | true |
Aesop.DisplayRuleName.noConfusion | Aesop.Rule.Name | {P : Sort u} → {t t' : Aesop.DisplayRuleName} → t = t' → Aesop.DisplayRuleName.noConfusionType P t t' | null | false |
Lean.Server.WithRpcRef._sizeOf_inst | Lean.Server.Rpc.Basic | (α : Type u) → [SizeOf α] → SizeOf (Lean.Server.WithRpcRef α) | null | false |
Plausible.Gen.printSamples | Plausible.Gen | {t : Type} → [Repr t] → Plausible.Gen t → IO PUnit.{1} | Print (at most) 10 samples of a given type to stdout for debugging. Sadly specialized to `Type 0`
| true |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.mor_precomp._auto_1 | Mathlib.CategoryTheory.Sites.Descent.Precoverage | Lean.Syntax | null | false |
CategoryTheory.Limits.IsColimit.ι_map_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F G : CategoryTheory.Functor J C} {d : CategoryTheory.Limits.Cone G} (hd : CategoryTheory.Limits.IsLimit d)
(c : CategoryTheory.Limits.Cone F) (α : F ⟶ G) (j : J) {Z : C} (h : Z ⟶ c.pt),
Catego... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn.primitiveTriangle._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ}, ∀ k < n + 2, k + 2 < n + 3 + 1 | null | false |
CategoryTheory.Subgroupoid.isNormal_comap | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {D : Type u_1} [inst_1 : CategoryTheory.Groupoid D]
(φ : CategoryTheory.Functor C D) {S : CategoryTheory.Subgroupoid D},
S.IsNormal → (CategoryTheory.Subgroupoid.comap φ S).IsNormal | null | true |
IsIntegral.of_finite | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | ∀ (R : Type u_1) {B : Type u_3} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] [Module.Finite R B]
(x : B), IsIntegral R x | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.π_descH_assoc | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {A : C} (k : h.K ⟶ A)
(hk : CategoryTheory.CategoryStruct.comp h.f' k = 0) {Z : C} (h_1 : A ⟶ Z),
CategoryTheory.CategoryStruct.comp h.π (... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.edgeDensity_badVertices_le | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} (G : SimpleGraph α) [inst : DecidableRel G.Adj] {ε : ℝ} {s t : Finset α},
0 ≤ ε →
2 * ε ≤ ↑(G.edgeDensity s t) → ↑(G.edgeDensity (SimpleGraph.badVertices✝ G ε s t) t) ≤ ↑(G.edgeDensity s t) - ε | null | true |
ContDiffWithinAt.inversion | Mathlib.Geometry.Euclidean.Inversion.Calculus | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : InnerProductSpace ℝ F] {c x : E → F} {R : E → ℝ} {s : Set E} {a : E} {n : ℕ∞},
ContDiffWithinAt ℝ (↑n) c s a →
ContDiffWithinAt ℝ (↑n) R s a →
ContDiffWithinAt ℝ (↑n) x s a →
... | null | true |
CategoryTheory.IsSplitCoequalizer.leftSection_bottom | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {Z : C} {π : Y ⟶ Z}
(self : CategoryTheory.IsSplitCoequalizer f g π),
CategoryTheory.CategoryStruct.comp self.leftSection g = CategoryTheory.CategoryStruct.id Y | `leftSection` splits `g` | true |
Std.Http.URI.EncodedQueryParam.ofByteArray! | Std.Http.Data.URI.Encoding | ByteArray → Std.Http.URI.EncodedQueryParam | Creates an encoded query parameter from raw bytes, panicking on invalid encoding.
| true |
_private.Mathlib.Algebra.Module.Submodule.Map.0.Submodule.map_neg.match_1_3 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_3} {M₂ : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(p : Submodule R M) [inst_3 : AddCommGroup M₂] [inst_4 : Module R M₂] (f : M →ₗ[R] M₂) (x : M₂)
(motive : x ∈ Submodule.map f p → Prop) (x_1 : x ∈ Submodule.map f p),
(∀ (x_2 : M) (hx : x_2 ∈ ↑p) (hy : ... | null | false |
Nat.min | Init.Data.Nat.Basic | ℕ → ℕ → ℕ | Returns the lesser of two natural numbers. Usually accessed via `Min.min`.
Returns `n` if `n ≤ m`, or `m` if `m ≤ n`.
Examples:
* `min 0 5 = 0`
* `min 4 5 = 4`
* `min 4 3 = 3`
* `min 8 8 = 8`
| true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.isOrtho_polarBilin._simp_1_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {Q : QuadraticMap R M N} {x y : M},
Q.IsOrtho x y = (Q (x + y) = Q x + Q y) | null | false |
Lean.Parser.Command.extends.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
Polynomial.Gal.uniqueGalZero | Mathlib.FieldTheory.PolynomialGaloisGroup | {F : Type u_1} → [inst : Field F] → Unique (Polynomial.Gal 0) | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.Producer.mk.inj | Std.Http.Data.Body.Stream | ∀ {chunk : Std.Http.Chunk} {done : IO.Promise Bool} {chunk_1 : Std.Http.Chunk} {done_1 : IO.Promise Bool},
{ chunk := chunk, done := done } = { chunk := chunk_1, done := done_1 } → chunk = chunk_1 ∧ done = done_1 | null | true |
Lean.AsyncBranch.asyncEnv | Lean.Environment | Lean.AsyncBranch | The async branch that finished adding a declaration, i.e. `AddConstAsyncResult.asyncEnv`. | true |
IsRightRegular.unop | Mathlib.Algebra.Regular.Opposite | ∀ {R : Type u_1} [inst : Mul R] {a : Rᵐᵒᵖ}, IsLeftRegular a → IsRightRegular (MulOpposite.unop a) | **Alias** of the reverse direction of `isRightRegular_unop`. | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr.0.Std.Tactic.BVDecide.BVExpr.bitblast.go.match_17.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) (w a : ℕ)
(h_1 : (w a : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var a))
(h_2 : (w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val))
(h_3 :
(w : ℕ) →
(lhsExpr : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tact... | null | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.mkPatternRefMap.go | Lean.Elab.Match | Lean.Expr → (σ : Type) → ST σ (Lean.ExprMap Lean.Expr) | null | true |
StarAlgEquiv.symm_apply_eq | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A] [inst_3 : Mul B]
[inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] (e : A ≃⋆ₐ[R] B) {x : B} {y : A},
e.symm x = y ↔ x = e y | null | true |
Nucleus.toInfHom | Mathlib.Order.Nucleus | {X : Type u_2} → [inst : SemilatticeInf X] → Nucleus X → InfHom X X | null | true |
_private.Lean.Compiler.LCNF.Visibility.0.Lean.Compiler.LCNF.collectUsedDecls.match_1 | Lean.Compiler.LCNF.Visibility | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Alt pu → Sort u_1) →
(alt : Lean.Compiler.LCNF.Alt pu) →
((k : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.Alt.default k)) →
((ctorName : Lean.Name) →
(params : Array (Lean.Compiler.LCNF.Param pu)) →
... | null | false |
AddCommGrpCat.instZeroHom.eq_1 | Mathlib.Algebra.Category.Grp.Basic | ∀ (G H : AddCommGrpCat), G.instZeroHom H = { zero := AddCommGrpCat.ofHom 0 } | null | true |
CategoryTheory.Functor.IsDenseSubsite.mapPreimage_comp_assoc | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {J : CategoryTheory.GrothendieckTopology C}
(K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D) {A : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] [ins... | null | true |
_private.Mathlib.GroupTheory.Sylow.0.Sylow.not_dvd_index_aux | Mathlib.GroupTheory.Sylow | ∀ {p : ℕ} {G : Type u_1} [inst : Group G] [hp : Fact (Nat.Prime p)] (P : Sylow p G) [(↑P).Normal] [(↑P).FiniteIndex],
¬p ∣ (↑P).index | Auxiliary lemma for `Sylow.not_dvd_index` which is strictly stronger. | true |
CategoryTheory.ShortComplex.SnakeInput.functorL₃_map | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{X Y : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y),
CategoryTheory.ShortComplex.SnakeInput.functorL₃.map f = f.f₃ | null | true |
instPredOrderOrderDualOfSuccOrder._proof_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a b : αᵒᵈ}, a < b → SuccOrder.succ (OrderDual.ofDual b) ≤ a | null | false |
PartialEquiv.piecewise._proof_1 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e e' : PartialEquiv α β) (s : Set α) (t : Set β) [inst : (x : α) → Decidable (x ∈ s)],
e.IsImage s t → e'.IsImage s t → Set.MapsTo (s.piecewise ↑e ↑e') (s.ite e.source e'.source) (t.ite e.target e'.target) | null | false |
CategoryTheory.ShortComplex.SnakeInput.functorL₁'_map_τ₁ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{X Y : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y),
(CategoryTheory.ShortComplex.SnakeInput.functorL₁'.map f).τ₁ = f.f₀.τ₂ | null | true |
Std.DTreeMap.Equiv.getKeyGT?_eq | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
t₁.Equiv t₂ → t₁.getKeyGT? k = t₂.getKeyGT? k | null | true |
ContMDiffAt.nsmul | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {H : Type u_3} [inst_1 : TopologicalSpace H]
{E : Type u_4} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_5}
[inst_4 : AddCommMonoid G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace ... | null | true |
Mathlib.Tactic.Widget.StringDiagram.Kind.bicategory | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.Kind | null | true |
Pell.pell._unsafe_rec | Mathlib.NumberTheory.PellMatiyasevic | {a : ℕ} → 1 < a → ℕ → ℕ × ℕ | null | false |
_private.Mathlib.MeasureTheory.Function.SimpleFuncDenseLp.0.MeasureTheory.Integrable.induction._simp_1_1 | Mathlib.MeasureTheory.Function.SimpleFuncDenseLp | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε}, MeasureTheory.Integrable f μ = MeasureTheory.MemLp f 1 μ | null | false |
Std.Time.DayPeriodSymbols.mk.inj | Std.Time.Format.DateFormat | ∀ {am pm noon midnight am_1 pm_1 noon_1 midnight_1 : String},
{ am := am, pm := pm, noon := noon, midnight := midnight } =
{ am := am_1, pm := pm_1, noon := noon_1, midnight := midnight_1 } →
am = am_1 ∧ pm = pm_1 ∧ noon = noon_1 ∧ midnight = midnight_1 | null | true |
SeparationQuotient.mk_smul | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] [inst_1 : SMul M X] [inst_2 : ContinuousConstSMul M X]
(c : M) (x : X), SeparationQuotient.mk (c • x) = c • SeparationQuotient.mk x | null | true |
FilterBasis.filter.eq_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} (B : FilterBasis α),
B.filter = { sets := {s | ∃ t ∈ B, t ⊆ s}, univ_sets := ⋯, sets_of_superset := ⋯, inter_sets := ⋯ } | null | true |
Mathlib.Tactic.Choose.ChooseArg.mk.sizeOf_spec | Mathlib.Tactic.Choose | ∀ (ref : Lean.Syntax) (name : Lean.Name) (expectedType? : Option Lean.Term),
sizeOf { ref := ref, name := name, expectedType? := expectedType? } =
1 + sizeOf ref + sizeOf name + sizeOf expectedType? | null | true |
IsCompactlyGenerated.BooleanGenerators.rec | Mathlib.Order.BooleanGenerators | {α : Type u_1} →
[inst : CompleteLattice α] →
{S : Set α} →
{motive : IsCompactlyGenerated.BooleanGenerators S → Sort u} →
((isAtom : ∀ I ∈ S, IsAtom I) →
(finitelyAtomistic :
∀ (s : Finset α) (a : α), ↑s ⊆ S → IsCompactElement a → a ≤ s.sup id → ∃ t ⊆ s, a = t.sup id) →
... | null | false |
RingCon.instAddGroupQuotient._proof_8 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : AddGroup R] [inst_1 : Mul R] (c : RingCon R) (n : ℕ) (a : c.Quotient), ↑n.succ • a = ↑n • a + a | null | false |
_private.Mathlib.AlgebraicTopology.DoldKan.NReflectsIso.0.AlgebraicTopology.DoldKan.instReflectsIsomorphismsSimplicialObjectKaroubiChainComplexNatN₁._simp_2 | Mathlib.AlgebraicTopology.DoldKan.NReflectsIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{X X' : CategoryTheory.SimplicialObject C} {n : ℕ} {Z : C} (f : AlgebraicTopology.DoldKan.MorphComponents X n Z)
(g : X' ⟶ X), CategoryTheory.CategoryStruct.comp (g.app (Opposite.op { len := n + 1 })) f.φ = (f.pre... | null | false |
CompleteSublattice.bot_mem | Mathlib.Order.CompleteSublattice | ∀ {α : Type u_1} [inst : CompleteLattice α] {L : CompleteSublattice α}, ⊥ ∈ L | null | true |
Std.Sat.AIG.LawfulOperator.recOn | Std.Sat.AIG.LawfulOperator | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{β : Std.Sat.AIG α → Type} →
{f : (aig : Std.Sat.AIG α) → β aig → Std.Sat.AIG.Entrypoint α} →
{motive : Std.Sat.AIG.LawfulOperator α β f → Sort u} →
(t : Std.Sat.AIG.LawfulOperator α β f) →
((le_size : ... | null | false |
Encodable.encode' | Mathlib.Logic.Encodable.Basic | (α : Type u_1) → [Encodable α] → α ↪ ℕ | The `encode` function, viewed as an embedding. | true |
NonUnitalAlgHom.fst._proof_3 | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ (A : Type u_1) (B : Type u_2) [inst : NonUnitalNonAssocSemiring A] [inst_1 : NonUnitalNonAssocSemiring B]
(x x_1 : A × B), (x + x_1).1 = (x + x_1).1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.