name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgebraicGeometry.Scheme.Modules.restrictFunctorId_inv_app_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M : X.Modules} {U : X.Opens},
AlgebraicGeometry.Scheme.Modules.Hom.app (AlgebraicGeometry.Scheme.Modules.restrictFunctorId.inv.app M) U =
M.presheaf.map (CategoryTheory.eqToHom ⋯).op | null | true |
Function.graph | Mathlib.Data.Rel | {α : Type u_1} → {β : Type u_2} → (α → β) → SetRel α β | The graph of a function as a relation. | true |
CategoryTheory.Limits.IsLimit.pushout_zero_ext | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsConnected J] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_4 : CategoryTheory.Limits.HasPushouts C] [inst_5 : CategoryTheory.Limits.HasLimitsOfShape J C]
[CategoryTheory... | Detecting vanishing of a morphism factoring through a connected limit by pushing out along the
projections of the limit. | true |
CochainComplex.ConnectData.X | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → ChainComplex C ℕ → CochainComplex C ℕ → ℤ → C | Auxiliary definition for `ConnectData.cochainComplex`. | true |
CategoryTheory.Monad.MonadicityInternal.instHasColimitWalkingParallelPairParallelPairMapAppCounitObjOfHasCoequalizerAA | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D} (adj : F ⊣ G)
[∀ (A : adj.toMonad.Algebra), CategoryTheory.Limits.HasCoequalizer (F.map A.a) (adj.counit.app (F.obj A.A))] (B : D)... | null | true |
Quiver.homOfEq_trans | Mathlib.Combinatorics.Quiver.Basic | ∀ {V : Type u_1} [inst : Quiver V] {X Y X' Y' : V} (f : X ⟶ Y) (hX : X = X') (hY : Y = Y') {X'' Y'' : V}
(hX' : X' = X'') (hY' : Y' = Y''), Quiver.homOfEq (Quiver.homOfEq f hX hY) hX' hY' = Quiver.homOfEq f ⋯ ⋯ | null | true |
Monotone.ae_differentiableAt | Mathlib.Analysis.Calculus.Monotone | ∀ {f : ℝ → ℝ}, Monotone f → ∀ᵐ (x : ℝ), DifferentiableAt ℝ f x | A monotone real function is differentiable Lebesgue-almost everywhere. | true |
MonCat.monoidObj.eq_1 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J MonCat) (j : J),
MonCat.monoidObj F j = (F.obj j).str | null | true |
CategoryTheory.ComposableArrows.naturality'._auto_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | Lean.Syntax | null | false |
AList.lookup.eq_1 | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
AList.lookup a s = List.dlookup a s.entries | null | true |
_private.Mathlib.Analysis.Calculus.DSlope.0.differentiableAt_dslope_of_ne._simp_1_1 | Mathlib.Analysis.Calculus.DSlope | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E}, DifferentiableAt 𝕜 f x = DifferentiableWithinAt 𝕜 f... | null | false |
_private.Mathlib.GroupTheory.GroupAction.Primitive.0.MulAction.IsPreprimitive.exists_mem_smul_and_notMem_smul._simp_1_3 | Mathlib.GroupTheory.GroupAction.Primitive | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
String.Slice.Pos.Splits.rec | Init.Data.String.Lemmas.Splits | {s : String.Slice} →
{p : s.Pos} →
{t₁ t₂ : String} →
{motive : p.Splits t₁ t₂ → Sort u} →
((eq_append : s.copy = t₁ ++ t₂) → (offset_eq_rawEndPos : p.offset = t₁.rawEndPos) → motive ⋯) →
(t : p.Splits t₁ t₂) → motive t | null | false |
Std.TreeSet.Raw.get!_insertMany_list_of_not_mem_of_contains_eq_false | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : BEq α]
[Std.LawfulBEqCmp cmp] [inst_2 : Inhabited α],
t.WF → ∀ {l : List α} {k : α}, k ∉ t → l.contains k = false → (t.insertMany l).get! k = default | null | true |
String.Pos.Raw.isValidForSlice_iff_exists_append | Init.Data.String.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw},
String.Pos.Raw.IsValidForSlice s p ↔ ∃ t₁ t₂, s.copy = t₁ ++ t₂ ∧ p = t₁.rawEndPos | null | true |
Lean.Lsp.DidSaveTextDocumentParams | Lean.Data.Lsp.TextSync | Type | null | true |
Complex.sin_sub_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℕ), Complex.sin (x - ↑n * (2 * ↑Real.pi)) = Complex.sin x | null | true |
LinearEquiv.det_baseChange | Mathlib.LinearAlgebra.Charpoly.BaseChange | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Free R M]
[Module.Finite R M] (A : Type u_3) [inst_5 : CommRing A] [inst_6 : Algebra R A] (f : M ≃ₗ[R] M),
LinearEquiv.det (LinearEquiv.baseChange R A M M f) = (Units.map ↑(algebraMap R A)) (LinearEquiv.det f... | null | true |
BitVec.DivModState.recOn | Init.Data.BitVec.Bitblast | {w : ℕ} →
{motive : BitVec.DivModState w → Sort u} →
(t : BitVec.DivModState w) →
((wn wr : ℕ) → (q r : BitVec w) → motive { wn := wn, wr := wr, q := q, r := r }) → motive t | null | false |
_private.Mathlib.Combinatorics.Quiver.SingleObj.0.Quiver.SingleObj.toPrefunctor_symm_comp._simp_1_1 | Mathlib.Combinatorics.Quiver.SingleObj | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) | null | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preregular C] →
[inst_2 : CategoryTheory.FinitaryExtensive C] →
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type v))} →
(∀ (n : ℕ), CategoryTheory.Sheaf.IsLoca... | null | true |
_private.Mathlib.Computability.Primrec.List.0.Primrec.list_set.match_1_1 | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} (motive : ℕ × α → Prop) (x : ℕ × α), (∀ (n : ℕ) (v : α), motive (n, v)) → motive x | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_15 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i + 1 ≤ (List.findIdxs p (head :: tail) s).length → i < (List.findIdxs p (head :: tail) s).length | null | false |
Nat.ofDigits_lt_base_pow_length' | Mathlib.Data.Nat.Digits.Defs | ∀ {b : ℕ} {l : List ℕ}, (∀ x ∈ l, x < b + 2) → Nat.ofDigits (b + 2) l < (b + 2) ^ l.length | an n-digit number in base b + 2 is less than (b + 2)^n | true |
String.Pos.next.eq_1 | Init.Data.String.Basic | ∀ {s : String} (pos : s.Pos) (h : pos ≠ s.endPos), pos.next h = String.Pos.ofToSlice (pos.toSlice.next ⋯) | null | true |
Filter.CardinalGenerateSets.below | Mathlib.Order.Filter.CardinalInter | {α : Type u} →
{c : Cardinal.{u}} →
{g : Set (Set α)} →
{motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop} →
{a : Set α} → Filter.CardinalGenerateSets g a → Prop | null | true |
Std.Internal.List.getValueCast!_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {f : (a : α) → β a → Bool}
{l : List ((a : α) × β a)} {k : α} [inst_2 : Inhabited (β k)],
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCast! k (List.filter (fun p => f p.fst p.snd) l) =
(Option.filter (f k) (Std.Internal... | null | true |
MeasureTheory.L1.SimpleFunc.integralCLM'._proof_2 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ (α : Type u_1) (E : Type u_2) (𝕜 : Type u_3) [inst : NormedAddCommGroup E] {m : MeasurableSpace α}
(μ : MeasureTheory.Measure α) [inst_1 : NormedRing 𝕜] [inst_2 : Module 𝕜 E] [inst_3 : IsBoundedSMul 𝕜 E]
[inst_4 : NormedSpace ℝ E] [inst_5 : SMulCommClass ℝ 𝕜 E] (f : ↥(α →₁ₛ[μ] E)),
‖{ toFun := MeasureTheor... | null | false |
_private.Mathlib.Topology.Homeomorph.Defs.0.Homeomorph.isInducing._simp_1_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X], Topology.IsInducing id = True | null | false |
CommGroup.torsion.eq_1 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : CommGroup G], CommGroup.torsion G = { toSubmonoid := CommMonoid.torsion G, inv_mem' := ⋯ } | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_mul._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] [ExistsAddOfLE R] [MulPosStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R] {a b : R}, a < 0 → b < 0 → (0 < a * b) = True | null | false |
MulEquiv.withZero._proof_2 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_2} {β : Type u_1} [inst : Group α] [inst_1 : Group β] (e : α ≃* β) (x : WithZero β),
(WithZero.map' ↑e) ((WithZero.map' ↑e.symm) x) = x | null | false |
Lean.Server.RequestHandlerCompleteness.rec | Lean.Server.Requests | {motive : Lean.Server.RequestHandlerCompleteness → Sort u} →
motive Lean.Server.RequestHandlerCompleteness.complete →
((refreshMethod : String) →
(refreshIntervalMs : ℕ) →
motive (Lean.Server.RequestHandlerCompleteness.partial refreshMethod refreshIntervalMs)) →
(t : Lean.Server.RequestHan... | null | false |
CategoryTheory.Functor.LaxRightLinear.μᵣ_unitality._autoParam | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | Lean.Syntax | null | false |
HomologicalComplex.mapBifunctorDesc | Mathlib.Algebra.Homology.Bifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
{I₁ : Type u_4} →
{I₂ : Type u_5} →
{J : Type... | Constructor for morphisms from `(mapBifunctor K₁ K₂ F c).X j`. | true |
CategoryTheory.PreGaloisCategory.IsFundamentalGroup.rec | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
[inst_1 : CategoryTheory.GaloisCategory C] →
{G : Type u_1} →
[inst_2 : Group G] →
[inst_3 : (X : C) → MulAction G (F.obj X).obj] →
[inst_4 : TopologicalSpace... | null | false |
Lean.LBool.false.elim | Lean.Data.LBool | {motive : Lean.LBool → Sort u} → (t : Lean.LBool) → t.ctorIdx = 0 → motive Lean.LBool.false → motive t | null | false |
String.Slice.dropPrefix_char_eq_dropPrefix_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.dropPrefix c = s.dropPrefix fun x => x == c | null | true |
TopologicalSpace.Opens.mapId._proof_3 | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat),
CategoryTheory.CategoryStruct.comp { app := fun U => CategoryTheory.eqToHom ⋯, naturality := ⋯ }
{ app := fun U => CategoryTheory.eqToHom ⋯, naturality := ⋯ } =
CategoryTheory.CategoryStruct.id (TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)) | null | false |
WeierstrassCurve.Affine.CoordinateRing.quotientXYIdealEquiv._proof_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} {x : R} {y : Polynomial R},
(Ideal.map (Ideal.Quotient.mkₐ R (Ideal.span {W'.polynomial}))
(Ideal.span {Polynomial.C (Polynomial.X - Polynomial.C x), Polynomial.X - Polynomial.C y})).IsTwoSided | null | false |
CategoryTheory.IsKernelPair.equivalenceRelation._proof_1 | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f | null | false |
Std.Time.Day.Ordinal.instInhabitedOfYear._proof_1 | Std.Time.Date.Unit.Day | 1 ≤ 1 | null | false |
DeltaGenerated.instLargeCategory._proof_7 | Mathlib.Topology.Category.DeltaGenerated | autoParam
(∀ {X Y : DeltaGenerated} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f)
CategoryTheory.Category.id_comp._autoParam | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertEntry_perm_filter._simp_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} (a : α) {l₁ l₂ : List α}, (a :: l₁).Perm (a :: l₂) = l₁.Perm l₂ | null | false |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.instLawfulToForwardSearcherModelForallCharPropDefaultForwardSearcherForallBoolDecide._simp_1 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos : s.Pos}
{l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom p pos l =
String.Slice.Pattern.Model.IsValidSearchFrom (fun x => decide (p x)) pos l | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.mk | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convol... | null | true |
midpoint_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : Invertible 2] (x y : E), midpoint 𝕜 x y ∈ segment 𝕜 x y | null | true |
midpoint_le_right._simp_1 | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, (midpoint k a b ≤ b) = (a ≤ b) | null | false |
CategoryTheory.Monad.Algebra.Hom.mk.congr_simp | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A B : T.Algebra}
(f f_1 : A.A ⟶ B.A) (e_f : f = f_1)
(h : CategoryTheory.CategoryStruct.comp (T.map f) B.a = CategoryTheory.CategoryStruct.comp A.a f),
{ f := f, h := h } = { f := f_1, h := ⋯ } | null | true |
_private.Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition.0.Submodule.rank_le_one_iff_isPrincipal._simp_1_1 | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {K : Type u} {V : Type v} [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Module.Free K V], (Module.rank K V ≤ 1) = ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v | null | false |
_private.Lean.Elab.BuiltinCommand.0.Lean.Elab.Command.elabExit._regBuiltin.Lean.Elab.Command.elabExit_1 | Lean.Elab.BuiltinCommand | IO Unit | null | false |
AlternatingMap.mkContinuousLinear_norm_le_max | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {G : Type wG} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : SeminormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : Fintype... | null | true |
upperBounds_prod | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β},
s.Nonempty → t.Nonempty → upperBounds (s ×ˢ t) = upperBounds s ×ˢ upperBounds t | null | true |
CategoryTheory.Limits.KernelFork.mapIsoOfIsLimit_inv | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {kf : CategoryTheory.Limits.KernelFork f}
{kf' : CategoryTheory.Limits.KernelFork f'} (hf : CategoryTheory.Limits.IsLimit kf)
(hf' : CategoryTheory.Limits.I... | null | true |
Algebra.Generators.Hom.mk.sizeOf_spec | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} [inst_3 : CommRing R']
[inst_4 : CommRing S'] [inst_5 : Algebra R' S'] {P' : Algebra.Generators R' S' ι'} [inst_6 : Algebra S S']
... | null | true |
MvPolynomial.bind₂_monomial | Mathlib.Algebra.MvPolynomial.Monad | ∀ {σ : Type u_1} {R : Type u_3} {S : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
(f : R →+* MvPolynomial σ S) (d : σ →₀ ℕ) (r : R),
(MvPolynomial.bind₂ f) ((MvPolynomial.monomial d) r) = f r * (MvPolynomial.monomial d) 1 | null | true |
isMin_bot | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α], IsMin ⊥ | null | true |
_private.Lean.Meta.Tactic.Intro.0.Lean.Meta.mkAuxNameImp.match_1 | Lean.Meta.Tactic.Intro | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) →
(Unit → motive []) → ((n : Lean.Name) → (rest : List Lean.Name) → motive (n :: rest)) → motive x | null | false |
LinearMap.IsSymmetric.diagonalization_apply_self_apply | Mathlib.Analysis.InnerProductSpace.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{T : E →ₗ[𝕜] E} [inst_3 : FiniteDimensional 𝕜 E] (hT : T.IsSymmetric) (v : E) (μ : Module.End.Eigenvalues T),
(hT.diagonalization (T v)).ofLp μ = ↑T 1 μ • (hT.diagonalization v).ofLp μ | *Diagonalization theorem*, *spectral theorem*; version 1: A self-adjoint operator `T` on a
finite-dimensional inner product space `E` acts diagonally on the decomposition of `E` into the
direct sum of the eigenspaces of `T`. | true |
HeytAlg.instConcreteCategoryHeytingHomCarrier._proof_3 | Mathlib.Order.Category.HeytAlg | ∀ {X : HeytAlg} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
Lean.Meta.Grind.Filter.fvar | Lean.Meta.Tactic.Grind.Filter | Lean.FVarId → Lean.Meta.Grind.Filter | null | true |
_private.Mathlib.Condensed.Light.EffectiveEpi.0.instIsRegularEpiCategoryLightCondSet._proof_1 | Mathlib.Condensed.Light.EffectiveEpi | CategoryTheory.IsRegularEpiCategory LightCondSet | null | false |
CategoryTheory.MorphismProperty.Over.pullbackCongr_hom_app_left_fst_assoc | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P Q : CategoryTheory.MorphismProperty T}
[inst_1 : Q.IsMultiplicative] {X Y : T} {f : X ⟶ Y} [inst_2 : P.HasPullbacksAlong f] {g : X ⟶ Y}
[inst_3 : P.IsStableUnderBaseChangeAlong f] [inst_4 : Q.IsStableUnderBaseChange] (h : f = g) (A : P.Over Q Y) {Z :... | null | true |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.subst.match_3 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((val : Lean.Expr × Lean.Expr × Lean.Expr) → motive (some val)) → (Unit → motive none) → motive __do_lift | null | false |
_private.Init.Data.Fin.Lemmas.0.Fin.reverseInduction_castSucc_aux | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {motive : Fin (n + 1) → Sort u_1} {succ : (i : Fin n) → motive i.succ → motive i.castSucc} (i : Fin n) (j : ℕ)
(h : j < n + 1) (h2 : ↑i < j) (zero : motive ⟨j, h⟩),
Fin.reverseInduction.go succ i.castSucc j h ⋯ zero = succ i (Fin.reverseInduction.go succ i.succ j h h2 zero) | null | true |
RootPairing.smul_coroot_eq_of_root_eq_smul | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} [Finite ι]
[IsAddTorsionFree N] (i j : ι) (t : R), P.root j = t • P.root i → t • P.coroot j = P.coroot i | null | true |
Std.TreeSet.mem_insert_self | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α}, k ∈ t.insert k | null | true |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.insert._sparseCasesOn_7 | Lean.Meta.Tactic.Grind.Theorems | {motive : Lean.HeadIndex → Sort u} →
(t : Lean.HeadIndex) →
((constName : Lean.Name) → motive (Lean.HeadIndex.const constName)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.Array.Erase.0.Array.mem_eraseIdx_iff_getElem._simp_1_1 | Init.Data.Array.Erase | ∀ {α : Type u_1} {x : α} {l : List α} {k : ℕ}, (x ∈ l.eraseIdx k) = ∃ i, ∃ (h : i < l.length), i ≠ k ∧ l[i] = x | null | false |
Option.WeakPseudoEMetricSpace.OfIsOpenEmbedding._proof_2 | Mathlib.Topology.EMetricSpace.Weak | ∀ {α : Type u_1} [t : TopologicalSpace α] [m : WeakPseudoEMetricSpace α] [inst : EDist (Option α)],
inst = Option.toEDist → ∀ (x y : Option α), edist x y = edist y x | null | false |
Finset.mem_powersetCard._simp_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, (s ∈ Finset.powersetCard n t) = (s ⊆ t ∧ s.card = n) | null | false |
MeasureTheory.Measure.IsHaarMeasure.mk._flat_ctor | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_3} [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : MeasurableSpace G]
{μ : MeasureTheory.Measure G},
(∀ ⦃K : Set G⦄, IsCompact K → μ K < ⊤) →
(∀ (g : G), MeasureTheory.Measure.map (fun x => g * x) μ = μ) →
(∀ (U : Set G), IsOpen U → U.Nonempty → μ U ≠ 0) → μ.IsHaarMeasure | null | false |
BoxIntegral.Prepartition.instOrderTop | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} → {I : BoxIntegral.Box ι} → OrderTop (BoxIntegral.Prepartition I) | null | true |
CategoryTheory.LocalizerMorphism.arrow | Mathlib.CategoryTheory.Localization.LocalizerMorphism | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
CategoryTheory.LocalizerMorphism W₁ W₂ → CategoryTheory.Loca... | The localizer morphism from `W₁.arrow` to `W₂.arrow` that is induced by
`Φ : LocalizerMorphism W₁ W₂`. | true |
Lean.Lsp.instToJsonRange | Lean.Data.Lsp.BasicAux | Lean.ToJson Lean.Lsp.Range | null | true |
Units.instMulDistribMulAction._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Units | ∀ {M : Type u_1} {α : Type u_2} [inst : Monoid M] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction M α] (m : Mˣ)
(b₁ b₂ : α), ↑m • (b₁ * b₂) = ↑m • b₁ * ↑m • b₂ | null | false |
Affine.Simplex.faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_5} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] →
[inst_3 : AddTorsor V P] →
{n : ℕ} → [NeZero n] → Affine.Simplex k P n → Fin (n + 1) → Affine.Simplex k P (n - 1) | The face of a simplex with all but one point. | true |
UniformSpace.hausdorff._proof_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ (α : Type u_1) [inst : UniformSpace α],
Filter.Tendsto Prod.swap ((uniformity α).lift' hausdorffEntourage) ((uniformity α).lift' hausdorffEntourage) | null | false |
_private.Mathlib.Algebra.Algebra.Unitization.0.Unitization.isSelfAdjoint_inr._simp_1_1 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) | null | false |
DirectSum.decomposeAlgEquiv_apply | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : CommSemiring R]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (𝒜 : ι → Submodule R A) [inst_5 : GradedAlgebra 𝒜] (a : A),
(DirectSum.decomposeAlgEquiv 𝒜) a = (DirectSum.decompose 𝒜) a | null | true |
CategoryTheory.δ_naturality_assoc | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C)) {m n : M}
{X Y : C} (f : X ⟶ Y) [inst_3 : F.OplaxMonoidal] {Z : C} (h : (F.obj n).obj ((F.o... | null | true |
symmDiff_symmDiff_cancel_left | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedBooleanAlgebra α] (a b : α), symmDiff a (symmDiff a b) = b | null | true |
NumberField.instCommRingAdeleRing._proof_25 | Mathlib.NumberTheory.NumberField.AdeleRing | ∀ (R : Type u_1) (K : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (a : NumberField.AdeleRing R K), a * 0 = 0 | null | false |
PMF.binomial_apply_zero | Mathlib.Probability.ProbabilityMassFunction.Binomial | ∀ (p : NNReal) (h : p ≤ 1) (n : ℕ), (PMF.binomial p h n) 0 = (1 - ↑p) ^ n | null | true |
Ne.dite_ne_right_iff | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {P : Prop} [inst : Decidable P] {b : α} {A : P → α},
(∀ (h : P), A h ≠ b) → ((dite P A fun x => b) ≠ b ↔ P) | null | true |
Std.HashMap.size_insertIfNew | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
{v : β}, (m.insertIfNew k v).size = if k ∈ m then m.size else m.size + 1 | null | true |
CategoryTheory.EnrichedCat.bicategory._proof_14 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c d : CategoryTheory.EnrichedCat V} {f f' : CategoryTheory.EnrichedFunctor V ↑a ↑b} (η : f ⟶ f')
(g : CategoryTheory.EnrichedFunctor V ↑b ↑c) (h : CategoryTheory.EnrichedFunctor V ↑c ↑d),
CategoryTheor... | null | false |
_private.Mathlib.Lean.Meta.Simp.0.Lean.Meta.Simp.withoutTheorems.match_1 | Mathlib.Lean.Meta.Simp | {α : Type} →
(motive : α × Lean.Meta.Simp.State → Sort u_1) →
(__discr : α × Lean.Meta.Simp.State) → ((x : α) → (s : Lean.Meta.Simp.State) → motive (x, s)) → motive __discr | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_11 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ), 0 < table.size → table.size - 1 < table.size | null | false |
Nat.Partrec.Code.eval_eq_rfindOpt | Mathlib.Computability.PartrecCode | ∀ (c : Nat.Partrec.Code) (n : ℕ), c.eval n = Nat.rfindOpt fun k => Nat.Partrec.Code.evaln k c n | null | true |
SSet.horn₃₁.desc | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | {X : SSet} →
(f₀ f₂ f₃ : SSet.stdSimplex.obj { len := 2 } ⟶ X) →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₀ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) f₃ →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 1) f₀ =
CategoryTheory.CategoryStruct.comp (SSe... | The morphism `Λ[3, 1] ⟶ X` which is obtained by gluing three
morphisms `Δ[2] ⟶ X`. | true |
BoundedContinuousFunction._aux_Mathlib_Topology_ContinuousMap_Bounded_Basic___unexpand_BoundedContinuousFunction_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.RingTheory.Jacobson.Ring.0.IsLocalization.isMaximal_iff_isMaximal_disjoint._simp_1_2 | Mathlib.RingTheory.Jacobson.Ring | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
NormedAlgebra.restrictScalars._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_2) (𝕜' : Type u_3) (E : Type u_1) [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedRing E] [inst_4 : NormedAlgebra 𝕜' E] (r : 𝕜) (x : E),
(algebraMap 𝕜 E) r * x = x * (algebraMap 𝕜 E) r | null | false |
IsHomeomorph.surjective | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsHomeomorph f → Function.Surjective f | null | true |
SSet.stdSimplex.objMk₁_of_castSucc_lt | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplexOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)), j.castSucc < i → (SSet.stdSimplex.objMk₁ i) j = 0 | null | true |
HahnSeries.toIterate._proof_2 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
(x : HahnSeries (Lex (Γ × Γ')) R),
(Function.support fun g => { coeff := fun g' => x.coeff (g, g'), isPWO_support' := ⋯ }).IsPWO | null | false |
_private.Batteries.Data.List.Basic.0.List.dropSlice_zero₂.match_1_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : ℕ → List α → Prop) (x : ℕ) (x_1 : List α),
(∀ (a : Unit), motive 0 []) →
(∀ (head : α) (tail : List α), motive 0 (head :: tail)) →
(∀ (n : ℕ), motive n.succ []) → (∀ (n : ℕ) (x : α) (xs : List α), motive n.succ (x :: xs)) → motive x x_1 | null | false |
Rep.unitIso._proof_5 | Mathlib.RepresentationTheory.Rep.Iso | ∀ {k : Type u_2} {G : Type u_3} [inst : CommRing k] [inst_1 : Monoid G] (V : Rep.{u_1, u_2, u_3} k G),
Function.LeftInverse Rep.unitIsoAddEquiv.invFun Rep.unitIsoAddEquiv.toFun | null | false |
CategoryTheory.Iso.inv_ext' | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : Y ⟶ X},
CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.id X → g = f.inv | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.