name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.Real.rpowIntegrand₀₁_eq_sub._proof_1_2 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p : ℝ}, p ≠ 1 → ¬p + -1 = 0 | null | false |
Lean.Lsp.SignatureHelpTriggerKind.invoked.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SignatureHelpTriggerKind.invoked = 1 | null | true |
PSigma.Lex.linearOrder._proof_1 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)]
(a b : Σₗ' (i : ι), α i), a ≤ b ∨ b ≤ a | null | false |
ReaderT.run_orElse | Batteries.Control.Lemmas | ∀ {m : Type u_1 → Type u_2} {ρ α : Type u_1} [inst : Monad m] [inst_1 : Alternative m] (x y : ReaderT ρ m α) (ctx : ρ),
(x <|> y).run ctx = (x.run ctx <|> y.run ctx) | null | true |
Nat.divisors_prime_pow | Mathlib.NumberTheory.Divisors | ∀ {p : ℕ} (pp : Nat.Prime p) (k : ℕ),
(p ^ k).divisors = Finset.map { toFun := fun x => p ^ x, inj' := ⋯ } (Finset.range (k + 1)) | null | true |
Quiver.Symmetrify.lift.match_1 | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} →
[inst : Quiver V] →
{X Y : Quiver.Symmetrify V} →
(motive : (X ⟶ Y) → Sort u_3) →
(x : X ⟶ Y) → ((g : X ⟶ Y) → motive (Sum.inl g)) → ((g : Y ⟶ X) → motive (Sum.inr g)) → motive x | null | false |
_private.Mathlib.Data.Set.Insert.0.Set.subset_pair_iff._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a b : α}, s ⊆ {a, b} ↔ ∀ x ∈ s, x = a ∨ x = b | null | false |
Order.Icc_subset_Ioc_pred_left | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Icc b a ⊆ Set.Ioc (Order.pred b) a | null | true |
Algebra.Presentation.compRelationAux | 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] →
{ι' : Type u_1} →
{σ' : Type u_2} →
{T : Type u_3} →
[inst_3 : CommRing T] →
... | A choice of pre-image of `Q.relation r` under the canonical
map `MvPolynomial (ι' ⊕ ι) R →ₐ[R] MvPolynomial ι' S` given by the evaluation of `P`. | true |
SemistandardYoungTableau.col_strict | Mathlib.Combinatorics.Young.SemistandardTableau | ∀ {μ : YoungDiagram} (T : SemistandardYoungTableau μ) {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → T i1 j < T i2 j | null | true |
MeasCat | Mathlib.MeasureTheory.Category.MeasCat | Type (u + 1) | The category of measurable spaces and measurable functions. | true |
Lean.Meta.DefEqContext._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.DefEqContext → ℕ | null | false |
Lean.Meta.instMonadMCtxMetaM | Lean.Meta.Basic | Lean.MonadMCtx Lean.MetaM | null | true |
Lean.OLeanLevel.server.elim | Lean.Environment | {motive : Lean.OLeanLevel → Sort u} → (t : Lean.OLeanLevel) → t.ctorIdx = 1 → motive Lean.OLeanLevel.server → motive t | null | false |
InnerProductSpace.Core.toSeminormedAddCommGroup._proof_4 | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), √(RCLike.re (inner 𝕜 (-x) (-x))) = √(RCLike.re (inner 𝕜 x x)) | null | false |
Std.ExtHashMap.getKey!_eq_of_contains | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
[inst_1 : Inhabited α] {k : α}, m.contains k = true → m.getKey! k = k | null | true |
TopologicalSpace.IsTopologicalBasis.recOn | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{s : Set (Set α)} →
{motive : TopologicalSpace.IsTopologicalBasis s → Sort u_1} →
(t_1 : TopologicalSpace.IsTopologicalBasis s) →
((exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂) →
(sUnion_eq... | null | false |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.mem_filter_key._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
_private.Init.Data.Array.Attach.0.Array.pmap_eq_self._simp_1_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {l : List α} {p : α → Prop} {hp : ∀ a ∈ l, p a} {f : (a : α) → p a → α},
(List.pmap f l hp = l) = ∀ (a : α) (h : a ∈ l), f a ⋯ = a | null | false |
Lean.Elab.Do.ReturnCont.mk.injEq | Lean.Elab.Do.Basic | ∀ (resultType : Lean.Expr) (k : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr) (resultType_1 : Lean.Expr)
(k_1 : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr),
({ resultType := resultType, k := k } = { resultType := resultType_1, k := k_1 }) =
(resultType = resultType_1 ∧ k = k_1) | null | true |
CategoryTheory.shiftEquiv'._proof_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ {A : Type u_1} [inst : AddGroup A] (i j : A), i + j = 0 → j + i = 0 | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.monoidalOppositeRightAction_actionHomLeft | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {d d' : D} (f : d ⟶ d') (c : Cᴹᵒᵖ),
CategoryTheory.MonoidalCategory.MonoidalR... | null | true |
Substring.Raw.hasBeq | Init.Data.String.Substring | BEq Substring.Raw | null | true |
LinearMap.applyₗ._proof_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {M₂ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂],
SMulCommClass R R M₂ | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.oangle_sign_smul_add_right._proof_1_3 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V),
(∀ (r' : ℝ), o.oangle x (r' • x + y) ≠ 0 ∧ o.oangle x (r' • x + y) ≠ ↑Real.pi) →
∀ z ∈ (fun r' => (x, r' • x + y)) '' Set.univ, ¬o.oangle z.1 z.2 = 0 ... | null | false |
Finset.sum_mul_boole | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonAssocSemiring R] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → R) (i : ι),
(∑ j ∈ s, f j * if i = j then 1 else 0) = if i ∈ s then f i else 0 | null | true |
Subgroup.top_lowerCentralSeries_prod | Mathlib.GroupTheory.Nilpotent | ∀ {G₁ : Type u_2} {G₂ : Type u_3} [inst : Group G₁] [inst_1 : Group G₂] (n : ℕ),
⊤.lowerCentralSeries n = (⊤.lowerCentralSeries n).prod (⊤.lowerCentralSeries n) | The ⊤-specialization of `lowerCentralSeries_prod`. | true |
Algebra.IsInvariant.recOn | Mathlib.RingTheory.Invariant.Defs | {A : Type u_1} →
{B : Type u_2} →
{G : Type u_3} →
[inst : CommSemiring A] →
[inst_1 : Semiring B] →
[inst_2 : Algebra A B] →
[inst_3 : Group G] →
[inst_4 : MulSemiringAction G B] →
{motive : Algebra.IsInvariant A B G → Sort u} →
... | null | false |
Representation.ofMulActionSelfAsModuleEquiv._proof_4 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Group G],
Function.LeftInverse (Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.invFun
(Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.toFun | null | false |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValidForSlice_sliceTo.match_1_3 | Init.Data.String.Basic | ∀ {s : String.Slice} {p : s.Pos} {off : String.Pos.Raw}
(motive : off ≤ p.offset ∧ String.Pos.Raw.IsValidForSlice s off → Prop)
(x : off ≤ p.offset ∧ String.Pos.Raw.IsValidForSlice s off),
(∀ (h₁ : off ≤ p.offset) (h₂ : off ≤ s.rawEndPos)
(h₃ : String.Pos.Raw.IsValid s.str (off.offsetBy s.startInclusive.off... | null | false |
AlgebraicGeometry.Scheme.Cover.copy._proof_2 | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.RespectsIso] {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (J : Type u_2)
(obj : J → AlgebraicGeometry.Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.face_le_horn_iff._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
Std.DHashMap.Const.get!_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α},
k ∉ m₂ → Std.DHashMap.Const.get! (m₁.union m₂) k = Std.DHashMap.Const.get! m₁ k | null | true |
absConvexHull_nonempty | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E}, ((absConvexHull 𝕜) s).Nonempty ↔ s.Nonempty | null | true |
ENNReal.tsum_eq_iSup_nat | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = ⨆ i, ∑ a ∈ Finset.range i, f a | null | true |
ZFSet.vonNeumann_inj._simp_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, (ZFSet.vonNeumann a = ZFSet.vonNeumann b) = (a = b) | null | false |
Option.instSMulCommClass | Mathlib.Algebra.Group.Action.Option | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : SMul N α] [SMulCommClass M N α],
SMulCommClass M N (Option α) | null | true |
CategoryTheory.Pretriangulated.Triangle.instZeroHom._proof_6 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} [inst_2 : CategoryTheory.Preadditive C]
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive],
CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shi... | null | false |
CategoryTheory.PreOneHypercover.map_Y | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D)
(x x_1 : (CategoryTheory.PreZeroHypercover.map F E.toPreZeroHypercover).I₀) (j : E.I₁ x x_1),
(E.map F).Y j = F.o... | null | true |
Polynomial.roots_expand_map_frobenius | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : ℕ} [inst_2 : ExpChar R p] {f : Polynomial R}
[PerfectRing R p], Multiset.map (⇑(frobenius R p)) ((Polynomial.expand R p) f).roots = p • f.roots | null | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.restoreM_ReaderT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | null | false |
Profinite.NobelingProof.πs._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] (o : Ordinal.{u_1}),
Continuous (Profinite.NobelingProof.ProjRestrict C fun x => Profinite.NobelingProof.ord I x < o) | null | false |
Denumerable.lower_raise._f | Mathlib.Logic.Equiv.Multiset | ∀ (x : List ℕ) (f : List.below (motive := fun x => ∀ (x_1 : ℕ), Denumerable.lower (Denumerable.raise x x_1) x_1 = x) x)
(x_1 : ℕ), Denumerable.lower (Denumerable.raise x x_1) x_1 = x | null | false |
Ideal.instIsTwoSided | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : CommSemiring α] (I : Ideal α), I.IsTwoSided | null | true |
_private.Mathlib.AlgebraicTopology.DoldKan.NCompGamma.0.Fin.succ.match_1.splitter | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | {n : ℕ} → (motive : Fin n → Sort u_1) → (x : Fin n) → ((i : ℕ) → (h : i < n) → motive ⟨i, h⟩) → motive x | null | true |
String.Slice.Pattern.Model.IsValidRevSearchFrom.startPos_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {p : s.Pos}
{l : List (String.Slice.Pattern.SearchStep s)},
p = s.startPos → l = [] → String.Slice.Pattern.Model.IsValidRevSearchFrom pat p l | null | true |
CategoryTheory.Quiv.lift_map | Mathlib.CategoryTheory.Category.Quiv | ∀ {V : Type u} [inst : Quiver V] {C : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} C] (F : V ⥤q C)
{X Y : CategoryTheory.Paths V} (f : X ⟶ Y),
(CategoryTheory.Quiv.lift F).map f = CategoryTheory.composePath (F.mapPath f) | null | true |
_private.Mathlib.Tactic.Use.0.Mathlib.Tactic.applyTheConstructor.match_9 | Mathlib.Tactic.Use | (motive : List Lean.Name → Sort u_1) →
(x : List Lean.Name) → ((ctor : Lean.Name) → motive [ctor]) → ((x : List Lean.Name) → motive x) → motive x | null | false |
Std.DTreeMap.Raw.Equiv.maxKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.maxKey! = t₂.maxKey! | null | true |
SeminormedAddGroup.toNorm | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → [self : SeminormedAddGroup E] → Norm E | null | true |
PresheafOfModules.isoMk._proof_8 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X)
(naturality :
∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (M₁.map f)
((ModuleCat.restrictScalars (RingCa... | null | false |
CochainComplex.shiftFunctorAdd'._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (n₁ n₂ n₁₂ : ℤ)
(h : n₁ + n₂ = n₁₂) (K : CochainComplex C ℤ) (x x_1 : ℤ),
CategoryTheory.CategoryStruct.comp (K.shiftFunctorObjXIso n₁₂ x (x + n₂ + n₁) ⋯).hom
((((CochainComplex.shiftFunctor C n₁).comp (Coch... | null | false |
ModN.basis._proof_7 | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ {G : Type u_1} [inst : AddCommGroup G] {n : ℕ} [NeZero n] {ι : Type u_2} (b : Module.Basis ι ℤ G)
(hker :
((LinearMap.lsmul ℤ G) ↑n).range ≤
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr).ker),
Function.Injective
⇑(AddMonoidHom.toZModLinearMap n
(((Linea... | null | false |
_private.Mathlib.Data.List.Sort.0.List.Pairwise.eq_of_mem_iff._proof_1_2 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l₁ l₂ : List α}, (∀ (a : α), a ∈ l₁ ↔ a ∈ l₂) → l₂ ⊆ l₁ | null | false |
deriv_neg_left_of_sign_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {x₀ : ℝ},
(∀ᶠ (x : ℝ) in nhdsWithin x₀ {x₀}ᶜ, SignType.sign (deriv f x) = SignType.sign (x - x₀)) →
∀ᶠ (b : ℝ) in nhdsWithin x₀ (Set.Iio x₀), deriv f b < 0 | null | true |
MeasureTheory.stoppedValue.congr_simp | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] (u u_1 : ι → Ω → β),
u = u_1 →
∀ (τ τ_1 : Ω → WithTop ι),
τ = τ_1 → ∀ (a a_1 : Ω), a = a_1 → MeasureTheory.stoppedValue u τ a = MeasureTheory.stoppedValue u_1 τ_1 a_1 | null | true |
_private.Aesop.Script.OptimizeSyntax.0.Aesop.optimizeFocusRenameI.match_1 | Aesop.Script.OptimizeSyntax | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((ns : Array (Lean.TSyntax `ident)) → motive (some ns)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscreteWithin_accPt._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} [inst : TopologicalSpace X] {S T : Set X},
(S ∈ Filter.codiscreteWithin T) = ∀ x ∈ T, Disjoint (nhdsWithin x {x}ᶜ) (Filter.principal (T \ S)) | null | false |
Std.Tactic.BVDecide.BVExpr.bin._override | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {w : ℕ} →
Std.Tactic.BVDecide.BVExpr w →
Std.Tactic.BVDecide.BVBinOp → Std.Tactic.BVDecide.BVExpr w → Std.Tactic.BVDecide.BVExpr w | null | false |
SimpleGraph.Walk.takeUntil_takeUntil | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v u : V} [inst : DecidableEq V] {w x : V} (p : G.Walk u v) (hw : w ∈ p.support)
(hx : x ∈ (p.takeUntil w hw).support), (p.takeUntil w hw).takeUntil x hx = p.takeUntil x ⋯ | null | true |
SSet.relativeCellComplexOfMono.l | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | {X Y : SSet} →
(i : X ⟶ Y) →
(d : ℕ) → SSet.relativeCellComplexOfMono.sigmaBoundary i d ⟶ SSet.relativeCellComplexOfMono.sigmaStdSimplex i d | the left morphism of the pushout square `isPushout i d`: this is
the coproduct of copies of the boundary inclusion `∂Δ[d] ⟶ Δ[d]` indexed
by the nondegenerate `d`-simplices of `Y` not in the range of `i`. | true |
_private.Mathlib.Analysis.InnerProductSpace.Defs.0.InnerProductSpace.Core.termExt_iff_1 | Mathlib.Analysis.InnerProductSpace.Defs | Lean.ParserDescr | null | true |
Matrix.Commute.zpow_right | Mathlib.LinearAlgebra.Matrix.ZPow | ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
{A B : Matrix n' n' R}, Commute A B → ∀ (m : ℤ), Commute A (B ^ m) | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_notMem_support._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M], Module.rank R M = ↑(Module.finrank R M) | null | false |
EIO.adapt_pure | Batteries.Lean.LawfulMonadLift | ∀ {ε₁ ε₂ α : Type} (f : ε₁ → ε₂) (a : α), EIO.adapt f (pure a) = pure a | null | true |
CategoryTheory.Discrete.costructuredArrowEquivalenceOfUnique._proof_9 | Mathlib.CategoryTheory.Discrete.StructuredArrow | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {T : Type u_2}
(F : CategoryTheory.Functor C (CategoryTheory.Discrete T)) (t : T) [inst_1 : Subsingleton T]
{X Y : CategoryTheory.CostructuredArrow F { as := t }} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id (Categ... | null | false |
_private.Mathlib.Algebra.Group.ForwardDiff.0.fwdDiff_iter_pow_eq_zero_of_lt._proof_1_3 | Mathlib.Algebra.Group.ForwardDiff | ∀ (n : ℕ) {j : ℕ}, j < n + 1 → ∀ i < j, i < n | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKeyD_eq_iff_getKey?_eq_self_and_forall._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
UniformSpace.ofCoreEq_toCore | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} (u : UniformSpace α) (t : TopologicalSpace α) (h : t = u.toCore.toTopologicalSpace),
UniformSpace.ofCoreEq u.toCore t h = u | null | true |
_private.Mathlib.RingTheory.Valuation.LocalSubring.0.Ideal.image_subset_nonunits_valuationSubring.match_1_1 | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_1} [inst : Field K] {A : Subring K} (I : Ideal ↥A) (motive : (∃ M, M.IsMaximal ∧ I ≤ M) → Prop)
(x : ∃ M, M.IsMaximal ∧ I ≤ M), (∀ (M : Ideal ↥A) (hM : M.IsMaximal) (le : I ≤ M), motive ⋯) → motive x | null | false |
CategoryTheory.Functor.leibnizPushout_obj_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) [inst_3 : CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryThe... | null | true |
List.takeListTR.go.eq_def | Batteries.Data.List.Basic | ∀ {α : Type u_1} (a : List ℕ) (a_1 : List α) (a_2 : Array (List α)),
List.takeListTR.go a a_1 a_2 =
match a, a_1, a_2 with
| [], xs, acc => (acc.toList, xs)
| n :: ns, xs, acc =>
match List.splitAt n xs with
| (xs₁, xs₂) => List.takeListTR.go ns xs₂ (acc.push xs₁) | null | true |
Prod.instMonoid._proof_2 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] (a : M × N), a * 1 = a | null | false |
CategoryTheory.MarkovCategory.discard_natural_assoc | Mathlib.CategoryTheory.MarkovCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MarkovCategory C] {X Y : C} (f : X ⟶ Y) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp Catego... | Process then discard equals discard directly. | true |
Lean.Server.FileWorker.DiagnosticsState._sizeOf_1 | Lean.Server.FileWorker.Utils | Lean.Server.FileWorker.DiagnosticsState → ℕ | null | false |
Vector.find?_eq_none | Init.Data.Vector.Find | ∀ {α : Type} {p : α → Bool} {n : ℕ} {l : Vector α n}, Vector.find? p l = none ↔ ∀ x ∈ l, ¬p x = true | null | true |
MeasureTheory.VectorMeasure.restrict_union_add_inter | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {M : Type u_4} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M]
[T2Space M] [inst_3 : ContinuousAdd M] {v : MeasureTheory.VectorMeasure α M} {s t : Set α},
MeasurableSet s → MeasurableSet t → v.restrict (s ∪ t) + v.restrict (s ∩ t) = v.restrict s + v.restrict t | null | true |
ite_and | Mathlib.Logic.Basic | ∀ {α : Sort u_1} (P Q : Prop) [inst : Decidable P] (a b : α) [inst_1 : Decidable Q],
(if P ∧ Q then a else b) = if P then if Q then a else b else b | null | true |
StandardEtalePair.equivAwayAdjoinRoot._proof_8 | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R),
(P.lift ((algebraMap (AdjoinRoot P.f) (Localization.Away ((AdjoinRoot.mk P.f) P.g))) (AdjoinRoot.root P.f)) ⋯).comp
(IsLocalization.liftAlgHom ⋯) =
AlgHom.id R (Localization.Away ((AdjoinRoot.mk P.f) P.g)) | null | false |
Module.Injective.extension_property | Mathlib.Algebra.Module.Injective | ∀ (R : Type uR) [inst : Ring R] [Small.{uM, uR} R] (M : Type uM) [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inj : Module.Injective R M] (P : Type uP) [inst_4 : AddCommGroup P] [inst_5 : Module R P] (P' : Type uP')
[inst_6 : AddCommGroup P'] [inst_7 : Module R P'] (f : P →ₗ[R] P'),
Function.Injective ⇑f → ∀ ... | null | true |
Nat.ModEq.of_natCast | Mathlib.Data.Nat.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoidWithOne M] [CharZero M] {a b n : ℕ}, ↑a ≡ ↑b [PMOD ↑n] → a ≡ b [MOD n] | **Alias** of the forward direction of `AddCommGroup.natCast_modEq_natCast`. | true |
RingQuot.Rel.sub_left | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Ring R] {r : R → R → Prop} ⦃a b c : R⦄, RingQuot.Rel r a b → RingQuot.Rel r (a - c) (b - c) | null | true |
CategoryTheory.Types.instPreservesColimitsOfSizeForgetTypeFun | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | CategoryTheory.Limits.PreservesColimitsOfSize.{u_1, u_2, u, u, u + 1, u + 1} (CategoryTheory.forget (Type u)) | null | true |
Multiset.coe_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : List α),
Multiset.countP p ↑l = List.countP (fun b => decide (p b)) l | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabPanic._regBuiltin.Lean.Elab.Term.elabPanic.declRange_3 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
MeasurableEmbedding.schroederBernstein._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α} {A B : Set α}, A ⊆ B → (g '' (f '' A)ᶜ)ᶜ ⊆ (g '' (f '' B)ᶜ)ᶜ | null | false |
DyckWord.rec | Mathlib.Combinatorics.Enumerative.DyckWord | {motive : DyckWord → Sort u} →
((toList : List DyckStep) →
(count_U_eq_count_D : List.count DyckStep.U toList = List.count DyckStep.D toList) →
(count_D_le_count_U :
∀ (i : ℕ), List.count DyckStep.D (List.take i toList) ≤ List.count DyckStep.U (List.take i toList)) →
motive
... | null | false |
SetLike.ext_iff | Mathlib.Data.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p = q ↔ ∀ (x : B), x ∈ p ↔ x ∈ q | null | true |
_private.Lean.Elab.ErrorUtils.0.List.toOxford._f | Lean.Elab.ErrorUtils | {α : Type u_1} → [Append α] → [Lean.HasOxfordStrings✝ α] → (x : List α) → List.below x → α | null | false |
MonoidHom.mem_ker._simp_2 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {M : Type u_7} [inst_1 : MulOneClass M] {f : G →* M} {x : G}, (x ∈ f.ker) = (f x = 1) | null | false |
SeminormedGroup.toContinuousENorm._proof_1 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_1} [inst : SeminormedGroup E], Continuous (ENNReal.ofNNReal ∘ nnnorm) | null | false |
GromovHausdorff.repGHSpaceMetricSpace._aux_6 | Mathlib.Topology.MetricSpace.GromovHausdorff | {p : GromovHausdorff.GHSpace} → p.Rep → p.Rep → ENNReal | null | false |
LinearMap.map_eq_zero_iff._simp_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {S : Type u_5} {M : Type u_8} {M₃ : Type u_11} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module S M₃] {σ : R →+* S}
(f : M →ₛₗ[σ] M₃), Function.Injective ⇑f → ∀ {x : M}, (f x = 0) = (x = 0) | null | false |
_private.Lean.AddDecl.0.Lean.addDecl._sparseCasesOn_5 | Lean.AddDecl | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Digraph.sdiff | Mathlib.Combinatorics.Digraph.Basic | {V : Type u_2} → SDiff (Digraph V) | The difference of two digraphs `x \ y` has the edges of `x` with the edges of `y` removed. | true |
Computability.Encoding._sizeOf_inst | Mathlib.Computability.Encoding | (α : Type u) → [SizeOf α] → SizeOf (Computability.Encoding α) | null | false |
ConvexOn.isMinOn_of_leftDeriv_eq_zero | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x : ℝ}, ConvexOn ℝ S f → x ∈ interior S → derivWithin f (Set.Iio x) x = 0 → IsMinOn f S x | null | true |
Matroid.closure_subset_closure_iff_subset_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax | null | false |
Std.HashSet.Equiv.congr_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ m₃ : Std.HashSet α}, m₁.Equiv m₂ → (m₃.Equiv m₁ ↔ m₃.Equiv m₂) | null | true |
Lean.Linter.linter.unusedVariables.analyzeTactics | Lean.Linter.UnusedVariables | Lean.Option Bool | Enables linting variables defined in tactic blocks, may be expensive for complex proofs | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.