name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.coe_closure_eq._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (M : Subsemigroup R),
AddSubmonoid.closure ↑M = M.nonUnitalSubsemiringClosure.toAddSubmonoid | null | false |
Matrix.parabolicEigenvalue._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | (1 + 1).AtLeastTwo | null | false |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_mean_remainder_cauchy._simp_1_7 | Mathlib.Analysis.Calculus.Taylor | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
_private.Std.Time.Zoned.Database.PosixTz.0.Std.Time.TimeZone.posixParseSpec | Std.Time.Zoned.Database.PosixTz | Std.Internal.Parsec.String.Parser Std.Time.TimeZone.TransitionSpec | null | true |
USize.ofNatLT | Init.Prelude | (n : ℕ) → n < USize.size → USize | Converts a natural number to a `USize`. Requires a proof that the number is small enough to be
representable without overflow.
This function is overridden at runtime with an efficient implementation.
| true |
convexHull_eq_iInter | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) s = ⋂ t, ⋂ (_ : s ⊆ t), ⋂ (_ : Convex 𝕜 t), t | null | true |
_private.Mathlib.CategoryTheory.Limits.Weighted.PreservesLimit.0.CategoryTheory.Functor.weightedLimObj.preservesLimit.isLimitMapCone._proof_2 | Mathlib.CategoryTheory.Limits.Weighted.PreservesLimit | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_5}
[inst_1 : CategoryTheory.Category.{u_4, u_5} C] {K : Type u_7} [inst_2 : CategoryTheory.Category.{u_6, u_7} K]
(W : CategoryTheory.Functor J (Type u_2)) [inst_3 : W.HasWeightedLimObj C]
[inst_4 : CategoryTheory.Limits.HasLimitsOfShape K... | null | false |
SSet.horn.primitiveTriangle._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ}, ∀ k < n + 2, k < n + 3 + 1 | null | false |
Batteries.Random.MersenneTwister.State.mk.injEq | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} (data : Vector (BitVec cfg.wordSize) cfg.stateSize)
(index : Fin cfg.stateSize) (data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize) (index_1 : Fin cfg.stateSize),
({ data := data, index := index } = { data := data_1, index := index_1 }) = (data = data_1 ∧ index = ... | null | true |
CategoryTheory.ihom.ev_coev_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A B : C)
[inst_2 : CategoryTheory.Closed A] {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj A B ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((Ca... | null | true |
_private.Mathlib.Data.Multiset.Bind.0.Multiset.nodup_bind._simp_1_1 | Mathlib.Data.Multiset.Bind | ∀ {α : Type u} {β : Type v} {l₁ : List α} {f : α → List β},
(List.flatMap f l₁).Nodup = ((∀ x ∈ l₁, (f x).Nodup) ∧ List.Pairwise (Function.onFun List.Disjoint f) l₁) | null | false |
MeasureTheory.IsStoppingTime.measurableSpace.congr_simp | Mathlib.Probability.Martingale.OptionalSampling | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f f_1 : MeasureTheory.Filtration ι m}
(e_f : f = f_1) {τ τ_1 : Ω → WithTop ι} (e_τ : τ = τ_1) (hτ : MeasureTheory.IsStoppingTime f τ),
hτ.measurableSpace = ⋯.measurableSpace | null | true |
CategoryTheory.Functor.PushoutObjObj.mapArrowRight_comp | 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₃)} {f₁ : CategoryTheory.Arrow C₁}
{f₂ f₂' : CategoryTheory.Arrow C₂}... | null | true |
_private.Mathlib.GroupTheory.ClassEquation.0.Group.nat_card_center_add_sum_card_noncenter_eq_card._simp_1_6 | Mathlib.GroupTheory.ClassEquation | ∀ {α : Type u} {s : Set α}, (¬s.Nontrivial) = s.Subsingleton | null | false |
cfc_le_one_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [ContinuousSqrt R]
[StarOrderedRing R] [inst_8 : TopologicalSpace A] [inst_9 : Ring A] [inst_10 : StarRing A] [inst_1... | null | true |
Set.cast_ncard_sdiff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α} {R : Type u_3} [inst : AddGroupWithOne R],
s ⊆ t → t.Finite → ↑(t \ s).ncard = ↑t.ncard - ↑s.ncard | null | true |
Std.Http.URI.EncodedQueryString._sizeOf_inst | Std.Http.Data.URI.Encoding | (r : UInt8 → Bool) → SizeOf (Std.Http.URI.EncodedQueryString r) | null | false |
Lean.Meta.Match.Pattern.applyFVarSubst._unsafe_rec | Lean.Meta.Match.Basic | Lean.Meta.FVarSubst → Lean.Meta.Match.Pattern → Lean.Meta.Match.Pattern | null | false |
Function.Injective.addAction.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} {β : Type u_6} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : VAdd M β]
(f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c +ᵥ x) = c +ᵥ f x),
Function.Injective.addAction f hf smul = { toVAdd := inst_2, add_vadd := ⋯, zero_vadd := ⋯ } | null | true |
Subring.toNonUnitalSubring | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} → [inst : NonAssocRing R] → Subring R → NonUnitalSubring R | Turn a `Subring` into a `NonUnitalSubring` by forgetting that it contains `1`. | true |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.deriv2_qaryEntropy._simp_1_3 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
Sym.cast._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n m : ℕ} (h : n = m), Function.LeftInverse (fun s => ⟨↑s, ⋯⟩) fun s => ⟨↑s, ⋯⟩ | null | false |
Submodule.starProjection_inner_eq_zero | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [inst_3 : K.HasOrthogonalProjection] (v w : E), w ∈ K → inner 𝕜 (v - K.starProjection v) w = 0 | The characterization of the orthogonal projection. | true |
Std.DHashMap.diff | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Std.DHashMap α β → Std.DHashMap α β → Std.DHashMap α β | Computes the difference of the given hash maps.
This function always iterates through the smaller map, so the expected runtime is
`O(min(m₁.size, m₂.size))`.
| true |
Turing.TM1to0.trAux.eq_6 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (M : Λ → Turing.TM1.Stmt Γ Λ σ) (s : Γ) (x : σ),
Turing.TM1to0.trAux M s Turing.TM1.Stmt.halt x = ((none, x), Turing.TM0.Stmt.write s) | null | true |
MonomialOrder.div_set | Mathlib.RingTheory.MvPolynomial.Groebner | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] {B : Set (MvPolynomial σ R)},
(∀ b ∈ B, IsUnit (m.leadingCoeff b)) →
∀ (f : MvPolynomial σ R),
∃ g r,
f = (Finsupp.linearCombination (MvPolynomial σ R) fun b => ↑b) g + r ∧
(∀ (b : ↑B), m.toSyn (m.degree (↑b * g b)) ... | Division by a *set* of multivariate polynomials
whose leading coefficients are invertible with respect to a monomial order | true |
AdjoinRoot.instGroupWithZero._proof_8 | Mathlib.RingTheory.AdjoinRoot | ∀ {K : Type u_1} [inst : Field K] {f : Polynomial K}, (Ideal.span {f}).IsTwoSided | null | false |
Lean.Widget.DiffTag.ctorElimType | Lean.Widget.InteractiveCode | {motive : Lean.Widget.DiffTag → Sort u} → ℕ → Sort (max 1 u) | null | false |
sup_le_of_le_sdiff_left | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, b ≤ c \ a → a ≤ c → a ⊔ b ≤ c | null | true |
Lean.Grind.Linarith.Expr.denote | Init.Grind.Ordered.Linarith | {α : Type u_1} → [Lean.Grind.IntModule α] → Lean.Grind.Linarith.Context α → Lean.Grind.Linarith.Expr → α | null | true |
CategoryTheory.Limits.isLimitConeUnopOfCocone_lift | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.Cone F.unop),
(CategoryTheory.Limits.isLimitConeUnop... | null | true |
Finset.card_neg_le | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Neg α] {s : Finset α}, (-s).card ≤ s.card | null | true |
Lean.Server.lookupStatefulLspRequestHandler | Lean.Server.Requests | String → BaseIO (Option Lean.Server.StatefulRequestHandler) | null | true |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.firstDiff_comm._simp_1_1 | Mathlib.Topology.MetricSpace.PiNat | ∀ {α : Sort u_1} {a b : α}, (a ≠ b) = (b ≠ a) | null | false |
Std.Do.SPred.bientails.eq_1 | Std.Do.SPred.Laws | ∀ (P_2 Q_2 : Std.Do.SPred []), (P_2 ⊣⊢ₛ Q_2) = (P_2.down ↔ Q_2.down) | null | true |
Lean.SerialMessage.casesOn | Lean.Message | {motive : Lean.SerialMessage → Sort u} →
(t : Lean.SerialMessage) →
((toBaseMessage : Lean.BaseMessage String) →
(kind : Lean.Name) → motive { toBaseMessage := toBaseMessage, kind := kind }) →
motive t | null | false |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.1201310447._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | IO (Lean.Option Bool) | null | false |
_private.Mathlib.Data.List.TakeDrop.0.List.span.loop_eq_take_drop | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (l₁ l₂ : List α),
List.span.loop p l₁ l₂ = (l₂.reverse ++ List.takeWhile p l₁, List.dropWhile p l₁) | null | true |
_private.Mathlib.Data.Finset.Filter.0.Finset.filter_nonempty_iff._simp_1_4 | Mathlib.Data.Finset.Filter | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
ContinuousMap.instCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {A : Type u_1} [inst : CStarAlgebra A], IsTopologicalSemiring A | null | false |
Stream'.WSeq.bind_assoc._simp_1 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.WSeq α) (f : α → Stream'.WSeq β) (g : β → Stream'.WSeq γ),
((s.bind f).bind g ~ʷ s.bind fun x => (f x).bind g) = True | null | false |
Function.End.mul_def | Mathlib.Algebra.Group.Action.End | ∀ {α : Type u_4} (f g : Function.End α), f * g = f ∘ g | null | true |
Matrix.PosDef.finite_setOfPred_dotProduct_mulVec_le | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} [inst : Fintype n] {A : Matrix n n ℤ}, A.PosDef → ∀ (r : ℤ), {v | v ⬝ᵥ A.mulVec v ≤ r}.Finite | null | true |
Aesop.CompleteMatch.mk.inj | Aesop.Forward.Match.Types | ∀ {clusterMatches clusterMatches_1 : Array Aesop.Match},
{ clusterMatches := clusterMatches } = { clusterMatches := clusterMatches_1 } → clusterMatches = clusterMatches_1 | null | true |
Std.Time.ValidDate | Std.Time.Date.ValidDate | Bool → Type | Represents a valid date for a given year, considering whether it is a leap year. Example: `(2, 29)`
is valid only if `leap` is `true`.
| true |
IncidenceAlgebra.ext | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_4} [inst : Zero 𝕜] [inst_1 : LE α] ⦃f g : IncidenceAlgebra 𝕜 α⦄,
(∀ (a b : α), a ≤ b → f a b = g a b) → f = g | null | true |
tensorKaehlerQuotKerSqEquiv._proof_4 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (P : Type u_1) (S : Type u_2) [inst : CommRing P] [inst_1 : CommRing S] [inst_2 : Algebra P S],
SMulCommClass (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S S | null | false |
invOf_eq_left_inv | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible a], b * a = 1 → ⅟a = b | null | true |
CategoryTheory.Oplax.StrongTrans.whiskerRight_naturality_naturality_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {F G : CategoryTheory.OplaxFunctor B CategoryTheory.Cat}
(η : CategoryTheory.Oplax.StrongTrans F G) {a b : B} {a' : CategoryTheory.Cat} {f g : a ⟶ b} (β : f ⟶ g)
(h : G.obj b ⟶ a') (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp (h.toFunctor.map ((η.app b... | null | true |
CategoryTheory.Comon.MonOpOpToComonObj | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon Cᵒᵖ → CategoryTheory.Comon C | Turn a monoid object in the opposite category into a comonoid object.
| true |
_private.Mathlib.Probability.Distributions.Binomial.0.ProbabilityTheory.integrable_map_cast_binomial._simp_1_3 | Mathlib.Probability.Distributions.Binomial | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ε : Type u_7} [inst : TopologicalSpace ε]
[inst_1 : ESeminormedAddMonoid ε] {f : α → ε},
MeasureTheory.Integrable f μ → ∀ {c : ENNReal}, c ≠ ⊤ → MeasureTheory.Integrable f (c • μ) = True | null | false |
instAddMonoidWithOneENat._proof_3 | Mathlib.Data.ENat.Monoid | ∀ (a : ℕ∞), a + 0 = a | null | false |
Std.ExtTreeSet.isSome_min?_of_isSome_min?_erase | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(t.erase k).min?.isSome = true → t.min?.isSome = true | null | true |
TensorProduct.AlgebraTensorModule.map_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : ... | null | true |
Set.encard_le_encard_iff_encard_diff_le_encard_diff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, (s ∩ t).Finite → (s.encard ≤ t.encard ↔ (s \ t).encard ≤ (t \ s).encard) | **Alias** of `Set.encard_le_encard_iff_encard_sdiff_le_encard_sdiff`. | true |
Set.infs_subset_iff | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] {s t u : Set α}, s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.oangle_smul_add_right_eq_zero_or_eq_pi_iff._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} [inst_3 : Fintype ι], (¬LinearIndependent R v) = ∃ g, ∑ i, g i • v i = 0 ∧ ∃ i, g i ≠ 0 | null | false |
ContinuousAlgEquiv.image_symm_eq_preimage | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B) (S : Set B), ⇑e.symm '' S = ⇑e ⁻¹' S | null | true |
DoubleCentralizer.instInhabited | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u_1} →
{A : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] →
[inst_2 : NormedSpace 𝕜 A] →
[inst_3 : SMulCommClass 𝕜 A A] → [inst_4 : IsScalarTower 𝕜 A A] → Inhabited (DoubleCentralizer 𝕜 A) | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.noConfusion | Lean.Compiler.LCNF.InferBorrow | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.ParamMap.Key✝} → t = t' → Lean.Compiler.LCNF.ParamMap.Key.noConfusionType✝ P t t' | null | false |
_private.Mathlib.RingTheory.Adjoin.Basic.0.Subalgebra.adjoin_eq_span_basis._simp_1_1 | Mathlib.RingTheory.Adjoin.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | null | false |
CategoryTheory.Cat.HasLimits.limitCone._proof_2 | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (j : J)
(X : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X X) j))
(Categ... | null | false |
_private.Init.Data.SInt.Bitwise.0.Int8.or_eq_zero_iff._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
LinearMap.isPerfPair_of_subsingleton | Mathlib.LinearAlgebra.PerfectPairing.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N]
[inst_2 : CommSemiring R] [inst_3 : Module R M] [inst_4 : Module R N] [Subsingleton R] (p : M →ₗ[R] N →ₗ[R] R),
p.IsPerfPair | null | true |
Std.DTreeMap.Internal.Impl.Const.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
α →
(Option β → Option β) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α (fun x => β) (t.size - 1) (t.size + 1) | null | false |
boolRingCatEquivBoolAlg | Mathlib.Algebra.Category.BoolRing | BoolRing ≌ BoolAlg | The equivalence between Boolean rings and Boolean algebras. This is actually an isomorphism. | true |
Cardinal.isSingular_aleph_iff | Mathlib.SetTheory.Cardinal.Regular | ∀ {o : Ordinal.{u_1}}, (Cardinal.aleph o).IsSingular ↔ Order.IsSuccLimit o ∧ o.cof < Cardinal.aleph o | null | true |
_private.Lean.Elab.Util.0.Lean.Elab.getBetterRef.match_1 | Lean.Elab.Util | (motive : Option Lean.Elab.MacroStackElem → Sort u_1) →
(x : Option Lean.Elab.MacroStackElem) →
((elem : Lean.Elab.MacroStackElem) → motive (some elem)) → (Unit → motive none) → motive x | null | false |
Fin.div_val | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a b : Fin n), ↑(a / b) = ↑a / ↑b | null | true |
Pi.addCommGroupWithOne._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → AddCommGroupWithOne (f i)] (a b : (i : I) → f i), a - b = a + -b | null | false |
EuclideanSpace.inner_eq_star_dotProduct | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype ι] (x y : EuclideanSpace 𝕜 ι),
inner 𝕜 x y = y.ofLp ⬝ᵥ star x.ofLp | null | true |
AlgebraicGeometry.Scheme.fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → AlgebraicGeometry.Spec (X.residueField x) ⟶ X | The canonical map `Spec κ(x) ⟶ X`. | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.cmp_veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : Unit → motive Ordering.lt)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.eq with
| Ordering.eq => h_1 ()
| Ordering.lt => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | null | true |
_private.Mathlib.Data.Set.Lattice.Bounded.0.Set.sUnion_eq_univ_iff._simp_1_2 | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u} {x : α} {S : Set (Set α)}, (x ∈ ⋃₀ S) = ∃ t ∈ S, x ∈ t | null | false |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.eqOn_right_half_plane_of_superexponential_decay._simp_1_1 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
MvPowerSeries.support_truncFinset_subset | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : Finset (σ →₀ ℕ)} (p : MvPowerSeries σ R),
((MvPowerSeries.truncFinset R s) p).support ⊆ s | null | true |
inf_le_inf | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b c d : α}, b ≤ a → d ≤ c → b ⊓ d ≤ a ⊓ c | null | true |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.auxMat_blockTriangular._simp_1_2 | Mathlib.RingTheory.Norm.Transitivity | ∀ {a b : Prop}, (¬(a → b)) = (a ∧ ¬b) | null | false |
IsCompact.isSigmaCompact | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsSigmaCompact s | Compact sets are σ-compact. | true |
List.alternatingProd_cons_cons' | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : One G] [inst_1 : Mul G] [inst_2 : Inv G] (a b : G) (l : List G),
(a :: b :: l).alternatingProd = a * b⁻¹ * l.alternatingProd | null | true |
AlgebraicGeometry.mono_pushoutSection_of_isCompact_of_flat_left_of_ringHomFlat | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | null | true |
HasFDerivWithinAt.of_insert | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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} {f' : E →L[𝕜] F} {x : E} {s : Set E} {y : E},
HasFDerivWith... | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Stepwise.imp_1eq._simp_1_3 | Init.Grind.Ring.CommSolver | ∀ {M : Type u} [inst : Lean.Grind.AddCommGroup M] {a b : M}, (a - b = 0) = (a = b) | null | false |
isCompact_setOf_finiteMeasure_le_of_isCompact | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {E : Type u_1} [inst : MeasurableSpace E] [inst_1 : TopologicalSpace E] [T2Space E] [inst_3 : BorelSpace E]
(C : NNReal) {K : Set E}, IsCompact K → IsCompact {μ | μ.mass ≤ C ∧ μ Kᶜ = 0} | **Alias** of `isCompact_setOfPred_finiteMeasure_le_of_isCompact`.
---
The set of finite measures of mass at most `C` supported on a given compact set `K` is
compact. | true |
_private.Mathlib.RingTheory.Bialgebra.MonoidAlgebra.0.AddMonoidAlgebra.mapDomainOfBialgHomFun._proof_1 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} {G : Type u_3} {H : Type u_2} [inst : CommRing R] [IsDomain R] [inst_2 : AddGroup G]
[inst_3 : AddGroup H] (f : AddMonoidAlgebra R G →ₐc[R] AddMonoidAlgebra R H) (g : G),
f (AddMonoidAlgebra.single g 1) ∈ Set.range fun x => AddMonoidAlgebra.single x 1 | null | false |
SimpleGraph.neighborSet_sdiff | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} {G₁ G₂ : SimpleGraph V} (v : V), (G₁ \ G₂).neighborSet v = G₁.neighborSet v \ G₂.neighborSet v | null | true |
Algebra.algebraMapSubmonoid_self | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R), Algebra.algebraMapSubmonoid R M = M | null | true |
CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_26 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) {i' j' k' l' : ι}
(f₁' : i' ⟶ j') (f₂' : j' ⟶ k') (... | null | false |
Lean.instInhabitedVersoDocString.default | Lean.DocString.Extension | Lean.VersoDocString | null | true |
CategoryTheory.Limits.ImageFactorisation.mk | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
(F : CategoryTheory.Limits.MonoFactorisation f) →
CategoryTheory.Limits.IsImage F → CategoryTheory.Limits.ImageFactorisation f | null | true |
AddSubmonoid.pi | Mathlib.Algebra.Group.Submonoid.Operations | {ι : Type u_4} →
{M : ι → Type u_5} →
[inst : (i : ι) → AddZeroClass (M i)] → Set ι → ((i : ι) → AddSubmonoid (M i)) → AddSubmonoid ((i : ι) → M i) | A version of `Set.pi` for `AddSubmonoid`s. Given an index set `I` and a family
of `AddSubmonoid`s `s : Π i, AddSubmonoid f i`, `pi I s` is the `AddSubmonoid` of dependent
functions `f : Π i, f i` such that `f i` belongs to `pi I s` whenever `i ∈ I`. | true |
_private.Mathlib.Algebra.Order.BigOperators.GroupWithZero.List.0.List.one_le_prod._simp_1_2 | Mathlib.Algebra.Order.BigOperators.GroupWithZero.List | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.RelStruct.refl._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ (n : ℕ) (i : Fin (n + 1)) (j : Fin (n + 1 + 1)), j.castSucc < i.succ.castSucc → j ≤ i.castSucc | null | false |
Lean.Meta.Simp.NormCastConfig.beta._default | Init.MetaTypes | Bool | null | false |
_private.Mathlib.GroupTheory.OrderOfElement.0.orderOf_zero._simp_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → (a = b) = False | null | false |
DiscreteMeasurableSpace.toMeasurableSub | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : Sub α] [DiscreteMeasurableSpace α], MeasurableSub α | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.isHexDigit_isEncodedChar | Std.Http.Data.URI.Encoding | ∀ {r : UInt8 → Bool} {c : UInt8}, Std.Http.Internal.Char.isHexDigitByte c = true → Std.Http.URI.isEncodedChar r c = true | null | true |
FundamentalGroupoid.map_obj_as | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(x : FundamentalGroupoid X), ((FundamentalGroupoid.map f).obj x).as = f x.as | null | true |
ContinuousLinearMap.toNormedRing._proof_14 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (n : ℕ), IntCast.intCast ↑n = ↑n | null | false |
Option.merge_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o o' : Option α} {f : α → α → α} {a : α},
Option.merge f o o' = some a ↔
o = some a ∧ o' = none ∨ o = none ∧ o' = some a ∨ ∃ b c, o = some b ∧ o' = some c ∧ f b c = a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.