name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Prod.bitraverse.eq_1 | Mathlib.Control.Bitraversable.Instances | ∀ {F : Type u → Type u} [inst : Applicative F] {α : Type u_1} {α' : Type u} {β : Type u_2} {β' : Type u} (f : α → F α')
(f' : β → F β') (x_1 : α) (y : β), Prod.bitraverse f f' (x_1, y) = Prod.mk <$> f x_1 <*> f' y | null | true |
CategoryTheory.kernelOpOp_inv | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C}
(f : X ⟶ Y),
(CategoryTheory.kernelOpOp f).inv = CategoryTheory.Limits.kernel.lift f.op (CategoryTheory.Limits.cokernel.π f).op ⋯ | null | true |
Nat.getElem?_toArray_rcc_eq_some | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, i < n + 1 - m → (m...=n).toArray[i]? = some (m + i) | null | true |
IsNonarchimedean.nmul_le_of_pos | Mathlib.Algebra.Order.Ring.IsNonarchimedean | ∀ {α : Type u_1} {R : Type u_3} [inst : LinearOrder R] {f : α → R} {n : ℕ} [inst_1 : NonAssocSemiring α],
IsNonarchimedean f → ∀ (a : α), 0 < n → f (↑n * a) ≤ f a | If `f : α → R` is nonarchimedean, then `f (n * a) ≤ f a` for every positive `n : ℕ`. | true |
Std.Http.Internal.Char.isSubDelims | Std.Http.Internal.Char | UInt8 → Bool | Checks if a byte is a sub-delimiter character according to RFC 3986.
Sub-delimiters are: `!`, `$`, `&`, `'`, `(`, `)`, `*`, `+`, `,`, `;`, `=`.
| true |
CategoryTheory.MonoidalCategory.leftUnitor_inv_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryS... | null | true |
groupCohomology.eq_d₂₃_comp_inv_assoc | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) {Z : ModuleCat k}
(h : ↧((Fin 3 → G) → ↑A) ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupCohomology.cochainsIso₂ A).inv
(CategoryTheory.CategoryStruct.comp
(CochainComplex.of.d (fun n => ↧((Fin n → G) → ↑A)) (fun n => inh... | null | true |
Order.IsNormal.map_iSup | Mathlib.Order.IsNormal | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : ConditionallyCompleteLinearOrder α]
[inst_1 : ConditionallyCompleteLinearOrder β] {ι : Sort u_4} [Nonempty ι] {g : ι → α},
Order.IsNormal f → BddAbove (Set.range g) → f (⨆ i, g i) = ⨆ i, f (g i) | null | true |
DividedPowerAlgebra.mapEquiv._proof_2 | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ {R : Type u_1} [inst : CommSemiring R] {N : Type u_2} [inst_1 : AddCommMonoid N] [inst_2 : Module R N],
IsScalarTower R R N | null | false |
Lean.Meta.LazyDiscrTree.MatchClone.shouldAddAsStar | Lean.Meta.LazyDiscrTree | Lean.Name → Lean.Expr → Lean.MetaM Bool | This is a hook to determine if we should add an expression as a wildcard pattern.
Clone of `Lean.Meta.DiscrTree.shouldAddAsStar`. See it for more discussion.
| true |
MvPolynomial.coe_def | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (φ : MvPolynomial σ R), ↑φ = fun n => φ.coeff n | null | true |
AkraBazziRecurrence.isBigO_asympBound | Mathlib.Computability.AkraBazzi.AkraBazzi | ∀ {α : Type u_1} [inst : Fintype α] {T : ℕ → ℝ} {g : ℝ → ℝ} {a b : α → ℝ} {r : α → ℕ → ℕ} [inst_1 : Nonempty α]
(R : AkraBazziRecurrence T g a b r), T =O[Filter.atTop] AkraBazziRecurrence.asympBound g a b | The **Akra-Bazzi theorem**: `T ∈ O(n^p (1 + ∑_u^n g(u) / u^{p+1}))` | true |
mul_padicValNat_le | Mathlib.NumberTheory.Padics.PadicVal.Defs | ∀ {p n : ℕ}, p * padicValNat p n ≤ n | A weak upper bound on `padicValNat p n`. | true |
Lean.Meta.LiftLetsConfig.preserveBinderNames._default | Init.MetaTypes | Bool | null | false |
Nat.modCore | Init.Prelude | ℕ → ℕ → ℕ | The modulo operator, which computes the remainder when dividing one natural number by another.
Usually accessed via the `%` operator. When the divisor is `0`, the result is the dividend rather
than an error.
This is the core implementation of `Nat.mod`. It computes the correct result for any two closed
natural numbers... | true |
ClosedAddSubgroup.toAddSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | {G : Type u} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → ClosedAddSubgroup G → AddSubgroup G | null | true |
Matrix.SpecialLinearGroup.toLin'_equiv._proof_12 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_2} [inst : CommRing R] {n : Type u_1} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(A B : Matrix.SpecialLinearGroup n R),
⟨Matrix.SpecialLinearGroup.toLin' (A * B), ⋯⟩ =
⟨Matrix.SpecialLinearGroup.toLin' A, ⋯⟩ * ⟨Matrix.SpecialLinearGroup.toLin' B, ⋯⟩ | null | false |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.VisitStep.descend.sizeOf_spec | Mathlib.Tactic.DefEqAbuse | ∀ {α : Type u_1} [inst : SizeOf α] (butFirst : optParam (Option α) none),
sizeOf (Lean.MessageData.VisitStep.descend✝ butFirst) = 1 + sizeOf butFirst | null | true |
eventually_nhdsNE_eventually_nhds_iff | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T1Space X] {a : X} {p : X → Prop},
(∀ᶠ (y : X) in nhdsWithin a {a}ᶜ, ∀ᶠ (x : X) in nhds y, p x) ↔ ∀ᶠ (x : X) in nhdsWithin a {a}ᶜ, p x | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.adaptationNoteLinter._proof_1 | Mathlib.Tactic.Linter.TextBased | ∀ (lines : Array String), ∀ idx ∈ [:lines.size], idx < lines.size | null | false |
Std.DTreeMap.Internal.Impl.maxEntry?.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (motive : Std.DTreeMap.Internal.Impl α β → Option ((a : α) × β a) → Prop),
motive Std.DTreeMap.Internal.Impl.leaf none →
(∀ (size : ℕ) (k : α) (v : β k) (l : Std.DTreeMap.Internal.Impl α β),
motive (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf... | null | true |
Sum.Lex.instLocallyFiniteOrderTop._proof_2 | Mathlib.Data.Sum.Interval | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrderTop α]
[inst_3 : Fintype β] [inst_4 : LocallyFiniteOrderTop β] (a x : α ⊕ₗ β),
x ∈
((Sum.elim (fun x => Finset.map toLex.toEmbedding ((Finset.Ioi x).disjSum Finset.univ)) fun x =>
Finset.map (Func... | null | false |
Std.DTreeMap.Internal.Impl.link2! | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β | Slower version of `link2` which can be used in the absence of balance information but
still assumes the preconditions of `link2`, otherwise might panic.
| true |
Antitone.le_rightLim | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : ConditionallyCompleteLinearOrder β]
[inst_2 : TopologicalSpace β] [OrderTopology β] {f : α → β},
Antitone f → ∀ {x y : α}, y < x → f x ≤ Function.rightLim f y | null | true |
TestFunction.fderivCLM._proof_11 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] (k : ℕ∞), ContinuousSMul ℝ (TestFunction Ω (E →L[ℝ] F) k) | null | false |
AlgebraicGeometry.Scheme.Etale.forget_obj_left | Mathlib.AlgebraicGeometry.Morphisms.Etale | ∀ (X : AlgebraicGeometry.Scheme) (Y : X.Etale), ((AlgebraicGeometry.Scheme.Etale.forget X).obj Y).left = Y.left | null | true |
CategoryTheory.RelCat.instLargeCategory._proof_2 | Mathlib.CategoryTheory.Category.RelCat | ∀ {X Y : CategoryTheory.RelCat} (f : X.Hom Y), { rel := { rel := SetRel.id }.rel.comp f.rel } = f | null | false |
Mathlib.Meta.NormNum.inferAddMonoidWithOne | Mathlib.Tactic.NormNum.Result | {u : Lean.Level} → (α : Q(Type u)) → Lean.MetaM Q(AddMonoidWithOne «$α») | Helper function to synthesize a typed `AddMonoidWithOne α` expression. | true |
Std.Net.SocketAddressV4.mk.sizeOf_spec | Std.Net.Addr | ∀ (addr : Std.Net.IPv4Addr) (port : UInt16), sizeOf { addr := addr, port := port } = 1 + sizeOf addr + sizeOf port | null | true |
HomogeneousSubsemiring.toSubsemiring | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring | {ι : Type u_1} →
{σ : Type u_2} →
{A : Type u_3} →
[inst : AddMonoid ι] →
[inst_1 : Semiring A] →
[inst_2 : SetLike σ A] →
[inst_3 : AddSubmonoidClass σ A] →
{𝒜 : ι → σ} →
[inst_4 : DecidableEq ι] → [inst_5 : GradedRing 𝒜] → HomogeneousSubsemirin... | null | true |
Manifold._aux_Mathlib_Geometry_Manifold_Instances_Real___macroRules_Manifold_term𝓡__1 | Mathlib.Geometry.Manifold.Instances.Real | Lean.Macro | null | false |
AffineSubspace.subtypeA_toAffineMap | Mathlib.Topology.Algebra.AffineSubspace | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] (s : AffineSubspace R P) [inst_5 : Nonempty ↥s],
↑s.subtypeA = s.subtype | null | true |
Std.Iterators.Types.StepSizeIterator.instIterator._proof_2 | Std.Data.Iterators.Combinators.Monadic.StepSize | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] (it : Std.IterM m β)
(s : Std.PlausibleIterStep (Std.IterM.IsPlausibleNthOutputStep it.internalState.nextIdx it.internalState.inner)),
Std.IterM.IsPlausibleNthOutputStep it.internalState.nextIdx it.internalState.inner
(Std.I... | null | false |
Std.DTreeMap.Internal.Impl.alter.match_1 | Std.Data.DTreeMap.Internal.Operations | {α : Type u_1} →
{β : α → Type u_2} →
(l' : Std.DTreeMap.Internal.Impl α β) →
(motive : Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (l'.size - 1) (l'.size + 1) → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (l'.size - 1) (l'.size + 1)) →
((d : Std.DTreeMap.Interna... | null | false |
Lean.Compiler.LCNF.Simp.instReprFunDeclInfo | Lean.Compiler.LCNF.Simp.FunDeclInfo | Repr Lean.Compiler.LCNF.Simp.FunDeclInfo | null | true |
_private.Std.Data.ByteSlice.0.ByteSlice.forM.loop.eq_def | Std.Data.ByteSlice | ∀ {m : Type v → Type w} [inst : Monad m] (f : UInt8 → m PUnit.{v + 1}) (as : ByteSlice) (i : ℕ),
ByteSlice.forM.loop✝ f as i =
if h : i < as.size then do
f as[i]
ByteSlice.forM.loop✝ f as (i + 1)
else pure PUnit.unit | null | true |
CategoryTheory.Limits.colim.coconeFlip._proof_1 | Mathlib.CategoryTheory.Limits.ColimitLimit | ∀ {J : Type u_6} {K : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
[CategoryTheory.Limits.HasColimitsOfShape K C] (F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (j : J),
CategoryT... | null | false |
instIsPreorderLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : Preorder α], IsPreorder α fun x1 x2 => x1 ≤ x2 | null | true |
SimpleGraph.IsPathGraph3Compl.fst_ne_snd | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u} {G : SimpleGraph α} {v w₁ w₂ : α}, G.IsPathGraph3Compl v w₁ w₂ → w₁ ≠ w₂ | null | true |
ImportGraph.Shake.ComptimeDependency.indirect | ImportGraph.Shake.DeclNeeds | Lean.IndirectModUse → Array Lean.Name → ImportGraph.Shake.ComptimeDependency | A potential compile-time dependency due to an indirect mod use.
`imposingModule` records the module that imposed the indirect mod use (not the source module of
the declaration). | true |
BitVec.toInt_sdiv | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (a b : BitVec w), (a.sdiv b).toInt = (a.toInt.tdiv b.toInt).bmod (2 ^ w) | null | true |
Module.Relations.instAddCommGroupQuotient._proof_7 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u_3} [inst : Ring A] (relations : Module.Relations A) (a : relations.Quotient), a + 0 = a | null | false |
smoothPresheafRing._proof_2 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | null | false |
CategoryTheory.Pseudofunctor.isStackFor_ofArrows_iff | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type t} {S : C}
{X : ι → C} (f : (i : ι) → X i ⟶ S),
F.IsStackFor (CategoryTheory.Presieve.ofArrows X f) ↔ (F.toDescentData f).IsEquivalence | null | true |
Lean.Meta.InjectionResult.rec | Lean.Meta.Tactic.Injection | {motive : Lean.Meta.InjectionResult → Sort u} →
motive Lean.Meta.InjectionResult.solved →
((mvarId : Lean.MVarId) →
(newEqs : Array Lean.FVarId) →
(remainingNames : List Lean.Name) → motive (Lean.Meta.InjectionResult.subgoal mvarId newEqs remainingNames)) →
(t : Lean.Meta.InjectionResult) ... | null | false |
Lean.Lsp.Ipc.waitForExit | Lean.Data.Lsp.Ipc | Lean.Lsp.Ipc.IpcM UInt32 | null | true |
Monoid.CoprodI.Word.Pair.tail | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{M : ι → Type u_2} → [inst : (i : ι) → Monoid (M i)] → {i : ι} → Monoid.CoprodI.Word.Pair M i → Monoid.CoprodI.Word M | The remaining letters of the word, excluding the first letter | true |
AddAction.BlockMem.instBoundedOrder._proof_2 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ (G : Type u_1) [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] (a : X) (a_1 : AddAction.BlockMem G a),
a_1 ≤ ⟨Set.univ, ⋯⟩ | null | false |
torusMap.eq_1 | Mathlib.MeasureTheory.Integral.TorusIntegral | ∀ {n : ℕ} (c : Fin n → ℂ) (R θ : Fin n → ℝ) (i : Fin n),
torusMap c R θ i = c i + ↑(R i) * Complex.exp (↑(θ i) * Complex.I) | null | true |
CategoryTheory.Triangulated.TStructure.eTruncLTGEIsoGELT_hom_app_fac_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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 : CategoryT... | null | true |
FinBddDistLat.Iso.mk._proof_11 | Mathlib.Order.Category.FinBddDistLat | ∀ {α β : FinBddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat) (a b : ↑β.1.1),
{ toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ }.toFun (a ⊔ b) =
{ toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ }.toFun a ⊔
{ toFun := ⇑e.symm, map_sup' := ⋯, map_inf' := ⋯ }.toFun b | null | false |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_eq_of_size_le_stop._proof_1_2 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {i : ℕ} {a : Array α} (i_1 : ℕ), i_1 + 1 ≤ (a.extract i).size → i_1 < (a.extract i).size | null | false |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.revMatchesAt_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt p pos pos' =
∃ (h : pos' ≠ s.startPos), pos = pos'.prev h ∧ p ((pos'.prev h).get ⋯) | null | false |
Std.Tactic.BVDecide.BoolExpr._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | (α : Type) → [SizeOf α] → SizeOf (Std.Tactic.BVDecide.BoolExpr α) | null | false |
AffineSubspace.direction_mk' | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (p : P) (direction : Submodule k V), (AffineSubspace.mk' p direction).direction = direction | The direction of an affine subspace constructed from a point and a direction. | true |
Aesop.RuleBuilderOptions.casesOn | Aesop.Builder.Basic | {motive : Aesop.RuleBuilderOptions → Sort u} →
(t : Aesop.RuleBuilderOptions) →
((immediatePremises? : Option (Array Lean.Name)) →
(indexingMode? : Option Aesop.IndexingMode) →
(casesPatterns? : Option (Array Aesop.CasesPattern)) →
(pattern? : Option Lean.Term) →
(trans... | null | false |
_private.Lean.Util.SCC.0.Lean.SCC.updateLowLinkOf | Lean.Util.SCC | {α : Type} → [inst : BEq α] → [inst_1 : Hashable α] → α → Option ℕ → Lean.SCC.M α Unit | null | true |
instLinearOrderedAddCommGroupWithTopOrderDualAdditive._proof_1 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : LinearOrderedCommGroupWithZero α] (x : (Additive α)ᵒᵈ), ⊤ + x = ⊤ | null | false |
_private.Mathlib.Data.List.Pairwise.0.List.Pairwise.rel_head_of_rel_head_head._proof_1_4 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} {l : List α} {a : α},
List.Pairwise R l → ∀ (ha : a ∈ l), R (l.head ⋯) (l.head ⋯) → R (l.head ⋯) a | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.toReal_add_eq_toReal_add_toReal._simp_1_9 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
Aesop.MVarClusterData.ctorIdx | Aesop.Tree.Data | {Goal Rapp : Type} → Aesop.MVarClusterData Goal Rapp → ℕ | null | false |
Finset.powersetCard_nonempty_of_le | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} {s : Finset α}, n ≤ s.card → (Finset.powersetCard n s).Nonempty | **Alias** of the reverse direction of `Finset.powersetCard_nonempty`. | true |
Nat.divisorsAntidiagonal_eq_prod_filter_of_le | Mathlib.NumberTheory.Divisors | ∀ {n N : ℕ}, n ≠ 0 → n ≤ N → n.divisorsAntidiagonal = {x ∈ Finset.Ioc 0 N ×ˢ Finset.Ioc 0 N | x.1 * x.2 = n} | Useful lemma for reordering sums. | true |
CategoryTheory.ObjectProperty.instIsClosedUnderColimitsOfShapeFunctorPreservesColimitOfHasColimitsOfShape | Mathlib.CategoryTheory.ObjectProperty.FunctorCategory.PreservesLimits | ∀ {J : Type u_1} {C : Type u_2} (K : Type u_3) (K' : Type u_4) [inst : CategoryTheory.Category.{v_1, u_3} K]
[inst_1 : CategoryTheory.Category.{v_2, u_4} K'] [inst_2 : CategoryTheory.Category.{v_3, u_1} J]
[inst_3 : CategoryTheory.Category.{v_4, u_2} C] (F : CategoryTheory.Functor K J)
[CategoryTheory.Limits.HasC... | null | true |
LipschitzWith.hasFDerivAt_of_hasLineDerivAt_of_closure | Mathlib.Analysis.Calculus.Rademacher | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {C : NNReal} [FiniteDimensional ℝ E] {f : E → F},
LipschitzWith C f →
∀ {s : Set E},
Metric.sphere 0 1 ⊆ closure s →
∀ {L : E →L[ℝ] F} {x : E}, (∀ v ∈... | If a Lipschitz functions has line derivatives in a dense set of directions, all of them given by
a single continuous linear map `L`, then it admits `L` as Fréchet derivative. | true |
Lean.Grind.Ring.OfSemiring.toQ_inj | Init.Grind.Ring.Envelope | ∀ {α : Type u} [inst : Lean.Grind.Semiring α] [Lean.Grind.AddRightCancel α] {a b : α}, ↑a = ↑b → a = b | null | true |
IsAddUnit.of_leftInverse | Mathlib.Algebra.Group.Units.Hom | ∀ {F : Type u_1} {G : Type u_2} {M : Type u_3} {N : Type u_4} [inst : FunLike F M N] [inst_1 : FunLike G N M]
[inst_2 : AddMonoid M] [inst_3 : AddMonoid N] [AddMonoidHomClass G N M] {f : F} {x : M} (g : G),
Function.LeftInverse ⇑g ⇑f → IsAddUnit (f x) → IsAddUnit x | null | true |
Filter.instNSMul.eq_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : Add α], Filter.instNSMul = { smul := fun n s => nsmulRec n s } | null | true |
CategoryTheory.FreeBicategory.normalize._proof_8 | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ (B : Type u_1) [inst : Quiver B] {a b c : CategoryTheory.FreeBicategory B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c),
CategoryTheory.eqToHom ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToIso ⋯).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheory... | null | false |
Array.findSome?_eq_none_iff._simp_1 | Init.Data.Array.Find | ∀ {α : Type u_1} {α_1 : Type u_2} {p : α → Option α_1} {xs : Array α},
(Array.findSome? p xs = none) = ∀ x ∈ xs, p x = none | null | false |
GradedRingHom.one_def | Mathlib.RingTheory.GradedAlgebra.RingHom | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_6} [inst : Semiring A] [inst_1 : SetLike σ A] {𝒜 : ι → σ},
1 = GradedRingHom.id 𝒜 | null | true |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.msb_ofFnLE._proof_1_6 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool), (BitVec.ofFnLE f).msb = if h : ¬n = 0 then f ⟨n - 1, ⋯⟩ else false | null | false |
CategoryTheory.RepresentablyFlat.mk._flat_ctor | Mathlib.CategoryTheory.Functor.Flat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D},
(∀ (X : D), CategoryTheory.IsCofiltered (CategoryTheory.StructuredArrow X F)) → CategoryTheory.RepresentablyFlat F | null | false |
CategoryTheory.Limits.BinaryBicone.instIsSplitEpiFst | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (c : CategoryTheory.Limits.BinaryBicone P Q), CategoryTheory.IsSplitEpi c.fst | null | true |
_private.Mathlib.CategoryTheory.ObjectProperty.LimitsClosure.0.CategoryTheory.ObjectProperty.strictLimitsClosureStep_strictLimitsClosureIter_eq_self._simp_1_2 | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Sort u_1} (P : α → CategoryTheory.ObjectProperty C)
(X : C), (⨆ a, P a) X = ∃ a, P a X | null | false |
CategoryTheory.EnrichedOrdinaryCategory.homEquiv_comp._autoParam | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | Lean.Syntax | null | false |
Filter.coprod_cocompact | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y],
(Filter.cocompact X).coprod (Filter.cocompact Y) = Filter.cocompact (X × Y) | The coproduct of the cocompact filters on two topological spaces is the cocompact filter on
their product. | true |
UnitAddTorus.mFourierBasis | Mathlib.Analysis.Fourier.AddCircleMulti | {d : Type u_1} → [inst : Fintype d] → HilbertBasis (d → ℤ) ℂ ↥(MeasureTheory.Lp ℂ 2 MeasureTheory.volume) | We define `mFourierBasis` to be a `ℤᵈ`-indexed Hilbert basis for the `L²` space of functions
on `UnitAddTorus d`, which by definition is an isometric isomorphism from `L²(UnitAddTorus d)`
to `ℓ²(ℤᵈ, ℂ)`. | true |
Int8.and_self | Init.Data.SInt.Bitwise | ∀ {a : Int8}, a &&& a = a | null | true |
CategoryTheory.ObjectProperty.localEpi_top_eq_epimorphisms | Mathlib.CategoryTheory.MorphismProperty.LocalEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C],
⊤.localEpi = CategoryTheory.MorphismProperty.epimorphisms C | null | true |
Submodule.orthogonalBilin._proof_1 | Mathlib.LinearAlgebra.SesquilinearForm.Orthogonal | ∀ {R : Type u_4} {R₁ : Type u_6} {R₂ : Type u_3} {M : Type u_1} {M₁ : Type u_5} {M₂ : Type u_2} [inst : CommSemiring R]
[inst_1 : CommSemiring R₁] [inst_2 : CommSemiring R₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R₁ M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Mod... | null | false |
Real.rpowIntegrand₀₁_le_rpow_sub_two_mul_self | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p t x : ℝ}, p ∈ Set.Ioo 0 1 → 0 < t → 0 ≤ x → p.rpowIntegrand₀₁ t x ≤ t ^ (p - 2) * x | null | true |
Std.DTreeMap.Internal.Impl.getKeyLE? | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → [Ord α] → α → Std.DTreeMap.Internal.Impl α β → Option α | Implementation detail of the tree map | true |
StandardEtalePair.mk | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} →
[inst : CommRing R] →
(f : Polynomial R) →
f.Monic → (g : Polynomial R) → (∃ p₁ p₂ n, Polynomial.derivative f * p₁ + f * p₂ = g ^ n) → StandardEtalePair R | null | true |
CategoryTheory.Limits.CokernelCofork.IsColimit.ofπOp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {W' : Cᵒᵖ} (x : W' ⟶ Opposite.op Y),
CategoryTheory.CategoryStruct.comp x f.op = 0 → CategoryTheory.CategoryStruct.comp f x.unop = 0 | null | false |
IsometryEquiv.image_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] (h : α ≃ᵢ β) (x : α) (r : ℝ),
⇑h '' Metric.closedBall x r = Metric.closedBall (h x) r | null | true |
IsAlgClosure.isGalois | Mathlib.FieldTheory.Galois.Basic | ∀ (k : Type u_1) (K : Type u_2) [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] [IsAlgClosure k K]
[CharZero k], IsGalois k K | null | true |
String.Slice.takeEndWhile_eq_self_iff._simp_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.BackwardPattern pat] {s : String.Slice},
(s.takeEndWhile pat = s) = (s.revAll pat = true) | null | false |
CategoryTheory.Limits.limitFlipCompLimIsoLimitCompLim._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_5} {K : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
[CategoryTh... | null | false |
InfTopHom.mk | Mathlib.Order.Hom.BoundedLattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Min α] →
[inst_1 : Min β] →
[inst_2 : Top α] → [inst_3 : Top β] → (toInfHom : InfHom α β) → toInfHom.toFun ⊤ = ⊤ → InfTopHom α β | null | true |
_private.Init.Data.String.Lemmas.Intercalate.0.String.Slice.intercalate.go.eq_def | Init.Data.String.Lemmas.Intercalate | ∀ (acc : String) (s : String.Slice) (a : List String.Slice),
String.Slice.intercalate.go✝ acc s a =
match a with
| a :: as => String.Slice.intercalate.go✝ (acc ++ s ++ a) s as
| [] => acc | null | true |
IsAddUnit.add_iff | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] [IsDedekindFiniteAddMonoid M] {x y : M},
IsAddUnit (x + y) ↔ IsAddUnit x ∧ IsAddUnit y | null | true |
Aesop.RulePatternIndex.get | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM Aesop.RulePatternSubstMap | Get all substitutions of the rule patterns that match a subexpression of
`e`. Subexpressions containing bound variables are not considered. The returned
array may contain duplicates. | true |
WithTop.coe_wcovBy_top._simp_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (↑a ⩿ ⊤) = IsMax a | null | false |
_private.Lean.Compiler.InitAttr.0.Lean.initFn._@.Lean.Compiler.InitAttr.1632222590._hygCtx._hyg.2 | Lean.Compiler.InitAttr | IO (Lean.ParametricAttribute Lean.Name) | null | false |
Lean.Compiler.LCNF.CompilerM.State.mk | Lean.Compiler.LCNF.CompilerM | Lean.Compiler.LCNF.LCtx → ℕ → Lean.Compiler.LCNF.CompilerM.State | null | true |
List.Mem.tail | Init.Data.List.Basic | ∀ {α : Type u} {a : α} (b : α) {as : List α}, List.Mem a as → List.Mem a (b :: as) | A member of the tail of a list is a member of the list: `a ∈ l → a ∈ b :: l`. | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Model.0.Lean.Meta.Grind.Arith.Cutsat.getCutsatAssignment?.match_4 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Model | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((e : Lean.Expr) → motive (some e)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
AlgebraicGeometry.Scheme.ordHom._proof_1 | Mathlib.AlgebraicGeometry.OrderOfVanishing | ∀ {X : AlgebraicGeometry.Scheme} (z : ↥X), Order.coheight z = 1 → Ring.KrullDimLE 1 ↑(X.presheaf.stalk z) | null | false |
UInt8.ofNatLT_shiftLeft._proof_1 | Init.Data.UInt.Bitwise | 8 < UInt8.size | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.