name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SimpleGraph.Walk.head_darts_eq_firstDart | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w} (hnil : p.darts ≠ []), p.darts.head hnil = p.firstDart ⋯ | Use `firstDart_eq_head_darts` to rewrite in the reverse direction. | true |
IO.FS.DirEntry._sizeOf_1 | Init.System.IO | IO.FS.DirEntry → ℕ | null | false |
CategoryTheory.NatTrans.naturality_1 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (α : F ⟶ G) {X Y : C} (e : X ≅ Y),
CategoryTheory.CategoryStruct.comp (F.map e.inv) (CategoryTheory.CategoryStruct.comp (α.app X) (G.map e.hom)) =
α.app Y | null | true |
wbtw_smul_vadd_smul_vadd_of_nonpos_of_le | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P] (x : P) (v : V) {r₁ r₂ : R},
r₁ ≤ 0 → r₂ ≤ r₁ → Wbtw R x (r₁ • v +ᵥ x) (r₂ • v +ᵥ x) | null | true |
Subsemigroup.instCompleteLattice._proof_2 | Mathlib.Algebra.Group.Subsemigroup.Basic | ∀ {M : Type u_1} [inst : Mul M] (a : Subsemigroup M), a ≤ a | null | false |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.IsCompactElement.exists_le_finsetSup_of_le_isLUB._proof_1_1 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderBot α] {s : Set α} (t : Finset α),
↑t ⊆ s →
∀ (t' : Finset α),
↑t' ⊆ s →
(t ∪ t').sup id ∈ {x | ∃ t, ↑t ⊆ s ∧ x = t.sup id} ∧ t.sup id ≤ (t ∪ t').sup id ∧ t'.sup id ≤ (t ∪ t').sup id | null | false |
CategoryTheory.ModObj.instTensorUnit._proof_2 | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (X : D),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCat... | null | false |
Lean.PrefixTreeNode.Node.inj | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {a : Option β}
{a_1 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp} {a_2 : Option β}
{a_3 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp},
Lean.PrefixTreeNode.Node a a_1 = Lean.PrefixTreeNode.Node a_2 a_3 → a = a_2 ∧ a_1 = a_3 | null | true |
Bool.eq_and_not_self._simp_1 | Init.Data.Bool | ∀ {a b : Bool}, (b = (a && !b)) = ((!a) = true ∧ (!b) = true) | null | false |
CategoryTheory.Comonad.adj._proof_2 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (G : CategoryTheory.Comonad C) (X : G.Coalgebra) (Y : C)
(f : G.forget.obj X ⟶ Y),
CategoryTheory.CategoryStruct.comp X.a (G.map (CategoryTheory.CategoryStruct.comp X.a (G.map f))) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.... | null | false |
_private.Mathlib.Basic.ENNReal.Holder.0.ENNReal.HolderTriple.inv_sub_inv_eq_inv'._simp_1_1 | Mathlib.Basic.ENNReal.Holder | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
_private.Mathlib.NumberTheory.Height.MvPolynomial.0.Height.mulHeight_sym2_ge._proof_1_4 | Mathlib.NumberTheory.Height.MvPolynomial | ∀ (K : Type u_1) [inst : Field K], (MvPolynomial.X 1).IsHomogeneous 1 | null | false |
_private.Batteries.Data.List.Count.0.List.idxToSigmaCount_sigmaCountToIdx._proof_1_8 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] {xs : List α} {xc : (x : α) × Fin (List.count x xs)},
List.idxOfNth xc.fst xs ↑xc.snd + 1 ≤ xs.length → List.idxOfNth xc.fst xs ↑xc.snd < xs.length | null | false |
Option.instULiftable | Mathlib.Control.ULiftable | ULiftable Option Option | null | true |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.squashGCF.match_3.eq_1 | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp_f₀ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁.Hom S₂) (g : S₂.Hom S₃),
(f.comp g).f₀ = CategoryTheory.CategoryStruct.comp f.f₀ g.f₀ | null | true |
Mathlib.Tactic.AtomM.Context.mk | Mathlib.Util.AtomM | Lean.Meta.TransparencyMode → (Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result) → Mathlib.Tactic.AtomM.Context | null | true |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightNeutral | Lean.Compiler.LCNF.Simp.ConstantFold | {α : Type} →
[Lean.Compiler.LCNF.Simp.ConstantFold.Literal α] →
[BEq α] →
(neutral : α) →
(op : α → α → α) →
autoParam (∀ (x : α), op neutral x = x) Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightNeutral._auto_1 →
autoParam (∀ (x : α), op x neutral = x)
Le... | Provide a folder for an operation that has the same left and right neutral element.
| true |
NumberField.RingOfIntegers.instMulSemiringAction._proof_7 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] {G : Type u_2} [inst_1 : Group G] [inst_2 : MulSemiringAction G K] (g : G), g • 1 = 1 | null | false |
_private.Lean.Elab.PreDefinition.TerminationMeasure.0.Lean.Elab.TerminationMeasure.delab.go._unary | Lean.Elab.PreDefinition.TerminationMeasure | Lean.Elab.TerminationMeasure →
(_ : ℕ) ×' Lean.TSyntaxArray `ident →
Lean.PrettyPrinter.Delaborator.DelabM (Lean.TSyntax `Lean.Parser.Termination.terminationBy) | null | false |
AddCommMonCat.noConfusion | Mathlib.Algebra.Category.MonCat.Basic | {P : Sort u_1} → {t t' : AddCommMonCat} → t = t' → AddCommMonCat.noConfusionType P t t' | null | false |
CategoryTheory.ModObj.trivialAction._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.MonObj M] (X : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft CategoryTheory.MonObj.one X)
... | null | false |
Vector.eraseIdx_append._proof_4 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n + m → ¬k < n → k - n < m | null | false |
CategoryTheory.Bicategory.postcomp₂_naturality_inv_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} (f : a ⟶ b) {a_1 b_1 : Bᵒᵖ} (g : a_1 ⟶ b_1)
(X : ↑↧(Opposite.unop a_1 ⟶ a)),
((CategoryTheory.Bicategory.postcomp₂ f).naturality g).inv.toNatTrans.app X =
(CategoryTheory.Bicategory.associator g.unop X f).inv | null | true |
HomologicalComplex.hom_ext | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C D : HomologicalComplex V c} (f g : C ⟶ D),
(∀ (i : ι), f.f i = g.f i) → f = g | null | true |
groupHomology.isoCycles₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] → (A : Rep.{u, u, u} k G) → groupHomology.cycles A 1 ≅ ↧↥(groupHomology.cycles₁ A) | The 1-cycles of the complex of inhomogeneous chains of `A` are isomorphic to
`cycles₁ A`, which is a simpler type. | true |
Lean.Meta.Sym.SharedExprs.recOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.SharedExprs → Sort u} →
(t : Lean.Meta.Sym.SharedExprs) →
((trueExpr falseExpr natZExpr btrueExpr bfalseExpr ordEqExpr intExpr : Lean.Expr) →
motive
{ trueExpr := trueExpr, falseExpr := falseExpr, natZExpr := natZExpr, btrueExpr := btrueExpr,
bfalseExpr := bfa... | null | false |
_private.Aesop.Rule.Name.0.Aesop.RuleName.Json.mk.sizeOf_spec | Aesop.Rule.Name | ∀ (name : Lean.Name) (builder : Aesop.BuilderName) (phase : Aesop.PhaseName) (scope : Aesop.ScopeName)
(rendered : String),
sizeOf { name := name, builder := builder, phase := phase, scope := scope, rendered := rendered } =
1 + sizeOf name + sizeOf builder + sizeOf phase + sizeOf scope + sizeOf rendered | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.isCycle_swap_mul_aux₂.match_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_1} [inst : DecidableEq α]
(motive :
(x : ℤ) →
(x_1 x_2 : α) →
(x_3 : Equiv.Perm α) → (Equiv.swap x_2 (x_3 x_2) * x_3) x_1 ≠ x_1 → (x_3 ^ x) (x_3 x_2) = x_1 → Prop)
(x : ℤ) (x_1 x_2 : α) (x_3 : Equiv.Perm α) (x_4 : (Equiv.swap x_2 (x_3 x_2) * x_3) x_1 ≠ x_1)
(x_5 : (x_3 ^ x) (x_3 x_... | null | false |
CategoryTheory.Pseudofunctor.mapComp'_id_comp_hom_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.Pseudofunctor B C) {b₀ b₁ : B} (f : b₀ ⟶ b₁)
{Z : F.obj b₀ ⟶ F.obj b₁}
(h : CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.Category... | null | true |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.isNonParametricLitValue | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → Lean.MetaM Bool | Returns true if `e` is a nonparametric literal.
For example, `BitVec` and `Fin` are parametric literals, but `Nat` is not.
| true |
_private.Mathlib.Algebra.BigOperators.Finprod.0.finprod_le_finprod._proof_1_1 | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] {f g : α → M}
(this : Fintype ↑(Function.mulSupport f ∪ Function.mulSupport g)),
Function.mulSupport f ⊆ ↑(Function.mulSupport f ∪ Function.mulSupport g).toFinset | null | false |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentData.0.CategoryTheory.Pseudofunctor.DescentData.ofObj._proof_1 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} (Y : C) (q : Y ⟶ S) (i₁ : ι) (f₁ : Y ⟶ X i₁),
CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q →
CategoryTheory.CategoryStruct.comp (f i₁).op.toLoc f₁.op.toLoc = q.op.toLoc | null | false |
WithBot.le_unbot_iff._simp_2 | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α} (hx : x ≠ ⊥), (a ≤ x.unbot hx) = (↑a ≤ x) | null | false |
PreLp.ring._proof_21 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {I : Type u_1} {B : I → Type u_2} [inst : (i : I) → NormedRing (B i)],
autoParam (∀ (a : PreLp B), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | null | false |
tangentSpaceCast._proof_3 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] (x y : M), Continuous fun v => v | null | false |
Rep.add_hom | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{w, u, v} k G} (f g : A ⟶ B),
Rep.Hom.hom (f + g) = Rep.Hom.hom f + Rep.Hom.hom g | null | true |
PowerSeries.binomialSeries_coeff | Mathlib.RingTheory.PowerSeries.Binomial | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : BinomialRing R] [inst_2 : Semiring A] [inst_3 : SMul R A]
(r : R) (n : ℕ), (PowerSeries.coeff n) (PowerSeries.binomialSeries A r) = Ring.choose r n • 1 | null | true |
balancedCore.balanced | Mathlib.Analysis.LocallyConvex.BalancedCoreHull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] (s : Set E), Balanced 𝕜 (balancedCore 𝕜 s) | null | true |
CompactConvergenceCLM._aux_Mathlib_Topology_Algebra_Module_Spaces_CompactConvergenceCLM___unexpand_CompactConvergenceCLM_1 | Mathlib.Topology.Algebra.Module.Spaces.CompactConvergenceCLM | Lean.PrettyPrinter.Unexpander | null | false |
Fintype.rec | Mathlib.Data.Fintype.Defs | {α : Type u_3} →
{motive : Fintype α → Sort u} →
((elems : Finset α) → (complete : ∀ (x : α), x ∈ elems) → motive { elems := elems, complete := complete }) →
(t : Fintype α) → motive t | null | false |
MeasureTheory.stronglyMeasurable_condExp | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → E}
[inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E], MeasureTheory.StronglyMeasurable μ[f | m] | null | true |
Lean.Declaration._sizeOf_1 | Lean.Declaration | Lean.Declaration → ℕ | null | false |
CategoryTheory.Bundled | Mathlib.CategoryTheory.ConcreteCategory.Bundled | (Type u → Type v) → Type (max (u + 1) v) | `Bundled` is a type bundled with a type class instance for that type. Only
the type class is exposed as a parameter. | true |
summable_of_summable_hasDerivAt_of_isPreconnected | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} {𝕜 : Type u_2} {F : Type u_4} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ} [inst_4 : NormedSpace 𝕜 F] {g g' : α → 𝕜 → F}
{t : Set 𝕜} {y₀ y : 𝕜},
Summable u →
IsOpen t →
IsPreconnected t →
(∀ (n : ... | Consider a series of functions `∑' n, f n x` on a preconnected open set. If the series converges
at a point, and all functions in the series are differentiable with a summable bound on the
derivatives, then the series converges everywhere on the set. | true |
MeasureTheory.StronglyMeasurable.fun_sub | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Sub β]
[ContinuousSub β],
MeasureTheory.StronglyMeasurable f →
MeasureTheory.StronglyMeasurable g → MeasureTheory.StronglyMeasurable fun i => f i - g i | Eta-expanded form of `MeasureTheory.StronglyMeasurable.sub` | true |
_private.Std.Data.DHashMap.Raw.0.Std.DHashMap.Raw.Const.getThenInsertIfNew?.match_1 | Std.Data.DHashMap.Raw | {α : Type u_2} →
{β : Type u_1} →
(motive : (Option β × Std.DHashMap.Internal.Raw₀ α fun x => β) → Sort u_3) →
(x : Option β × Std.DHashMap.Internal.Raw₀ α fun x => β) →
((replaced : Option β) →
(r : Std.DHashMap.Raw α fun x => β) → (property : 0 < r.buckets.size) → motive (replaced, ⟨r,... | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PP.0.Lean.Meta.Grind.Arith.Linear.ppStruct?.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.PP | (motive : Lean.Expr × ℚ → Sort u_1) → (x : Lean.Expr × ℚ) → ((e : Lean.Expr) → (val : ℚ) → motive (e, val)) → motive x | null | false |
PrimeSpectrum.vanishingIdeal_range_comap | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S),
PrimeSpectrum.vanishingIdeal (Set.range (PrimeSpectrum.comap f)) = (RingHom.ker f).radical | null | true |
BooleanSubalgebra.instBot._proof_2 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α], ∀ x ∈ {⊥, ⊤}, ∀ ⦃b : α⦄, b ∈ {⊥, ⊤} → x ⊓ b ∈ {⊥, ⊤} | null | false |
Lean.Server.FileWorker.EditableDocumentCore.ctorIdx | Lean.Server.FileWorker.Utils | Lean.Server.FileWorker.EditableDocumentCore → ℕ | null | false |
CategoryTheory.Functor.NatTrans.hcomp_eq_whiskerRight_comp_whiskerLeft | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {F G : CategoryTheory.Functor C D}
{H K : CategoryTheory.Functor D E} (α : G ⟶ F) (β : K ⟶ H),
α ◫ β = CategoryTheory.CategoryStruct.c... | null | true |
Mathlib.Meta.FunProp.instReprTheoremForm | Mathlib.Tactic.FunProp.Theorems | Repr Mathlib.Meta.FunProp.TheoremForm | null | true |
Std.DHashMap.instDecidableEquivOfLawfulBEq | Std.Data.DHashMap.DecidableEquiv | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[LawfulBEq α] →
[inst_2 : Hashable α] →
[inst_3 : (k : α) → BEq (β k)] →
[∀ (k : α), LawfulBEq (β k)] → (m₁ m₂ : Std.DHashMap α β) → Decidable (m₁.Equiv m₂) | null | true |
MeasureTheory.Measure.AbsolutelyContinuous.zero | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ : MeasureTheory.Measure α), MeasureTheory.Measure.AbsolutelyContinuous 0 μ | null | true |
CategoryTheory.Triangulated.TStructure.truncLTι_comp_truncGEπ_app | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
MulHom.toFun_eq_coe | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N), f.toFun = ⇑f | null | true |
ValuativeRel.ofValuation._proof_4 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {S : Type u_2} {Γ : Type u_1} [inst : Ring S] [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation S Γ),
¬v 1 ≤ v 0 | null | false |
Equiv.Perm.equivUnitsEnd | Mathlib.Algebra.Group.End | {α : Type u_4} → Equiv.Perm α ≃* (Function.End α)ˣ | The permutation of a type is equivalent to the units group of the endomorphisms monoid of this
type. | true |
Real.binEntropy_strictAntiOn | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | StrictAntiOn Real.binEntropy (Set.Icc 2⁻¹ 1) | Binary entropy is strictly decreasing in interval [1/2, 1]. | true |
Std.Iterators.Types.Drop.rec | Std.Data.Iterators.Combinators.Monadic.Drop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{motive : Std.Iterators.Types.Drop α m β → Sort u} →
((remaining : ℕ) → (inner : Std.IterM m β) → motive { remaining := remaining, inner := inner }) →
(t : Std.Iterators.Types.Drop α m β) → motive t | null | false |
Int16.toInt8_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, -2 ^ 15 ≤ n → n < 2 ^ 15 → (Int16.ofIntClamp n).toInt8 = Int8.ofInt n | null | true |
CategoryTheory.Functor.instFullProdUncurry₃ | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_4} {E : Type u_9} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_4} C₃]
[inst_3 : CategoryTheory.Category.{v_9, u_9} E], CategoryTheory.Functor.uncurry₃.Full | null | true |
BAll.imp_left | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {r p q : α → Prop}, (∀ (x : α), p x → q x) → (∀ (x : α), q x → r x) → ∀ (x : α), p x → r x | null | true |
locallyPathConnectedSpace_iff_pathComponentIn_mem_nhds | Mathlib.Topology.Connected.LocallyPathConnected | ∀ {X : Type u_4} [inst : TopologicalSpace X],
LocallyPathConnectedSpace X ↔ ∀ (x : X) (u : Set X), IsOpen u → x ∈ u → pathComponentIn u x ∈ nhds x | A space is locally path-connected iff all path components of open subsets are neighbourhoods. | true |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.isMVarSwap.go._sparseCasesOn_14 | Mathlib.Tactic.Widget.LibraryRewrite | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 2048 t.ctorIdx → motive t) → motive t | null | false |
Lean.Parser.Command.openDecl.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
UniformSpace.Completion.instAddCommGroup | Mathlib.Topology.Algebra.GroupCompletion | {α : Type u_3} →
[inst : UniformSpace α] → [inst_1 : AddCommGroup α] → [IsUniformAddGroup α] → AddCommGroup (UniformSpace.Completion α) | null | true |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.collectInfoBasedSemanticTokens.match_9 | Lean.Server.FileWorker.SemanticHighlighting | (motive : Lean.Elab.Info → Sort u_1) →
(info : Lean.Elab.Info) →
((ti : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo ti)) →
((x : Lean.Elab.Info) → motive x) → motive info | null | false |
ModelWithCorners.uniqueDiffOn_preimage_source | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {β : Type u_4}
[inst_4 : TopologicalSpace β] {e : OpenPartialHomeomorph H β}, UniqueDiffOn 𝕜 (↑I.symm ⁻¹' e.sou... | null | true |
Nat.factorization_le_iff_dvd | Mathlib.Data.Nat.Factorization.Defs | ∀ {d n : ℕ}, d ≠ 0 → n ≠ 0 → (d.factorization ≤ n.factorization ↔ d ∣ n) | null | true |
String.Pos.nextn_eq_nextn_toSlice | Init.Data.String.Lemmas.Basic | ∀ {n : ℕ} {s : String} {p : s.Pos}, p.nextn n = String.Pos.ofToSlice (p.toSlice.nextn n) | null | true |
Algebra.IsCentral.mk._flat_ctor | Mathlib.Algebra.Central.Defs | ∀ {K : Type u} [inst : CommSemiring K] {D : Type v} [inst_1 : Semiring D] [inst_2 : Algebra K D],
Subalgebra.center K D ≤ ⊥ → Algebra.IsCentral K D | null | false |
_private.Init.Grind.Ring.Basic.0.Lean.Grind.Ring.intCast_nat_sub._proof_1_2 | Init.Grind.Ring.Basic | ∀ {y : ℕ} (x : ℕ), x + 1 ≥ y → ¬x + 1 = y → ¬↑(x + 1 - y) = ↑(x - y) + 1 → False | null | false |
Set.IsPWO.insert | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} [inst : Preorder α] {s : Set α}, s.IsPWO → ∀ (a : α), (insert a s).IsPWO | null | true |
Filter.Tendsto.finset_sup'_nhds_apply | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} [inst : TopologicalSpace L] {ι : Type u_3} {α : Type u_4} {s : Finset ι} {f : ι → α → L} {l : Filter α}
{g : ι → L} [inst_1 : SemilatticeSup L] [ContinuousSup L] (hne : s.Nonempty),
(∀ i ∈ s, Filter.Tendsto (f i) l (nhds (g i))) →
Filter.Tendsto (fun a => s.sup' hne fun x => f x a) l (nhds (s.s... | null | true |
CategoryTheory.BicartesianSq.toIsPullback | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z}
{i : Y ⟶ Z}, CategoryTheory.BicartesianSq f g h i → CategoryTheory.IsPullback f g h i | null | true |
Real.log_zpow._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ (x : ℝ) (n : ℤ), ↑n * Real.log x = Real.log (x ^ n) | null | false |
SkewMonoidAlgebra.single_add_erase | Mathlib.Algebra.SkewMonoidAlgebra.Single | ∀ {M : Type u_4} {α : Type u_5} [inst : AddCommMonoid M] (a : α) (f : SkewMonoidAlgebra M α),
SkewMonoidAlgebra.single a (f.coeff a) + (SkewMonoidAlgebra.erase a) f = f | null | true |
_private.Init.Data.List.Nat.InsertIdx.0.List.insertIdx_eraseIdx_of_le.match_1_1 | Init.Data.List.Nat.InsertIdx | ∀ {α : Type u_1} (motive : (x x_1 : ℕ) → (x_2 : List α) → x < x_2.length → x_1 ≤ x → Prop) (x x_1 : ℕ) (x_2 : List α)
(x_3 : x < x_2.length) (x_4 : x_1 ≤ x),
(∀ (x : ℕ) (head : α) (tail : List α) (x_5 : x < (head :: tail).length) (x_6 : 0 ≤ x),
motive x 0 (head :: tail) x_5 x_6) →
(∀ (n n_1 : ℕ) (a : α) (... | null | false |
Module.Free.Module.free_shrink | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M]
[inst_4 : Small.{w, v} M], Module.Free R (Shrink.{w, v} M) | **Alias** of `Module.Free.shrink`. | true |
CategoryTheory.RelCat.graphFunctor._proof_3 | Mathlib.CategoryTheory.Category.RelCat | ∀ {X Y Z : Type u_1} (f : X ⟶ Y) (g : Y ⟶ Z),
{ rel := Function.graph ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) } =
CategoryTheory.CategoryStruct.comp { rel := Function.graph ⇑(CategoryTheory.ConcreteCategory.hom f) }
{ rel := Function.graph ⇑(CategoryTheory.ConcreteCat... | null | false |
Lean.Meta.Grind.isCastLikeFn | Lean.Meta.Tactic.Grind.CastLike | Lean.Expr → Bool | Returns `true` if `f` is a cast-like operation. | true |
_private.Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique.0.AlgebraNorm.instAlgebraCopy._aux_3 | Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique | {K : Type u_1} →
{L : Type u_2} →
[inst : NontriviallyNormedField K] →
[inst_1 : Field L] → [inst_2 : Algebra K L] → (_f : AlgebraNorm K L) → (x : L) → K →+* AlgebraNorm.copy✝ _f x | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_neg_of_msb_true._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w},
2 * x.toNat ≥ 2 ^ w → ¬(if 2 * x.toNat < 2 ^ w then ↑x.toNat else ↑x.toNat - ↑(2 ^ w)) < 0 → False | null | false |
CategoryTheory.MonoidalCategory.monoidalOfLawfulDayConvolutionMonoidalCategoryStruct._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_6, u_3} C] (V : Type u_5)
[inst_1 : CategoryTheory.Category.{u_4, u_5} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCa... | null | false |
Std.TreeMap.minKey_insert_of_isEmpty | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t.isEmpty = true → (t.insert k v).minKey ⋯ = k | null | true |
Invertible.ofLeftInverse | Mathlib.Algebra.Group.Invertible.Basic | {R : Type u_1} →
{S : Type u_2} →
{G : Type u_3} →
[inst : MulOneClass R] →
[inst_1 : MulOneClass S] →
[inst_2 : FunLike G S R] →
[MonoidHomClass G S R] →
(f : R → S) → (g : G) → (r : R) → Function.LeftInverse (⇑g) f → [Invertible (f r)] → Invertible r | If a function `f : R → S` has a left-inverse that is a monoid hom,
then `r : R` is invertible if `f r` is.
The inverse is computed as `g (⅟(f r))` | true |
Lean.Omega.LinearCombo.noConfusion | Init.Omega.LinearCombo | {P : Sort u} → {t t' : Lean.Omega.LinearCombo} → t = t' → Lean.Omega.LinearCombo.noConfusionType P t t' | null | false |
Classical.propDecidable._proof_1 | Init.Classical | ∀ (a : Prop), Nonempty (Decidable a) | null | false |
Prod.nonUnitalSeminormedRing._proof_6 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalSeminormedRing α] [inst_1 : NonUnitalSeminormedRing β] (a : α × β),
0 * a = 0 | null | false |
Lean.Compiler.LCNF.Pass.shouldAlwaysRunCheck._default | Lean.Compiler.LCNF.PassManager | Bool | null | false |
_private.Mathlib.Combinatorics.Colex.0.Finset.Colex.erase_le_erase_min'._simp_1_3 | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s t : Finset α},
(Finset.filter p s = Finset.filter p t) = ∀ ⦃a : α⦄, p a → (a ∈ s ↔ a ∈ t) | null | false |
ValuativeExtension.vle_iff_vle | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {A : Type u_1} {B : Type u_2} {inst : CommSemiring A} {inst_1 : Semiring B} {inst_2 : ValuativeRel A}
{inst_3 : ValuativeRel B} {inst_4 : Algebra A B} [self : ValuativeExtension A B] (a b : A),
(algebraMap A B) a ≤ᵥ (algebraMap A B) b ↔ a ≤ᵥ b | null | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.instPartialOrderDiagramWithUniqueTerminal._proof_2 | Mathlib.CategoryTheory.Presentable.Directed | ∀ (J : Type u_1) [inst : CategoryTheory.SmallCategory J] (κ : Cardinal.{u_1})
(x : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ), x.P ≤ x.P | null | false |
isPGroup_iff_pow_pow_eq_one | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G], IsPGroup p G ↔ ∀ (g : G), ∃ k, g ^ p ^ k = 1 | null | true |
Array.count.eq_1 | Init.Data.Array.Count | ∀ {α : Type u} [inst : BEq α] (a : α) (as : Array α), Array.count a as = Array.countP (fun x => x == a) as | null | true |
AlgebraicGeometry.Scheme.Hom.quasiFiniteLocus_eq_top_iff | Mathlib.AlgebraicGeometry.ZariskisMainTheorem | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.LocallyOfFiniteType f],
AlgebraicGeometry.Scheme.Hom.quasiFiniteLocus f = ⊤ ↔ AlgebraicGeometry.LocallyQuasiFinite f | null | true |
_private.Lean.Meta.Sym.AlphaShareBuilder.0.Lean.Meta.Sym.Internal.mkAppRevRangeS.go._unsafe_rec | Lean.Meta.Sym.AlphaShareBuilder | {m : Type → Type} →
[Lean.Meta.Sym.Internal.MonadShareCommon m] → [Monad m] → Array Lean.Expr → ℕ → Lean.Expr → ℕ → m Lean.Expr | null | false |
RBTree.RBNode.toList | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → RBTree.RBNode α → List α | `O(n)`. Convert the tree to a list in ascending order. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.