name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
derivedSet | Mathlib.Topology.DerivedSet | {X : Type u_1} → [TopologicalSpace X] → Set X → Set X | The derived set of a set is the set of all accumulation points of it.
| true |
SupHom.rec | Mathlib.Order.Hom.Lattice | {α : Type u_6} →
{β : Type u_7} →
[inst : Max α] →
[inst_1 : Max β] →
{motive : SupHom α β → Sort u} →
((toFun : α → β) →
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b) →
motive { toFun := toFun, map_sup' := map_sup' }) →
(t : SupHom α... | null | false |
_private.Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid.0.Affine.Simplex.eq_centroid_of_forall_mem_median._proof_1_5 | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n),
(AffineIndependent k fun a => if h : a = 0 then ⋯ ▸ s.centroid else s.points a) →
AffineIndependent k fun x => if x = 0 then s.centr... | null | false |
BitVec.mk_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {h : 0 < 2 ^ w}, { toFin := ⟨0, h⟩ } = 0#w | null | true |
SSet.instIsStableUnderCoproductsMonomorphismsOfHasCoproductsType | Mathlib.AlgebraicTopology.SimplicialSet.Monomorphisms | ∀ [CategoryTheory.Limits.HasCoproducts (Type u)],
CategoryTheory.MorphismProperty.IsStableUnderCoproducts.{v', u, u + 1}
(CategoryTheory.MorphismProperty.monomorphisms SSet) | null | true |
Ideal.fiberIsoOfBijectiveResidueField._proof_7 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R' : Type u_1} [inst : CommRing R'] {q : Ideal R'} [inst_1 : q.IsPrime],
SMulCommClass R' q.ResidueField q.ResidueField | null | false |
_private.Mathlib.Analysis.Convex.Segment.0.mem_openSegment_translate._simp_1_2 | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} {G : Type u_4} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [AddRightMono 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : AddCommGroup G] [inst_5 : Module 𝕜 E] [inst_6 : AddTorsor G E]
[VAddCommClass G E E] (a : G) (b c : E), openSegment 𝕜 (a +ᵥ b) (a +ᵥ c) = a +ᵥ openSegment 𝕜 b c | null | false |
ContinuousLinearEquiv.comp_contDiffWithinAt_iff | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {s : Set E} {f : E → F} {x : E} {n : ... | Composition by continuous linear equivs on the left respects higher differentiability at a
point in a domain. | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_8 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_1} [inst : Fintype α] (x : α), (x ∈ Finset.univ) = True | null | false |
AlgebraicGeometry.Scheme.ProEt.forget | Mathlib.AlgebraicGeometry.Sites.Proetale | (S : AlgebraicGeometry.Scheme) → CategoryTheory.Functor S.ProEt (CategoryTheory.Over S) | The forgetful functor the pro-étale site of `S` to schemes over `S`. | true |
CategoryTheory.ObjectProperty.isThin_of_isSeparating_bot | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], ⊥.IsSeparating → Quiver.IsThin C | null | true |
Vector.append_assoc._proof_2 | Init.Data.Vector.Lemmas | ∀ {n m k : ℕ}, n + (m + k) = n + m + k | null | false |
CategoryTheory.Limits.uniqueFromInitial.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasInitial C] (P : C),
CategoryTheory.Limits.uniqueFromInitial P =
(CategoryTheory.Limits.isInitialEquivUnique (CategoryTheory.Functor.empty C) (⊥_ C))
CategoryTheory.Limits.initialIsInitial P | null | true |
Aesop.RuleStatsTotals.empty | Aesop.Stats.Basic | Aesop.RuleStatsTotals | null | true |
Lean.IR.IRType.usize | Lean.Compiler.IR.Basic | Lean.IR.IRType | null | true |
KummerDedekind.quotMapEquivQuotQuotMap._proof_4 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {x : S} {I : Ideal R}
[inst_3 : IsDomain R] [inst_4 : IsIntegrallyClosed R] [inst_5 : IsDedekindDomain S]
[inst_6 : Module.IsTorsionFree R S] (hx' : IsIntegral R x),
(Ideal.span {Polynomial.map (Ideal.Quotient.mk I) (... | null | false |
_private.Mathlib.Probability.Kernel.Representation.0.ProbabilityTheory.Kernel.exists_measurable_map_eq_unitInterval_aux._simp_1_12 | Mathlib.Probability.Kernel.Representation | ∀ {α : Type u_1} [inst : CompleteSemilatticeSup α] {s : Set α} {a : α}, (sSup s ≤ a) = ∀ b ∈ s, b ≤ a | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minView.match_3.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
(r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(l : Std.DTreeMap.Internal.Impl α β) →
(hl : l.Balanced) →
... | null | true |
CategoryTheory.Presieve.singleton_eq_iff_domain._simp_1 | Mathlib.CategoryTheory.Sites.Sieves.Presieve | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : Y ⟶ X),
CategoryTheory.Presieve.singleton f g = (f = g) | null | false |
_private.Mathlib.Topology.MetricSpace.GromovHausdorff.0.GromovHausdorff.instSecondCountableTopologyGHSpace._simp_7 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
sInfHom.ext | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] {f g : sInfHom α β},
(∀ (a : α), f a = g a) → f = g | null | true |
IsClub.csSup_mem | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrder α] {s t : Set α},
IsClub s → t ⊆ s → t.Nonempty → BddAbove t → sSup t ∈ s | null | true |
Std.WP.WP.Frames.recOn | Std.WP.Frame | {Prog : Type u} →
{Value : Type v} →
{Pred : Type w} →
{EPred : Type z} →
[inst : Std.WP.Assertion Pred] →
[inst_1 : Std.WP.Assertion EPred] →
[inst_2 : Std.WP.WP Prog Value Pred EPred] →
{R : Type t} →
{op : R → Pred → Pred} →
{x... | null | false |
Lean.IR.EmitLLVM.constIntSizeT | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} → ℕ → Lean.IR.EmitLLVM.M llvmctx (Lean.LLVM.Value llvmctx) | null | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence.0.Mathlib.Tactic.BicategoryLike.normalize.match_3 | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | (motive : Mathlib.Tactic.BicategoryLike.Mor₁ → Sort u_1) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) →
((e : Lean.Expr) → (a : Mathlib.Tactic.BicategoryLike.Obj) → motive (Mathlib.Tactic.BicategoryLike.Mor₁.id e a)) →
((e : Lean.Expr) →
(f g : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.T... | null | false |
CategoryTheory.ShortComplex.SnakeInput.functorL₃._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{X Y Z : CategoryTheory.ShortComplex.SnakeInput C} (f : X ⟶ Y) (g : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f g).f₃ = CategoryTheory.CategoryStruct.comp f.f₃ g.f₃ | null | false |
Fin.val_mk | Init.Data.Fin.Lemmas | ∀ {m n : ℕ} (h : m < n), ↑⟨m, h⟩ = m | null | true |
MulOpposite.instAddCommSemigroup | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [AddCommSemigroup α] → AddCommSemigroup αᵐᵒᵖ | null | true |
_private.Mathlib.Analysis.InnerProductSpace.l2Space.0.HilbertBasis.dense_span._simp_1_1 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
_private.Mathlib.NumberTheory.ModularForms.Bounds.0.ModularGroup.exists_bound_of_invariant_of_isBigO._simp_1_4 | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Std.ExtTreeMap.minKeyD_le_minKeyD_erase | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
t.erase k ≠ ∅ → ∀ {fallback : α}, (cmp (t.minKeyD fallback) ((t.erase k).minKeyD fallback)).isLE = true | null | true |
_private.Mathlib.NumberTheory.Chebyshev.0.Nat.lcmUpto_dvd_factorial._simp_1_2 | Mathlib.NumberTheory.Chebyshev | ∀ {m n : ℕ}, 0 < m → m ≤ n → (m ∣ n.factorial) = True | null | false |
_private.Mathlib.Order.OmegaCompletePartialOrder.0.OmegaCompletePartialOrder.Chain.pair.match_1.eq_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ (motive : ℕ → Sort u_1) (x : ℕ) (h_1 : Unit → motive 0) (h_2 : (x : ℕ) → motive x),
(x = 0 → False) →
(match x with
| 0 => h_1 ()
| x => h_2 x) =
h_2 x | null | true |
Lean.Elab.formatDeprecatedArgMsg | Lean.Elab.DeprecatedArg | Lean.Elab.DeprecatedArgEntry → Lean.MessageData | Format the deprecation warning message for a deprecated argument. | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.BifunctorCokernel.0.CategoryTheory.Limits.CokernelCofork.mapBifunctor._simp_2 | Mathlib.CategoryTheory.Limits.Preserves.BifunctorCokernel | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.WF.of_le.match_1_3 | Batteries.Data.BinomialHeap.Basic | ∀ {n' : ℕ} {α : Type u_1} {le : α → α → Bool}
(motive : (s : Batteries.BinomialHeap.Imp.Heap α) → Batteries.BinomialHeap.Imp.Heap.WF le n' s → Prop)
(s : Batteries.BinomialHeap.Imp.Heap α) (h : Batteries.BinomialHeap.Imp.Heap.WF le n' s),
(∀ (h : Batteries.BinomialHeap.Imp.Heap.WF le n' Batteries.BinomialHeap.Imp... | null | false |
LinearIsometryEquiv.toLinearEquiv_symm | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | true |
Nat.toArray_ric_eq_cons | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n : ℕ}, (*...=n).toArray = #[0] ++ (1...=n).toArray | null | true |
SimpleGraph.Subgraph.IsPerfectMatching.exists_of_isClique_supp | Mathlib.Combinatorics.SimpleGraph.Tutte | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V],
Even (Nat.card V) →
¬G.IsTutteViolator G.universalVerts →
(∀ (K : G.deleteUniversalVerts.coe.ConnectedComponent), G.deleteUniversalVerts.coe.IsClique K.supp) →
∃ M, M.IsPerfectMatching | If the universal vertices of a graph `G` decompose `G` into cliques such that the Tutte isn't
violated, then `G` has a perfect matching. | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_271 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
SimpleGraph.ediam_eq_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G : SimpleGraph α}, G.ediam = ⊤ ↔ ∀ b < ⊤, ∃ u v, b < G.edist u v | null | true |
List.Forall._unsafe_rec | Mathlib.Data.List.Defs | {α : Type u_1} → (α → Prop) → List α → Prop | null | false |
Std.DHashMap.Const.get?_empty | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {a : α}, Std.DHashMap.Const.get? ∅ a = none | null | true |
NormedAddGroup.toBornology._inherited_default | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
(dist : E → E → ℝ) →
(∀ (x y : E), dist x y = dist y x) → (∀ (x y z : E), dist x z ≤ dist x y + dist y z) → Bornology E | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.minView.match_3.splitter | Std.Data.DTreeMap.Internal.Operations | {α : Type u_1} →
{β : α → Type u_2} →
(r : Std.DTreeMap.Internal.Impl α β) →
(motive :
(l : Std.DTreeMap.Internal.Impl α β) →
l.Balanced → Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size → Sort u_3) →
(l : Std.DTreeMap.Internal.Impl α β) →
(hl : l.Balanced) →
... | null | true |
_private.Lean.Elab.ConfigEval.DeriveEvalTerm.0.Lean.Elab.ConfigEval.EvalTerm.resolveDottedAtomicNameForConstNamespace | Lean.Elab.ConfigEval.DeriveEvalTerm | Lean.Name → Lean.Ident → Lean.Elab.TermElabM String | Resolves `id` as if it were a dotted identifier for namespace `c`,
and returns `s` if the resolved name is of the form `Name.str c s`.
| true |
List.modify_eq_nil_iff | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {i : ℕ} {l : List α}, l.modify i f = [] ↔ l = [] | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.δ_σ₀Iter._proof_1_10 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ {n : ℕ} (j : ℕ) (k : Fin ({ len := n }.len + 1)), ↑k < j → ↑k.succ < j + 1 | null | false |
OrderType.inductionOn₂ | Mathlib.Order.Types.Defs | ∀ {C : OrderType.{u_1} → OrderType.{u_2} → Prop} (o₁ : OrderType.{u_1}) (o₂ : OrderType.{u_2}),
(∀ (α : Type u_1) [inst : LinearOrder α] (β : Type u_2) [inst_1 : LinearOrder β],
C (OrderType.type α) (OrderType.type β)) →
C o₁ o₂ | `Quotient.inductionOn₂` specialized to `OrderType`. | true |
_private.Mathlib.RingTheory.Localization.Algebra.0.IsLocalization.ker_map._simp_1_2 | Mathlib.RingTheory.Localization.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (s : ↥M),
(IsLocalization.mk' S x s = 0) = ∃ m, ↑m * x = 0 | null | false |
Submodule.finrank_quotient | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_2} R] [StrongRankCondition R] [Module.Finite R M] {S : Type u_1} [inst_6 : Ring S]
[inst_7 : SMul R S] [inst_8 : Module S M] [inst_9 : IsScalarTower R S M] (N : Submodule S M),
Module.finrank R (M ⧸... | Rank-nullity theorem using `finrank` and subtraction. | true |
BitVec.toNat_mul_toNat_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x.toNat * y.toNat < 2 ^ (w * 2) | null | true |
Ideal.stabilizerEquiv_symm_apply_smul | Mathlib.RingTheory.Ideal.Pointwise | ∀ {M : Type u_1} {R : Type u_3} [inst : Group M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {N : Type u_4}
[inst_3 : Group N] [inst_4 : MulSemiringAction N R] (I : Ideal R) (e : M ≃* N)
(he : ∀ (m : M) (x : R), e m • x = m • x) (n : ↥(MulAction.stabilizer N I)) (x : R),
(I.stabilizerEquiv e he).symm n... | null | true |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_7 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L),
CochainComplex.HomComplex.Cochain.ofHom
(CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.... | null | false |
Lean.Elab.Term.ElabElim.Context | Lean.Elab.App | Type | Context of the `elab_as_elim` elaboration procedure. | true |
Lean.Elab.Term.Do.ToTerm.reassignToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.MacroM Lean.Syntax | null | true |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_4 | Mathlib.Algebra.GroupWithZero.Range | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
CategoryTheory.Functor.instCommShift₂IntCochainComplexIntMap₂CochainComplex._proof_4 | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Preadditive C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Preadditive D]... | null | false |
_private.Init.Data.Nat.Control.0.Nat.forM.loop | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit | null | true |
MvPowerSeries.trunc_pderiv | Mathlib.RingTheory.MvPowerSeries.Derivative | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] [inst_1 : DecidableEq σ] {i : σ} (f : MvPowerSeries σ R)
(n : σ →₀ ℕ),
(MvPowerSeries.trunc R n) ((MvPowerSeries.pderiv i) f) =
(MvPolynomial.pderiv i) ((MvPowerSeries.trunc R (n + fun₀ | i => 1)) f) | null | true |
Subgroup.instInfSet | Mathlib.Algebra.Group.Subgroup.Lattice | {G : Type u_1} → [inst : Group G] → InfSet (Subgroup G) | null | true |
IsCompactElement.sup._simp_1 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a b : α},
IsCompactElement a → IsCompactElement b → IsCompactElement (a ⊔ b) = True | null | false |
CategoryTheory.Mon.limit_mon_mul | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (hc : CategoryTheory.Limits.I... | null | true |
Finset.compls_subset_compls._simp_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {s₁ s₂ : Finset α}, (s₁.compls ⊆ s₂.compls) = (s₁ ⊆ s₂) | null | false |
Set.EqOn.comp_eq | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_6} {f : ι → α} {g₁ g₂ : α → β},
Set.EqOn g₁ g₂ (Set.range f) → g₁ ∘ f = g₂ ∘ f | **Alias** of the forward direction of `Set.eqOn_range`. | true |
MeasureTheory.Measure.instMeasurableAdd₂ | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_3} {m : MeasurableSpace α}, MeasurableAdd₂ (MeasureTheory.Measure α) | null | true |
CategoryTheory.Lax.LaxTrans.homCategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {X Y : F ⟶ G} (f : CategoryTheory.Lax.LaxTrans.Hom X Y),
{ as := f.as.vcomp { as := CategoryTheory.Lax.LaxTrans.Modification.id Y }.as } = f | null | false |
List.Interleaves.pairwise_left | Mathlib.Data.List.Interleave | ∀ {α : Type u_1} {r : α → α → Prop} {l₁ l₂ : List α} [IsTrans α r], List.Interleaves r l₁ l₂ → List.Pairwise r l₁ | null | true |
dimH_empty | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {X : Type u_2} [inst : EMetricSpace X], dimH ∅ = 0 | null | true |
AlgebraicGeometry.Scheme.Modules.restrictStalkNatIso | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X Y : AlgebraicGeometry.Scheme} →
(f : X ⟶ Y) →
[inst : AlgebraicGeometry.IsOpenImmersion f] →
(x : ↥X) →
(AlgebraicGeometry.Scheme.Modules.restrictFunctor f).comp
((AlgebraicGeometry.Scheme.Modules.toPresheaf X).comp (TopCat.Presheaf.stalkFunctor Ab x)) ≅
(AlgebraicGeometry.S... | Restriction along open immersions commutes with taking stalks. | true |
Lagrange.nodal_insert_eq_nodal | Mathlib.LinearAlgebra.Lagrange | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} {s : Finset ι} {v : ι → R} [inst_1 : DecidableEq ι] {i : ι},
i ∉ s → Lagrange.nodal (insert i s) v = (Polynomial.X - Polynomial.C (v i)) * Lagrange.nodal s v | null | true |
_private.Mathlib.GroupTheory.Torsion.0.CommMonoid.torsion.isMulTorsion.match_1_1 | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : CommMonoid G] (motive : ↥(CommMonoid.torsion G) → Prop) (x : ↥(CommMonoid.torsion G)),
(∀ (x : G) (n : ℕ) (npos : n > 0) (hn : Function.IsPeriodicPt (fun x_1 => x * x_1) n 1), motive ⟨x, ⋯⟩) → motive x | null | false |
Std.DHashMap.get_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{f : β k → β k} {h : k ∈ m.modify k f}, (m.modify k f).get k h = f (m.get k ⋯) | null | true |
AddAction.nonempty_orbit | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M α] (a : α), (AddAction.orbit M a).Nonempty | null | true |
Topology.closure_of | Mathlib.Topology.Defs.Basic | Lean.ParserDescr | Notation for `closure` with respect to a non-standard topology. | true |
BitVec.shiftLeftZeroExtend._proof_1 | Init.Data.BitVec.Basic | ∀ {w x : ℕ}, x < 2 ^ w → ∀ (m : ℕ), x <<< m < 2 ^ (w + m) | null | false |
CategoryTheory.MorphismProperty.multiplicativeClosure'.below.id | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure' x → Prop} (x : C),
CategoryTheory.MorphismProperty.multiplicativeClosure'.below ⋯ | null | true |
LocallyConstant.instCommMonoid | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [CommMonoid Y] → CommMonoid (LocallyConstant X Y) | null | true |
conjneg_inj | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f g : G → R},
conjneg f = conjneg g ↔ f = g | null | true |
GenContFract.IntFractPair.stream_zero | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.stream v 0 = some (GenContFract.IntFractPair.of v) | null | true |
CategoryTheory.Functor.essImage.liftFunctor._proof_1 | Mathlib.CategoryTheory.EssentialImage | ∀ {J : Type u_6} {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
(G : CategoryTheory.Functor J D) (F : CategoryTheory.Functor C D) [inst_3 : F.Full] [F.Faithful]
(hG : ∀ (j : J), F.essImage ... | null | false |
CommRingCat.commRingObj._aux_1 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J CommRingCat) → (j : J) → Zero ((F.comp (CategoryTheory.forget CommRingCat)).obj j) | null | false |
AddMonoidAlgebra.uniqueAlgEquiv | Mathlib.Algebra.MonoidAlgebra.Basic | (R : Type u_1) →
{A : Type u_4} →
(M : Type u_7) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] → [inst_3 : AddMonoid M] → [Subsingleton M] → AddMonoidAlgebra A M ≃ₐ[R] A | The trivial monoid algebra is the base ring. | true |
RBTree.RBSet.AlterWF.recOn | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
{cmp : α → α → Ordering} →
{t : RBTree.RBSet α cmp} →
{cut : α → Ordering} →
{f : Option α → Option α} →
{motive : t.AlterWF cut f → Sort u} →
(t_1 : t.AlterWF cut f) →
((wf : RBTree.RBNode.WF cmp (RBTree.RBNode.alter cut f ↑t)) → motive ⋯) → moti... | null | false |
TestFunction.instAddCommGroup._proof_8 | 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] {n : ℕ∞},
autoParam (∀ (n_1 : ℕ) (a : TestFunction Ω F n), ↑n_1.succ • a = ↑n_1 • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
Homeomorph.preimageImageRestrict._proof_2 | Mathlib.Topology.IsClosedRestrict | ∀ {ι : Type u_1} (α : ι → Type u_2) (S : Set ι) (s : Set ((j : ι) → α j))
(p : ↑(Sᶜ.domRestrict '' s) × ((i : ↑S) → α ↑i)),
(fun x => (⟨Sᶜ.domRestrict ↑x, ⋯⟩, fun i => ↑x ↑i)) ((fun p => ⟨Topology.reorderRestrictProd S s p, ⋯⟩) p) = p | null | false |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_counitIso_hom_app_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
(X :
CategoryTheory.Comma (CategoryTheory.Functor.const SimplexCategory)
(CategoryTheory.Functor.id (CategoryTheory.Functor SimplexCategory C))),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.counitIso.hom.app X).left =
Catego... | null | true |
UV.shadow_compression_subset_compression_shadow | Mathlib.Combinatorics.SetFamily.Compression.UV | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} (u v : Finset α),
(∀ x ∈ u, ∃ y ∈ v, UV.IsCompressed (u.erase x) (v.erase y) 𝒜) →
(UV.compression u v 𝒜).shadow ⊆ UV.compression u v 𝒜.shadow | UV-compression reduces the size of the shadow of `𝒜` if, for all `x ∈ u` there is `y ∈ v` such
that `𝒜` is `(u.erase x, v.erase y)`-compressed. This is the key fact about compression for
Kruskal-Katona. | true |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instPosMulStrictMono._simp_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : LT α] (a : α), (⊥ < ↑a) = True | null | false |
CategoryTheory.leftDistributor_ext_left | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {X Y : C} {f : J → C}
{g h : CategoryTheo... | null | true |
Submodule.submoduleOf_sup_of_le | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N₁ N₂ N : Submodule R M}, N₁ ≤ N → N₂ ≤ N → (N₁ ⊔ N₂).submoduleOf N = N₁.submoduleOf N ⊔ N₂.submoduleOf N | null | true |
IsNilpotent.unop | Mathlib.RingTheory.Nilpotent.Defs | ∀ {R : Type u_1} [inst : MonoidWithZero R] {x : Rᵐᵒᵖ}, IsNilpotent x → IsNilpotent (MulOpposite.unop x) | **Alias** of the reverse direction of `isNilpotent_unop`. | true |
Inclusion.IntervalBool.not.eq_3 | Mathlib.Tactic.Inclusion.Core.ToSet | Inclusion.IntervalBool.undetermined.not = Inclusion.IntervalBool.undetermined | null | true |
_private.Lean.Environment.0.Lean.ImportedModule.rec | Lean.Environment | {motive : Lean.ImportedModule✝ → Sort u} →
((toEffectiveImport : Lean.EffectiveImport) →
(parts irParts : Array (Lean.ModuleData × Lean.CompactedRegion)) →
(needsIRTrans : Bool) →
motive
{ toEffectiveImport := toEffectiveImport, parts := parts, irParts := irParts,
nee... | null | false |
LinearEquiv.toEquiv | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
{S : Type u_6} →
{M : Type u_7} →
{M₂ : Type u_9} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
{modM : Module R M} →
{modM₂ : Module S M₂} →
... | The equivalence of types underlying a linear equivalence. | true |
CategoryTheory.Grothendieck.fiber_eqToHom | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (h : X = Y), (CategoryTheory.eqToHom h).fiber = CategoryTheory.eqToHom ⋯ | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter.0.CategoryTheory.SimplicialObject.δ_δ₀Iter._proof_1_2 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ (i : ℕ) {m : ℕ} (j : Fin (m + 2)), ↑j ≤ i → ↑j ≤ i | null | false |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.comap_dist_right_atTop._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF._proof_43 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (cond ifTrue ifFalse : Std.Sat.AIG.Fanin), cond.gate < upper → ¬cond.gate < aig.decls.size → False | null | false |
Stream'.get_even | Mathlib.Data.Stream.Init | ∀ {α : Type u} (n : ℕ) (s : Stream' α), s.even.get n = s.get (2 * n) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.