name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Algebra.Presentation.aeval_val_relation | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Presentation R S ι σ) (i : σ), (MvPolynomial.aeval P.val) (P.relation i) = 0 | null | true |
_private.Mathlib.Data.Int.Bitwise.0.Int.shiftLeft_natCast_right._simp_1_2 | Mathlib.Data.Int.Bitwise | ∀ (n : ℕ), ↑n + 1 = ↑(n + 1) | null | false |
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Under.instIsAccessibleCategory._proof_1 | Mathlib.CategoryTheory.Presentable.Comma | ∀ {D : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} D] [CategoryTheory.IsAccessibleCategory.{u_1, u_2, u_3} D]
(X : D), CategoryTheory.IsAccessibleCategory.{u_1, u_2, max u_3 u_2} (CategoryTheory.Under X) | null | false |
SimpleGraph.triangleRemovalBound_mul_cube_lt | Mathlib.Combinatorics.SimpleGraph.Triangle.Removal | ∀ {ε : ℝ}, 0 < ε → SimpleGraph.triangleRemovalBound ε * ↑⌈4 / ε⌉₊ ^ 3 < 1 | null | true |
Matrix.toEuclideanCLM._proof_1 | Mathlib.Analysis.CStarAlgebra.Matrix | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n], SMulCommClass 𝕜 𝕜 (EuclideanSpace 𝕜 n) | null | false |
CategoryTheory.StructuredArrow.locallySmall | Mathlib.CategoryTheory.Comma.LocallySmall | ∀ {B : Type u₂} {T : Type u₃} [inst : CategoryTheory.Category.{v₂, u₂} B] [inst_1 : CategoryTheory.Category.{v₃, u₃} T]
(S : T) (T_1 : CategoryTheory.Functor B T) [CategoryTheory.LocallySmall.{w, v₂, u₂} B],
CategoryTheory.LocallySmall.{w, v₂, max u₂ v₃} (CategoryTheory.StructuredArrow S T_1) | null | true |
MeasurableSet.exists_isClosed_diff_lt | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace α]
[OpensMeasurableSpace α] [μ.WeaklyRegular] ⦃A : Set α⦄,
MeasurableSet A → μ A ≠ ⊤ → ∀ {ε : ENNReal}, ε ≠ 0 → ∃ F ⊆ A, IsClosed F ∧ μ (A \ F) < ε | **Alias** of `MeasurableSet.exists_isClosed_sdiff_lt`. | true |
TopPair.Homotopy.mk.noConfusion | Mathlib.Topology.Category.TopPair | {X Y : TopPair} →
{f g : X ⟶ Y} →
{P : Sort u_1} →
{fst : TopCat.Homotopy (TopPair.Hom.fst f) (TopPair.Hom.fst g)} →
{snd : TopCat.Homotopy (TopPair.Hom.snd f) (TopPair.Hom.snd g)} →
{w :
autoParam
(CategoryTheory.CategoryStruct.comp
(Categ... | null | false |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeapImp.Heap.merge.eq_4 | Batteries.Data.PairingHeap | ∀ {α : Type u_1} (le : α → α → Bool) (a₁ : α) (c₁ sibling : Batteries.PairingHeapImp.Heap α) (a₂ : α)
(c₂ sibling_1 : Batteries.PairingHeapImp.Heap α),
Batteries.PairingHeapImp.Heap.merge le (Batteries.PairingHeapImp.Heap.node a₁ c₁ sibling)
(Batteries.PairingHeapImp.Heap.node a₂ c₂ sibling_1) =
if le a₁ ... | null | true |
IsOpenMap.functorNhds_map | Mathlib.Topology.Category.TopCat.OpenNhds | ∀ {X Y : TopCat} {f : X ⟶ Y} (h : IsOpenMap ⇑(CategoryTheory.ConcreteCategory.hom f)) (x : ↑X)
{X_1 Y_1 : TopologicalSpace.OpenNhds x} (i : X_1 ⟶ Y_1), (h.functorNhds x).map i = h.functor.map i | null | true |
Submodule.instDistribMulActionSubtypeMemTorsion'._proof_2 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : CommMonoid S] [inst_4 : DistribMulAction S M] [inst_5 : SMulCommClass S R M], Function.Injective fun a => ↑a | null | false |
_private.Init.Data.List.Impl.0.List.modifyTR_go_eq.match_1_1 | Init.Data.List.Impl | ∀ {α : Type u_1} (motive : List α → ℕ → Prop) (x : List α) (x_1 : ℕ),
(∀ (i : ℕ), motive [] i) →
(∀ (a : α) (l : List α), motive (a :: l) 0) →
(∀ (a : α) (l : List α) (i : ℕ), motive (a :: l) i.succ) → motive x x_1 | null | false |
SetLike.ext | Mathlib.Basic.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (∀ (x : B), x ∈ p ↔ x ∈ q) → p = q | Note: implementers of `SetLike` must copy this lemma in order to tag it with `@[ext]`. | true |
ContinuousMap.inseparable_coe._simp_1 | Mathlib.Topology.CompactOpen | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f g : C(X, Y)},
Inseparable ⇑f ⇑g = Inseparable f g | null | false |
Sym2.card_image_diag | Mathlib.Data.Sym.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), (Finset.image (Function.uncurry Sym2.mk) s.diag).card = s.card | The `diag` of `s : Finset α` is sent on a finset of `Sym2 α` of card `#s`. | true |
Set.finite_Iic | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [LocallyFiniteOrderBot α] (a : α), (Set.Iic a).Finite | null | true |
LinearPMap.«_aux_Mathlib_Analysis_InnerProductSpace_LinearPMap___macroRules_LinearPMap_term_†_1» | Mathlib.Analysis.InnerProductSpace.LinearPMap | Lean.Macro | null | false |
cfcₙ_def | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_3} {A : Type u_4} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | null | true |
TopologicalSpace.Clopens.isClopen | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s : TopologicalSpace.Clopens α), IsClopen ↑s | null | true |
_private.Mathlib.NumberTheory.Harmonic.ZetaAsymp.0.ZetaAsymptotics.term_one._simp_1_8 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
LeftOrdContinuous.map_sup | Mathlib.Order.OrdContinuous | ∀ {α : Type u} {β : Type v} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] {f : α → β},
LeftOrdContinuous f → ∀ (x y : α), f (x ⊔ y) = f x ⊔ f y | null | true |
MeasureTheory.integral_mul_left_eq_self | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_2} {E : Type u_3} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
{μ : MeasureTheory.Measure G} [inst_3 : Group G] [MeasurableMul G] [μ.IsMulLeftInvariant] (f : G → E) (g : G),
∫ (x : G), f (g * x) ∂μ = ∫ (x : G), f x ∂μ | Translating a function by left-multiplication does not change its integral with respect to a
left-invariant measure. | true |
Lean.HasConstCache.mk | Lean.Util.HasConstCache | {declNames : Array Lean.Name} → Std.HashMap.Raw Lean.Expr Bool → Lean.HasConstCache declNames | null | true |
List.isRotatedDecidable._proof_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u_1} [inst : DecidableEq α], LawfulBEq (List α) | null | false |
CategoryTheory.Linear.smulOfRingMorphism_smul_eq | Mathlib.CategoryTheory.Center.Linear | ∀ {R : Type w} [inst : Ring R] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] (φ : R →+* CategoryTheory.CatCenter C) {X Y : C} (a : R) (f : X ⟶ Y),
a • f = CategoryTheory.CategoryStruct.comp ((φ a).app X) f | null | true |
MonCat.shrinkFunctor | Mathlib.Algebra.Category.MonCat.Shrink | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor C MonCat) → [∀ (X : C), Small.{w, w'} ↑(F.obj X)] → CategoryTheory.Functor C MonCat | A functor `F : C ⥤ MonCat.{w'}` factors through `MonCat.{w}` if all the
monoids are `w`-small. | true |
Std.HashMap.unitOfList_singleton | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {k : α}, Std.HashMap.unitOfList [k] = ∅.insertIfNew k () | null | true |
_private.Batteries.Util.ProofWanted.0.WantedDep.mk.sizeOf_spec | Batteries.Util.ProofWanted | ∀ (name : Lean.Name) (ident : Lean.TSyntax `ident) (binderType : Lean.TSyntax `term) (isClass : Bool),
sizeOf { name := name, ident := ident, binderType := binderType, isClass := isClass } =
1 + sizeOf name + sizeOf ident + sizeOf binderType + sizeOf isClass | null | true |
Mathlib.Tactic.ClickSuggestions.instOrdRwKey | Mathlib.Tactic.ClickSuggestions.Rewrite | Ord Mathlib.Tactic.ClickSuggestions.RwKey | null | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.toArray_rco_add_add_eq_append._simp_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, (m...n).toArray = (m...n).toList.toArray | null | false |
ImportGraph.Widget.instRpcEncodableCopyProps | ImportGraph.Widget.Copy | Lean.Server.RpcEncodable ImportGraph.Widget.CopyProps | null | true |
_private.Init.Core.0.Subtype.ext.match_1_1 | Init.Core | ∀ {α : Sort u_1} {p : α → Prop} (motive : (x x_1 : { x // p x }) → ↑x = ↑x_1 → Prop) (x x_1 : { x // p x })
(x_2 : ↑x = ↑x_1),
(∀ (val : α) (property property_1 : p val), motive ⟨val, property⟩ ⟨val, property_1⟩ ⋯) → motive x x_1 x_2 | null | false |
_private.Mathlib.RingTheory.Localization.AtPrime.Basic.0.Localization.AtPrime.eq_maximalIdeal_iff_under_eq._simp_1_1 | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {I : Ideal R} [hI : I.IsPrime],
IsLocalRing.maximalIdeal (Localization I.primeCompl) = Ideal.map (algebraMap R (Localization.AtPrime I)) I | null | false |
MeasureTheory.integrableOn_Ioi_comp_mul_left_iff | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : ℝ → E) (c : ℝ) {a : ℝ},
0 < a →
(MeasureTheory.IntegrableOn (fun x => f (a * x)) (Set.Ioi c) MeasureTheory.volume ↔
MeasureTheory.IntegrableOn f (Set.Ioi (a * c)) MeasureTheory.volume) | null | true |
Rat.add_neg_cancel | Init.Data.Rat.Lemmas | ∀ (a : ℚ), a + -a = 0 | null | true |
Std.Time.Duration.mk.inj | Std.Time.Duration | ∀ {second : Std.Time.Second.Offset} {nano : Std.Time.Nanosecond.Span}
{proof : second.val ≥ 0 ∧ ↑nano ≥ 0 ∨ second.val ≤ 0 ∧ ↑nano ≤ 0} {second_1 : Std.Time.Second.Offset}
{nano_1 : Std.Time.Nanosecond.Span} {proof_1 : second_1.val ≥ 0 ∧ ↑nano_1 ≥ 0 ∨ second_1.val ≤ 0 ∧ ↑nano_1 ≤ 0},
{ second := second, nano := n... | null | true |
Std.Rxo.IsAlwaysFinite.finite | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.Rxo.IsAlwaysFinite α] (init hi : α),
∃ n, (Std.PRange.succMany? n init).elim True fun x => ¬x < hi | For every pair of elements `init` and `hi`, there exists a chain of successors that
results in an element that either has no successors or is greater than `hi`.
| true |
CategoryTheory.Localization.liftNatTrans_zero | Mathlib.CategoryTheory.Localization.Preadditive | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
(L : CategoryTheory.Functor C D) (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
(F₁ F₂ : CategoryTheor... | null | true |
Topology.IsEmbedding.firstCountableTopology | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {β : Type u_1} [inst : TopologicalSpace β] [FirstCountableTopology β]
{f : α → β}, Topology.IsEmbedding f → FirstCountableTopology α | null | true |
SchwartzMap.mkLM._proof_2 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {D : Type u_3} {E : Type u_4} {F : Type u_1} {G : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup D] [inst_5 : NormedSpace ℝ D]
[inst_6 : NormedAddCommGroup G] [inst_7 : NormedSpace ℝ G] (A : SchwartzMap D E... | null | false |
CategoryTheory.LiftsToColimit.mk.noConfusion | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{J : Type w} →
{inst_2 : CategoryTheory.Category.{w', w} J} →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | null | false |
Std.instHasRcoIntersectionNat_5 | Init.Data.Range.Polymorphic.Nat | Std.Rci.HasRcoIntersection ℕ | null | true |
LawfulApplicative.toLawfulFunctor | Init.Control.Lawful.Basic | ∀ {f : Type u → Type v} {inst : Applicative f} [self : LawfulApplicative f], LawfulFunctor f | null | true |
Filter.EventuallyEq.le | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f g : α → β}, f =ᶠ[l] g → f ≤ᶠ[l] g | null | true |
Std.Async.Selector.unregisterFn | Std.Async.Select | {α : Type} → Std.Async.Selector α → Std.Async.Async Unit | A cleanup function that is called once any `Selector` has won the `Selectable.one` race.
| true |
Lean.Compiler.LCNF.normFVar | Lean.Compiler.LCNF.CompilerM | {m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{t : Bool} →
[Lean.Compiler.LCNF.MonadFVarSubst m pu t] → [Monad m] → Lean.FVarId → m Lean.Compiler.LCNF.NormFVarResult | Normalize the given free variable.
See `normExprImp` for documentation on the `translator` parameter.
This function is meant to be used in contexts where the input free-variable is computationally relevant.
This function panics if the substitution is mapping `fvarId` to an expression that is not another free variable.
... | true |
CategoryTheory.ExactPairing._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_ExactPairing_coevaluation_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.PrettyPrinter.Unexpander | null | false |
Prod.seminormedRing._proof_17 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedRing α] [inst_1 : SeminormedRing β] (a : α × β), -a + a = 0 | null | false |
IsVAddRegular.of_vadd_eq_zero | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} {a : R} {s : S} [inst : AddMonoid S] [inst_1 : VAdd R M]
[inst_2 : VAdd R S] [inst_3 : AddAction S M] [VAddAssocClass R S M], a +ᵥ s = 0 → IsVAddRegular M s | An element of `S` admitting a left negative in `R` is `M`-regular. | true |
_private.Lean.Parser.Basic.0.Lean.Parser.recover._regBuiltin.Lean.Parser.recover.docString_1 | Lean.Parser.Basic | IO Unit | null | false |
fst_integral | Mathlib.MeasureTheory.Integral.Bochner.ContinuousLinearMap | ∀ {X : Type u_1} {E : Type u_3} {F : Type u_4} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace ℝ F]
[CompleteSpace F] {f : X → E × F}, MeasureTheory.Integrable f μ → (∫ (x : X), f x ∂μ).1 = ∫ (x... | null | true |
LinearOrder.strong_induction_of_finite | Mathlib.Order.Preorder.Finite | ∀ {α : Type u_4} [inst : LinearOrder α] [Finite α] {motive : α → Prop},
(∀ (j : α), (∀ k < j, motive k) → motive j) → ∀ (i : α), motive i | null | true |
Real.cosh_abs | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.cosh |x| = Real.cosh x | null | true |
_private.Batteries.Data.List.Lemmas.0.List.exists_of_replaceF.match_1_7 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(∀ (b' : α), x = some b' → motive (some b')) → (x = none → motive none) → motive x | null | false |
Inclusion.HypArg.recOn | Mathlib.Tactic.Inclusion.ExtensionAPI.Attr | {motive : Inclusion.HypArg → Sort u} →
(t : Inclusion.HypArg) →
((elemIdx setIdx proofIdx : ℕ) → motive { elemIdx := elemIdx, setIdx := setIdx, proofIdx := proofIdx }) → motive t | null | false |
Lean.StructureResolutionOrderConflict.recOn | Lean.Structure | {motive : Lean.StructureResolutionOrderConflict → Sort u} →
(t : Lean.StructureResolutionOrderConflict) →
((isDirectParent : Bool) →
(badParent : Lean.Name) →
(conflicts : Array (Bool × Lean.Name)) →
motive { isDirectParent := isDirectParent, badParent := badParent, conflicts := conf... | null | false |
Finset.sum_dite_eq | Mathlib.Algebra.BigOperators.Group.Finset.Piecewise | ∀ {ι : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (a : ι)
(b : (x : ι) → a = x → M), (∑ x ∈ s, if h : a = x then b x h else 0) = if a ∈ s then b a ⋯ else 0 | null | true |
UInt64.toUInt16_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), (a * b).toUInt16 = a.toUInt16 * b.toUInt16 | null | true |
SemimoduleCat.homAddEquiv | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} → [inst : Semiring R] → {M N : SemimoduleCat R} → (M ⟶ N) ≃+ (↑M →ₗ[R] ↑N) | `SemimoduleCat.Hom.hom` bundled as an additive equivalence. | true |
IsAdjoinRootMonic.coeff_root | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
(h : IsAdjoinRootMonic S f), 1 < f.natDegree → h.coeff h.root = Pi.single 1 1 | null | true |
nnnorm_add_eq_nnnorm_left | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] (x : E) {y : E}, ‖y‖₊ = 0 → ‖x + y‖₊ = ‖x‖₊ | null | true |
CategoryTheory.MonoidalClosed.id | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(x : C) → [inst_2 : CategoryTheory.Closed x] → CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ x ⟹ x | The C-identity morphism
`𝟙_ C ⟶ hom(x, x)`
used to equip `C` with the structure of a `C`-category | true |
_private.Mathlib.Tactic.Inclusion.Core.ToSet.0.Inclusion.IntervalBool.mem_true_iff._simp_1_1 | Mathlib.Tactic.Inclusion.Core.ToSet | ∀ {Iα : Type u_1} {α : Type u_2} [inst : Inclusion.ToSet Iα α] (a : α) (s : Iα), (a ∈ s) = (a ∈ Inclusion.ToSet.toSet s) | null | false |
instMulHomogeneousIdeal._proof_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : CommSemiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [GradedRing 𝒜], SetLike.GradedSMul 𝒜 𝒜 | null | false |
_private.Mathlib.InformationTheory.Hamming.0.eq_of_hammingDist_eq_zero._simp_1_3 | Mathlib.InformationTheory.Hamming | ∀ {α : Type u_1} {s : Finset α}, (s.card = 0) = (s = ∅) | null | false |
Lean.Doc.instReprDescItem.repr | Lean.DocString.Types | {α : Type u_1} → {β : Type u_2} → [Repr α] → [Repr β] → Lean.Doc.DescItem α β → ℕ → Std.Format | null | true |
CategoryTheory.Limits.biproduct.mapIso | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{f g : J → C} →
[inst_2 : CategoryTheory.Limits.HasBiproduct f] →
[inst_3 : CategoryTheory.Limits.HasBiproduct g] → ((b : J) → f b ≅ g b) → (⨁ f ≅ ⨁ g... | Given a collection of isomorphisms between corresponding summands of a pair of biproducts
indexed by the same type, we obtain an isomorphism between the biproducts. | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.FlatRank.0.AlgebraicGeometry.Scheme.Hom.isLocallyConstant_finrank._simp_1_1 | Mathlib.AlgebraicGeometry.Morphisms.FlatRank | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (f : X → Y),
IsLocallyConstant f = ∀ (x : X), ∃ U, IsOpen U ∧ x ∈ U ∧ ∀ x' ∈ U, f x' = f x | null | false |
Aesop.BuilderName.destruct.elim | Aesop.Rule.Name | {motive : Aesop.BuilderName → Sort u} →
(t : Aesop.BuilderName) → t.ctorIdx = 3 → motive Aesop.BuilderName.destruct → motive t | null | false |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.inj | Lean.DocString.Extension | ∀ {content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)}
{priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)} {titleString : String}
{title : Array (Lean.Doc.Inline Lean.ElabInline)} {content_1 : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)}
{priorParts_1 : Array (Lean.Doc... | null | true |
CategoryTheory.ProjectiveResolution.cochainComplexXIso.eq_1 | Mathlib.CategoryTheory.Abelian.Projective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {X : C} (R : CategoryTheory.ProjectiveResolution X) (n : ℤ) (k : ℕ)
(h : -↑k = n), R.cochainComplexXIso n k h = HomologicalComplex.extendXIso R.complex ComplexShape.embed... | null | true |
SheafOfModules.ιFree_freeMap_assoc | Mathlib.Algebra.Category.ModuleCat.Sheaf.Free | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {I J_1 : Type u} (f : I → J_1) (i : I) {Z : SheafOfModules R}
(h... | null | true |
VectorField.pullback_lieBracket_of_isSymmSndFDerivAt | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [CompleteSpace E]
{f : E → F} {V W : F → F} {x : E},
IsSymmSndFDerivAt 𝕜 f x →
ContDiffAt 𝕜 2 f x →
... | The Lie bracket commutes with taking pullbacks. This requires the function to have symmetric
second derivative. Version in a complete space. One could also give a version avoiding
completeness but requiring that `f` is a local diffeomorphism. | true |
Matroid.not_rankFinite | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) [M.RankInfinite], ¬M.RankFinite | null | true |
Algebra.discr_def | Mathlib.RingTheory.Discriminant | ∀ (A : Type u) {B : Type v} {ι : Type w} [inst : DecidableEq ι] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra A B] [inst_4 : Fintype ι] (b : ι → B), Algebra.discr A b = (Algebra.traceMatrix A b).det | null | true |
spectralAlgNorm_of_finiteDimensional_normal._proof_5 | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ (K : Type u_1) [inst : NormedField K] (L : Type u_2) [inst_1 : Field L] [inst_2 : Algebra K L]
[h_fin : FiniteDimensional K L] [hn : Normal K L] [IsUltrametricDist K] (x : L), spectralNorm K L x = 0 → x = 0 | null | false |
Polynomial.Chebyshev.derivative_T_eval_one | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {R : Type u_1} [inst : CommRing R] (n : ℤ),
Polynomial.eval 1 (Polynomial.derivative (Polynomial.Chebyshev.T R n)) = ↑n ^ 2 | null | true |
CategoryTheory.ShortComplex.homologyMap'_sub | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ φ' : S₁ ⟶ S₂} (h₁ : S₁.HomologyData) (h₂ : S₂.HomologyData),
CategoryTheory.ShortComplex.homologyMap' (φ - φ') h₁ h₂ =
CategoryTheory.ShortComplex.homologyMap' φ h₁ h... | null | true |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.eq.injEq | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {n : ℕ} {X : (k : ℕ) → k < n → (t : Type (max v w)) × (t → C)}
{k k' : ℕ} (hk : k < n) (hk' : k' < n) (j : (X k hk).fst) (j' : (X k' hk').fst)
(a a_1 : (X k hk).snd j ⟶ (X k' hk').snd j') (k_1 k'_1 : ℕ) (hk_1 : k_1 < n) (hk'_1 : k'_1 < n)
(j_1 : (X k_1 hk_1... | null | true |
HasFDerivWithinAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E}
{s : Set E}, HasFDerivWithinAt f f' s x → f x ≠ 0 → HasFDerivWithinAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') s x | null | true |
_private.Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar.0.BoundedContinuousFunction.separatesPoints_charPoly._simp_1_3 | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.getRewriteInterfaces.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Mathlib.Tactic.LibraryRewrite.Rewrite × Lean.FVarId → Sort u_1) →
(x : Mathlib.Tactic.LibraryRewrite.Rewrite × Lean.FVarId) →
((rw : Mathlib.Tactic.LibraryRewrite.Rewrite) → (fvarId : Lean.FVarId) → motive (rw, fvarId)) → motive x | null | false |
DirectLimit.instDivisionRing._proof_21 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
Algebra.SubmersivePresentation.mvPolynomial | Mathlib.RingTheory.Extension.Presentation.Submersive | (R : Type u) → (ι : Type w) → [inst : CommRing R] → Algebra.SubmersivePresentation R (MvPolynomial ι R) ι PEmpty.{t + 1} | The canonical submersive `R`-presentation of the polynomial algebra `MvPolynomial ι R`,
with generators `X` indexed by `ι` and no relations. | true |
CategoryTheory.ComonadHom.app_ε | Mathlib.CategoryTheory.Monad.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {M N : CategoryTheory.Comonad C}
(self : CategoryTheory.ComonadHom M N) (X : C),
CategoryTheory.CategoryStruct.comp (self.app X) (N.ε.app X) = M.ε.app X | null | true |
CategoryTheory.Limits.kernelForkBiproductToSubtype._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : Type} [inst_2 : Finite K] [inst_3 : CategoryTheory.Limits.HasFiniteBiproducts C] (f : K → C) (p : K → Prop),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biproduct.fromSubtype f pᶜ)
... | null | false |
multiplicity_self | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [IsCancelMulZero α] {a : α},
FiniteMultiplicity a a → multiplicity a a = 1 | null | true |
Lean.Meta.hasAssignableLevelMVar._f | Lean.Meta.HasAssignableMVar | (x : Lean.Level) → Lean.Level.below x → Lean.MetaM Bool | null | false |
SimpleGraph.edgeFinset_inj._simp_1 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} {G₁ G₂ : SimpleGraph V} [inst : Fintype ↑G₁.edgeSet] [inst_1 : Fintype ↑G₂.edgeSet],
(G₁.edgeFinset = G₂.edgeFinset) = (G₁ = G₂) | null | false |
Lean.Elab.Tactic.Grind.SimpCacheKey | Lean.Elab.Tactic.Grind.Basic | Type | Cache key for `Sym.simp` variant invocations. | true |
CategoryTheory.Limits.WalkingMulticospan.instFinCategoryOfLOfDecidableEqR._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (a b : J.R),
a = b → CategoryTheory.Limits.WalkingMulticospan.right a = CategoryTheory.Limits.WalkingMulticospan.right b | null | false |
Finsupp.subtypeDomain | Mathlib.Data.Finsupp.Basic | {α : Type u_1} → {M : Type u_5} → [inst : Zero M] → (p : α → Prop) → (α →₀ M) → Subtype p →₀ M | `subtypeDomain p f` is the restriction of the finitely supported function `f` to subtype `p`. | true |
locallyFinite_support_iff | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_1} {M : Type u_7} {ι : Type u_9} [inst : TopologicalSpace X] [inst_1 : Zero M] {f : ι → X → M},
(LocallyFinite fun i => Function.support (f i)) ↔ LocallyFinite fun i => tsupport (f i) | null | true |
Equiv.Perm.permGroup._proof_6 | Mathlib.Algebra.Group.End | ∀ {α : Type u_1} (x : ℕ) (x_1 : Equiv.Perm α), x_1 ^ (x + 1) = x_1 ^ x * x_1 | null | false |
Homeomorph.sumPiEquivProdPi | Mathlib.Topology.Homeomorph.Lemmas | (S : Type u_5) →
(T : Type u_6) →
(A : S ⊕ T → Type u_7) →
[inst : (st : S ⊕ T) → TopologicalSpace (A st)] →
((st : S ⊕ T) → A st) ≃ₜ ((s : S) → A (Sum.inl s)) × ((t : T) → A (Sum.inr t)) | The product over `S ⊕ T` of a family of topological spaces
is homeomorphic to the product of (the product over `S`) and (the product over `T`).
This is `Equiv.sumPiEquivProdPi` as a `Homeomorph`.
| true |
Lean.Grind.LinarithConfig.lax._inherited_default | Init.Grind.Config | Bool | null | false |
FormalMultilinearSeries.leftInv._proof_32 | Mathlib.Analysis.Analytic.Inverse | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
_private.Mathlib.FieldTheory.Perfect.0.MonoidHom.map_iterate_frobeniusEquiv_symm._simp_1_1 | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] (f : R →* S) (p : ℕ)
[inst_2 : ExpChar R p] [inst_3 : ExpChar S p] (x : R) (n : ℕ),
(⇑(frobenius S p))^[n] (f x) = f ((⇑(frobenius R p))^[n] x) | null | false |
fderiv_star | Mathlib.Analysis.Calculus.FDeriv.Star | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : StarRing 𝕜] {E : Type u_2} [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace 𝕜 E] {F : Type u_3} [inst_4 : NormedAddCommGroup F] [inst_5 : StarAddMonoid F]
[inst_6 : NormedSpace 𝕜 F] [inst_7 : StarModule 𝕜 F] [inst_8 : ContinuousStar F] {f : E ... | null | true |
MonoidHom.toOneHom_injective | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N], Function.Injective MonoidHom.toOneHom | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.