name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Server.TransientWorkerILean.mk.injEq | Lean.Server.References | ∀ (moduleUri : Lean.Lsp.DocumentUri) (version : ℕ) (directImports : Lean.Server.DirectImports)
(isSetupFailure? : Option Bool) (refs : Lean.Lsp.ModuleRefs) (decls : Lean.Lsp.Decls)
(moduleUri_1 : Lean.Lsp.DocumentUri) (version_1 : ℕ) (directImports_1 : Lean.Server.DirectImports)
(isSetupFailure?_1 : Option Bool) ... | null | true |
CategoryTheory.SimplicialThickening.instCategoryHom._proof_3 | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] (i j : CategoryTheory.SimplicialThickening J),
autoParam
(∀ {W X Y Z : CategoryTheory.SimplicialThickening.Path i.as j.as} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.Categ... | null | false |
RightPreLieAlgebra.instLeftPreLieAlgebraMulOpposite._proof_1 | Mathlib.Algebra.NonAssoc.PreLie.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : RightPreLieRing L] [inst_2 : RightPreLieAlgebra R L],
IsScalarTower R Lᵐᵒᵖ Lᵐᵒᵖ | null | false |
CategoryTheory.Functor.RepresentableBy.yoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → (X : C) → (CategoryTheory.yoneda.obj X).RepresentableBy X | `yoneda.obj X` is represented by `X`. | true |
Lean.Parser.Term.matchAltsWhereDecls.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.Localization.SmallShiftedHom.mk₀_comp_mk₀Inv | Mathlib.CategoryTheory.Localization.SmallShiftedHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {W : CategoryTheory.MorphismProperty C} {M : Type w'}
[inst_1 : AddMonoid M] [inst_2 : CategoryTheory.HasShift C M] {X Y : C}
[inst_3 : CategoryTheory.Localization.HasSmallLocalizedShiftedHom W M X Y]
[inst_4 : CategoryTheory.Localization.HasSmallLocaliz... | null | true |
_private.Mathlib.Basic.Rel.0.SetRel.cod_eq_empty_iff._simp_1_1 | Mathlib.Basic.Rel | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
Matroid.Indep.isNonloop_of_mem | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α} {I : Set α}, M.Indep I → e ∈ I → M.IsNonloop e | null | true |
MonoidAlgebra.liftNCRingHom_single | Mathlib.Algebra.MonoidAlgebra.Lift | ∀ {k : Type u₁} {G : Type u₂} {R : Type u_1} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Semiring R] (f : k →+* R)
(g : G →* R) (h_comm : ∀ (x : k) (y : G), Commute (f x) (g y)) (a : G) (b : k),
(MonoidAlgebra.liftNCRingHom f g h_comm) (MonoidAlgebra.single a b) = f b * g a | null | true |
AddGroupSeminorm.instSupSet._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (s : Set (AddGroupSeminorm E)),
BddAbove s → ∀ (x y : E), ⨆ p, ↑p (x + y) ≤ (⨆ p, ↑p x) + ⨆ p, ↑p y | null | false |
CategoryTheory.Bicategory.Adjunction.homEquiv₂._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {l : b ⟶ c} {r : c ⟶ b}
(adj : CategoryTheory.Bicategory.Adjunction l r) {g : a ⟶ b} {h : a ⟶ c}
(α : CategoryTheory.CategoryStruct.comp g l ⟶ h),
(fun γ =>
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight γ l)
... | null | false |
Turing.TM2.Stmt.ctorElim | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
{motive : Turing.TM2.Stmt Γ Λ σ → Sort u} →
(ctorIdx : ℕ) →
(t : Turing.TM2.Stmt Γ Λ σ) → ctorIdx = t.ctorIdx → Turing.TM2.Stmt.ctorElimType ctorIdx → motive t | null | false |
SimpleGraph.isEdgeReachable_two | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V},
G.IsEdgeReachable 2 u v ↔ ∀ (e : Sym2 V), (G.deleteEdges {e}).Reachable u v | null | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.embDomain_trans_apply._simp_1_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {M : Type u_5} [inst : AddCommMonoid M] {v : α →₀ M} {f : α → β}
{g : β → γ}, Finsupp.mapDomain g (Finsupp.mapDomain f v) = Finsupp.mapDomain (g ∘ f) v | null | false |
_private.Std.Data.DTreeMap.Lemmas.0.Break.runK.match_1.eq_2 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () | null | true |
CategoryTheory.sum.match_3 | Mathlib.CategoryTheory.Sums.Basic | (C : Type u_1) →
(D : Type u_2) →
(motive : C ⊕ D → Sort u_3) →
(X : C ⊕ D) → ((X : C) → motive (Sum.inl X)) → ((X : D) → motive (Sum.inr X)) → motive X | null | false |
_private.Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves.0.CategoryTheory.regularTopology.equalizerCondition_w._simp_1_2 | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.isClosed_lattice._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair), DiscreteTopology ↥L.lattice.toAddSubgroup | null | false |
List.chooseX.match_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (p : α → Prop) (l : α) (ls : List α) (x : α) (motive : x ∈ l :: ls ∧ p x → Prop)
(x_1 : x ∈ l :: ls ∧ p x), (∀ (o : x ∈ l :: ls) (h₂ : p x), motive ⋯) → motive x_1 | null | false |
IsGaloisGroup.fixedPoints_bot | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_4) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] [inst_5 : SMulCommClass G K L],
FixedPoints.intermediateField ↥⊥ = ⊤ | null | true |
Lean.Parser.Tactic.vcgenDischarge.quot | Std.Tactic.Do.Syntax | Lean.ParserDescr | null | true |
exists_enorm_lt | Mathlib.Analysis.Normed.Group.Basic | ∀ (E : Type u_7) [inst : TopologicalSpace E] [inst_1 : ESeminormedAddMonoid E] [hbot : (nhdsWithin 0 {0}ᶜ).NeBot]
{c : ENNReal}, c ≠ 0 → ∃ x, x ≠ 0 ∧ ‖x‖ₑ < c | null | true |
CategoryTheory.Limits.biprod.braid_natural | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : X ⟶ Y) (g : Z ⟶ W),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g)
(CategoryTheory.Limits.biprod... | The braiding isomorphism can be passed through a map by swapping the order. | true |
Module.End.rTensorAlgHom._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (M : Type u_3) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass R R (TensorProduct R M N) | null | false |
Std.Tactic.BVDecide.BVPred.ExprPair._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | SizeOf Std.Tactic.BVDecide.BVPred.ExprPair | null | false |
_private.Mathlib.Algebra.BigOperators.Field.0.Finset.dens_biUnion_le._simp_1_1 | Mathlib.Algebra.BigOperators.Field | ∀ {ι : Type u_1} {K : Type u_2} [inst : DivisionSemiring K] (s : Finset ι) (f : ι → K) (a : K),
∑ i ∈ s, f i / a = (∑ i ∈ s, f i) / a | null | false |
LieSubalgebra.coe_bracket_of_module | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L)
{M : Type w} [inst_3 : AddCommGroup M] [inst_4 : LieRingModule L M] (x : ↥L') (m : M), ⁅x, m⁆ = ⁅↑x, m⁆ | null | true |
SimpleGraph.Subgraph.neighborSet_subset_verts | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (G' : G.Subgraph) (v : V), G'.neighborSet v ⊆ G'.verts | null | true |
Topology.IsQuotientMap.isStrictMap | Mathlib.Topology.Maps.Strict.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Topology.IsQuotientMap f → Topology.IsStrictMap f | A quotient map is strict. See also `isQuotientMap_iff_isStrictMap_surjective`. | true |
linearIndependent_algebraMap_comp_iff._simp_1 | Mathlib.LinearAlgebra.LinearIndependent.BaseChange | ∀ {ι : Type u_1} {ι' : Type u_2} [Finite ι'] {R : Type u_3} {S : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [FaithfulSMul R S] [IsDomain S] {v : ι → ι' → R},
(LinearIndependent S fun i => ⇑(algebraMap R S) ∘ v i) = LinearIndependent R v | null | false |
Lean.Meta.Grind.instHashableCongrKey._private_1 | Lean.Meta.Tactic.Grind.Types | {enodeMap : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodeMap → UInt64 | null | false |
Topology.CWComplex.coe_skeletonLT | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] [inst : T2Space X] (C : Set X) {D : Set X}
[inst_1 : Topology.RelCWComplex C D] (n : ℕ∞),
↑(Topology.RelCWComplex.skeletonLT C n) = D ∪ ⋃ m, ⋃ (_ : ↑m < n), ⋃ j, Topology.RelCWComplex.closedCell m j | **Alias** of `Topology.RelCWComplex.coe_skeletonLT`. | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Cauchy.map_of_le._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : α → β} {m' : β → γ},
Filter.map (m' ∘ m) f = Filter.map m' (Filter.map m f) | null | false |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isEagerCasesCandidate.match_1 | Lean.Meta.Tactic.Grind.Intro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((x : Lean.Expr) → motive x) → motive x | null | false |
_private.Mathlib.Data.Finsupp.Weight.0.Finsupp.le_degree._simp_1_2 | Mathlib.Data.Finsupp.Weight | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
ENNReal.div_le_iff_le_mul | Mathlib.Basic.ENNReal.Inv | ∀ {a b c : ENNReal}, b ≠ 0 ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ 0 → (a / b ≤ c ↔ a ≤ c * b) | null | true |
ContinuousLinearMap.toBilinForm._proof_9 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E], ContinuousConstSMul 𝕜 (E →L[𝕜] 𝕜) | null | false |
Std.HashMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₁ → (m₁ \ m₂)[k]? = none | null | true |
CategoryTheory.Limits.pushout.desc.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} {f : X ⟶ Y} {g : X ⟶ Z}
[inst_1 : CategoryTheory.Limits.HasPushout f g] (h h_1 : Y ⟶ W) (e_h : h = h_1) (k k_1 : Z ⟶ W) (e_k : k = k_1)
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.Limit... | null | true |
Std.Http.Method.acl | Std.Http.Data.Method | Std.Http.Method | Access control list for a resource.
Source: https://www.rfc-editor.org/rfc/rfc3744#section-8.1
| true |
Quiver.Path.comp_inj' | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b c : V} {p₁ p₂ : Quiver.Path a b} {q₁ q₂ : Quiver.Path b c},
p₁.length = p₂.length → (p₁.comp q₁ = p₂.comp q₂ ↔ p₁ = p₂ ∧ q₁ = q₂) | null | true |
Finset.prod_coe_sort | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} (s : Finset ι) [inst : CommMonoid M] (f : ι → M), ∏ i, f ↑i = ∏ i ∈ s, f i | null | true |
Lean.Grind.CutsatConfig.locals._inherited_default | Init.Grind.Config | Bool | null | false |
CStarAlgebra.norm_le_natCast_iff_of_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
Matrix.reindex_mem_colStochastic | Mathlib.LinearAlgebra.Matrix.Stochastic | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring R]
[inst_3 : PartialOrder R] [inst_4 : IsOrderedRing R] {m : Type u_3} [inst_5 : Fintype m] [inst_6 : DecidableEq m]
{M : Matrix n n R} {e₁ e₂ : n ≃ m}, M ∈ Matrix.colStochastic R n → (Matrix.reindex e₁ e₂) M ∈ Matrix.col... | Reindexing a matrix preserves column-stochasticity. | true |
QuadraticMap.zero_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} {inst : FunLike F α β} {inst_1 : Zero β}
{inst_2 : Zero F} [self : IsZeroApply F α β] (x : α), 0 x = 0 | **Alias** of `zero_apply`. | true |
CategoryTheory.Limits.parallelPairOpIso_inv_app_zero | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f g : X ⟶ Y),
(CategoryTheory.Limits.parallelPairOpIso f g).inv.app CategoryTheory.Limits.WalkingParallelPair.zero =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.walkingParallelPairOpEquiv.functor.comp (CategoryTheory.Limits.... | null | true |
Unitary.toUnits_comp_map | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S] [inst_3 : StarMul S]
(f : R →⋆* S), Unitary.toUnits.comp (Unitary.map f).toMonoidHom = (Units.map f.toMonoidHom).comp Unitary.toUnits | null | true |
_private.Mathlib.Topology.Separation.CompletelyRegular.0.completelyRegularSpace_iInf._simp_1_7 | Mathlib.Topology.Separation.CompletelyRegular | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
Std.Iterators.Types.ArrayIterator.stepAsHetT_iterFromIdxM | Std.Data.Iterators.Lemmas.Producers.Monadic.Array | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} [LawfulMonad m] {array : Array β} {pos : ℕ},
(array.iterFromIdxM m pos).stepAsHetT =
if x : pos < array.size then pure (Std.IterStep.yield (array.iterFromIdxM m (pos + 1)) array[pos])
else pure Std.IterStep.done | null | true |
SimpContFract.of_isContFract | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} (v : K) [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] [inst_3 : FloorRing K],
(SimpContFract.of v).IsContFract | null | true |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.ProbabilityMeasure.coeFn_univ_ne_zero._simp_1_1 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
CategoryTheory.Limits.Types.limit_ext_iff | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)}
[inst_1 : CategoryTheory.Limits.HasLimit F] {x y : CategoryTheory.Limits.limit F},
x = y ↔
∀ (j : J),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.limit.π F j)) x =
(CategoryTheory.Concr... | null | true |
hasFPowerSeriesAt_log_one | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | HasFPowerSeriesAt Real.log (FormalMultilinearSeries.ofScalars ℝ fun n => -(-1) ^ n / ↑n) 1 | null | true |
Tactic.ComputeAsymptotics.Seq.Stream'.dist_le_one | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (s t : Stream' α), dist s t ≤ 1 | null | true |
Inclusion.true_of_mem_intervalBool_true | Mathlib.Tactic.Inclusion.Core.ToSet | ∀ {p : Prop}, p ∈ Inclusion.IntervalBool.true → p | null | true |
DivisionMonoid.toInvolutiveInv | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} → [self : DivisionMonoid G] → InvolutiveInv G | null | true |
Std.Packages.PreorderOfLEArgs.mk.noConfusion | Init.Data.Order.PackageFactories | {α : Type u} →
{P : Sort u_1} →
{le : autoParam (LE α) Std.Packages.PreorderOfLEArgs.le._autoParam} →
{decidableLE : autoParam (DecidableLE α) Std.Packages.PreorderOfLEArgs.decidableLE._autoParam} →
{lt :
autoParam
(let this := le;
LT α)
Std.Pack... | null | false |
Field.Emb.cardinal_eq_of_isSeparable | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
Cardinal.mk (Field.Emb F E) = (fun c => if Cardinal.aleph0 ≤ c then 2 ^ c else c) (Module.rank F E) | null | true |
PowerSeries.exist_eq_span_eq_ncard_of_X_notMem | Mathlib.RingTheory.PowerSeries.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal (PowerSeries R)} [I.IsPrime],
PowerSeries.X ∉ I →
∀ {S : Set R},
Ideal.span S = Ideal.map PowerSeries.constantCoeff I →
S.Finite → ∃ T, I = Ideal.span T ∧ T.Finite ∧ T.ncard = S.ncard | Given a prime ideal `I` of `R⟦X⟧` such that `X ∉ I`, if `I.map constantCoeff` is generated by a
finite set `S : Set T`, then there exists `T : Set R`, of the same cardinality as `S`, that
generates `I`. | true |
ProbabilityTheory.integrable_rpow_mul_cexp_of_re_mem_interior_integrableExpSet | Mathlib.Probability.Moments.IntegrableExpMul | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω} {z : ℂ},
z.re ∈ interior (ProbabilityTheory.integrableExpSet X μ) →
∀ {p : ℝ}, 0 ≤ p → MeasureTheory.Integrable (fun ω => ↑(X ω ^ p) * Complex.exp (z * ↑(X ω))) μ | null | true |
SkewMonoidAlgebra.liftNCRingHom._proof_3 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k] {R : Type u_3}
[inst_3 : Semiring R] (f : k →+* R) (g : G →* R),
(∀ {x : k} {y : G}, f (y • x) * g y = g y * f x) →
∀ (x x_1 : SkewMonoidAlgebra k G),
(SkewMonoidAlgebra.liftNC ↑f ⇑g) (x * x_1) =
... | null | false |
CategoryTheory.Limits.reflexivePair.mkNatIso_inv_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C}
(e₀ : F.obj CategoryTheory.Limits.WalkingReflexivePair.zero ≅ G.obj CategoryTheory.Limits.WalkingReflexivePair.zero)
(e₁ : F.obj CategoryTheory.Limits.WalkingReflexivePair.one ≅ G.o... | null | true |
Std.DTreeMap.Internal.Impl.Const.insertMany_empty_list_cons_eq_insertMany! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {k : α} {v : β} {tl : List (α × β)},
↑(Std.DTreeMap.Internal.Impl.Const.insertMany Std.DTreeMap.Internal.Impl.empty ((k, v) :: tl) ⋯) =
↑(Std.DTreeMap.Internal.Impl.Const.insertMany!
(Std.DTreeMap.Internal.Impl.insert! k v Std.DTreeMap.Internal.Impl.empty) tl) | null | true |
HahnSeries.SummableFamily.casesOn | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_8} →
{R : Type u_9} →
[inst : PartialOrder Γ] →
[inst_1 : AddCommMonoid R] →
{α : Type u_7} →
{motive : HahnSeries.SummableFamily Γ R α → Sort u} →
(t : HahnSeries.SummableFamily Γ R α) →
((toFun : α → HahnSeries Γ R) →
(isPWO_iUnion_... | null | false |
_private.Mathlib.Algebra.Group.Nat.Even.0.Nat.even_pow._proof_1_2 | Mathlib.Algebra.Group.Nat.Even | ∀ {m : ℕ} (n : ℕ), (Even (m ^ n) ↔ Even m ∧ n ≠ 0) → (Even (m ^ (n + 1)) ↔ Even m ∧ ¬n + 1 = 0) | null | false |
Set.even_ncard_compl_iff' | Mathlib.Data.Set.Card | ∀ {α : Type u_1}, Odd (Nat.card α) → ∀ (s : Set α), Even sᶜ.ncard ↔ Odd s.ncard | null | true |
CategoryTheory.Under.eqToHom_right._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} T] {X : T} {f g : CategoryTheory.Under X},
f = g → f.right = g.right | null | false |
Real.continuousAt_arctan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, ContinuousAt Real.arctan x | null | true |
Std.TreeMap.Raw.Equiv.congr_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp},
t₁.Equiv t₂ → (t₁.Equiv t₃ ↔ t₂.Equiv t₃) | null | true |
List.Subperm.idxInj.congr_simp | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs ys : List α} (h : xs.Subperm ys) (i i_1 : Fin xs.length),
i = i_1 → h.idxInj i = h.idxInj i_1 | null | true |
Algebra.Generators.Hom.toAlgHom_monomial | 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 R R']
... | null | true |
Lean.Meta.Grind.EMatch.State.gmt | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → ℕ | Goal modification time. | true |
AlgebraicGeometry.WeaklyEtale | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | A morphism is weakly étale if it is flat and the diagonal map is flat. | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂_term_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {β : Type u_2} {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [IsTopologicalAddGroup G]
[Infinite β] [T2Space G] (a : G), (Summable fun x => a) = (a = 0) | null | false |
Std.Internal.List.containsKey_insertList_disj_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.containsKey k l || Std.Internal.List.containsKey k toInsert) | null | true |
left_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : MulActionWithZero 𝕜 E] (x y : E), x ∈ segment 𝕜 x y | null | true |
CategoryTheory.yonedaMap._proof_2 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D) (X : C) ⦃X_1 Y : Cᵒᵖ⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.obj X).map f) (TypeCat.ofHom fun f => F.map f) =
Category... | null | false |
Order.Cofinal.above | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → Order.Cofinal P → P → P | A (noncomputable) element of a cofinal set lying above a given element. | true |
Lean.Meta.Simp.Stats.recOn | Lean.Meta.Tactic.Simp.Types | {motive : Lean.Meta.Simp.Stats → Sort u} →
(t : Lean.Meta.Simp.Stats) →
((usedTheorems : Lean.Meta.Simp.UsedSimps) →
(diag : Lean.Meta.Simp.Diagnostics) → motive { usedTheorems := usedTheorems, diag := diag }) →
motive t | null | false |
padicValRat.div | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ}, q ≠ 0 → r ≠ 0 → padicValRat p (q / r) = padicValRat p q - padicValRat p r | A rewrite lemma for `padicValRat p (q / r)` with conditions `q ≠ 0`, `r ≠ 0`. | true |
Set.mapsTo_univ | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.MapsTo f s Set.univ | null | true |
Subspace.flip_quotDualCoannihilatorToDual_bijective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_4} {V : Type u_5} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : Subspace K (Module.Dual K V)) [FiniteDimensional K ↥W],
Function.Bijective ⇑(Submodule.quotDualCoannihilatorToDual W).flip | null | true |
Lean.Elab.Term.CalcStepView.mk.noConfusion | Lean.Elab.Calc | {P : Sort u} →
{ref : Lean.Syntax} →
{term proof : Lean.Term} →
{ref' : Lean.Syntax} →
{term' proof' : Lean.Term} →
{ ref := ref, term := term, proof := proof } = { ref := ref', term := term', proof := proof' } →
(ref = ref' → term = term' → proof = proof' → P) → P | null | false |
Int.instAdd | Init.Data.Int.Basic | Add ℤ | null | true |
linarithToGrindRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config | Debug `grind` by identifying places where it does not yet supersede `linarith`. | true |
ZLattice.comap_refl | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(L : Submodule ℤ E), ZLattice.comap K L 1 = L | null | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.isRflTheoremCore.match_1 | Lean.Meta.Tactic.Simp.SimpTheorems | (motive : Lean.ConstantInfo → Sort u_1) →
(__x : Lean.ConstantInfo) →
((info : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_erase._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Submonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_3} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid M), ∃ a ∈ ↑S, f a = 1 | null | false |
Std.DTreeMap.Raw.self_le_maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true | null | true |
Turing.TM0.Cfg.q | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → [inst : Inhabited Γ] → Turing.TM0.Cfg Γ Λ → Λ | The current machine state. | true |
Lean.Name._impl.casesOn | Init.Prelude | {motive : Lean.Name._impl → Sort u} →
(t : Lean.Name._impl) →
motive Lean.Name.anonymous._impl →
((hash : UInt64) → (pre : Lean.Name) → (str : String) → motive (Lean.Name.str._impl hash pre str)) →
((hash : UInt64) → (pre : Lean.Name) → (i : ℕ) → motive (Lean.Name.num._impl hash pre i)) → motive t | null | false |
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Comma.isCardinalAccessibleCategory.instFinalJJ₂π₂ | Mathlib.CategoryTheory.Presentable.Comma | ∀ {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]
{F₁ : CategoryTheory.Functor C₁ D} {F₂ : CategoryTheory.Functor C₂ D} {κ : Cardinal.{w}} [inst_3 : Fact κ.IsRegular]
{f :... | null | true |
CategoryTheory.Limits.PullbackCone.mk._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | Lean.Syntax | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doLetArrow._regBuiltin.Lean.Parser.Term.doLetArrow.formatter_15 | Lean.Parser.Do | IO Unit | null | false |
Polynomial.resultant_zero_right_deg | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m : ℕ), f.resultant g m 0 = g.coeff 0 ^ m | null | true |
SemimoduleCat.MonoidalCategory.leftUnitor_naturality | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M N : SemimoduleCat R} (f : M ⟶ N),
CategoryTheory.CategoryStruct.comp (SemimoduleCat.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id ↧R) f)
(SemimoduleCat.MonoidalCategory.leftUnitor N).hom =
CategoryTheory.CategoryStruct.comp (SemimoduleCat.MonoidalCate... | null | true |
AddMonoidHom.exists_mrange_eq_mgraph | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} {I : Type u_3} [inst : AddMonoid G] [inst_1 : AddMonoid H] [inst_2 : AddMonoid I]
{f : G →+ H × I},
Function.Surjective (Prod.fst ∘ ⇑f) →
(∀ (g₁ g₂ : G), (f g₁).1 = (f g₂).1 → (f g₁).2 = (f g₂).2) → ∃ f', AddMonoidHom.mrange f = f'.mgraph | **Vertical line test** for monoid homomorphisms.
Let `f : G → H × I` be a homomorphism to a product of monoids. Assume that `f` is surjective on the
first factor and that the image of `f` intersects every "vertical line" `{(h, i) | i : I}` at most
once. Then the image of `f` is the graph of some monoid homomorphism `f... | true |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Mem.congr_left.match_1_1 | Mathlib.SetTheory.ZFC.PSet | ∀ (x : PSet.{u_1}) («Type» : Type u_1) (Func : «Type» → PSet.{u_1})
(motive : x ∈ { «Type» := «Type», Func := Func } → Prop) (x_1 : x ∈ { «Type» := «Type», Func := Func }),
(∀ (a : { «Type» := «Type», Func := Func }.Type) (ha : x.Equiv ({ «Type» := «Type», Func := Func }.Func a)),
motive ⋯) →
motive x_1 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.