name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Probability.Kernel.Disintegration.CondCDF.0.ProbabilityTheory.preCDF_le_one._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
Finset.nsmul_empty | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {n : ℕ}, n ≠ 0 → n • ∅ = ∅ | null | true |
MonoidWithZeroHom.ValueGroup₀.restrict₀_eq_zero_iff | Mathlib.Algebra.GroupWithZero.Range | ∀ {A : Type u_1} {B : Type u_2} [inst : MonoidWithZero A] [inst_1 : GroupWithZero B] {f : A →*₀ B} {a : A},
(MonoidWithZeroHom.ValueGroup₀.restrict₀ f) a = 0 ↔ f a = 0 | null | true |
Std.Iter.Equiv.trans | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α₁ α₂ α₃ β : Type w} [inst : Std.Iterator α₁ Id β] [inst_1 : Std.Iterator α₂ Id β] [inst_2 : Std.Iterator α₃ Id β]
{ita : Std.Iter β} {itb : Std.Iter β} {itc : Std.Iter β}, ita.Equiv itb → itb.Equiv itc → ita.Equiv itc | null | true |
ENNReal.instDivInvMonoid._proof_4 | Mathlib.Basic.ENNReal.Basic | ∀ (n : ℕ) (a : ENNReal), a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹ | null | false |
Lean.Meta.DefaultInstances.mk.inj | Lean.Meta.Instances | ∀ {defaultInstances : Lean.NameMap (List (Lean.Name × ℕ))} {priorities : Lean.Meta.PrioritySet}
{defaultInstances_1 : Lean.NameMap (List (Lean.Name × ℕ))} {priorities_1 : Lean.Meta.PrioritySet},
{ defaultInstances := defaultInstances, priorities := priorities } =
{ defaultInstances := defaultInstances_1, prio... | null | true |
PadicInt.residueField._proof_5 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)], Function.Surjective ⇑PadicInt.toZMod | null | false |
Padic.mk_eq | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] {f g : PadicSeq p}, Padic.mk f = Padic.mk g ↔ f ≈ g | null | true |
RCLike.norm_of_nonneg' | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {x : K}, 0 ≤ x → ↑‖x‖ = x | null | true |
CategoryTheory.Idempotents.KaroubiKaroubi.counitIso_hom_app_f_f | Mathlib.CategoryTheory.Idempotents.KaroubiKaroubi | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C]
(P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Idempotents.Karoubi C)),
((CategoryTheory.Idempotents.KaroubiKaroubi.counitIso C).hom.app P).f.f = P.p.f | null | true |
UInt8.add_left_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt8), -a + a = 0 | null | true |
Lean.Elab.Term.instAddErrorMessageContextTermElabM | Lean.Elab.Term.TermElabM | Lean.AddErrorMessageContext Lean.Elab.TermElabM | null | true |
Prod.totallyDisconnectedSpace | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [TotallyDisconnectedSpace α]
[TotallyDisconnectedSpace β], TotallyDisconnectedSpace (α × β) | null | true |
Lean.Lsp.ServerCapabilities.renameProvider? | Lean.Data.Lsp.Capabilities | Lean.Lsp.ServerCapabilities → Option Lean.Lsp.RenameOptions | null | true |
_private.Batteries.Data.List.Perm.0.List.cons_subperm_of_not_mem_of_mem.match_1_3 | Batteries.Data.List.Perm | ∀ {α : Type u_1} {a : α} {l₂ l₁ : List α} (motive : (a :: l₁).Subperm l₂ → Prop) (x : (a :: l₁).Subperm l₂),
(∀ (t : List α) (p' : t.Perm (a :: l₁)) (s' : t.Sublist l₂), motive ⋯) → motive x | null | false |
Subbimodule.mk._proof_2 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | null | false |
Mathlib.Tactic.Ring.Common.ExSumNat.evalPos._unsafe_rec | Mathlib.Tactic.Ring.Common | {a : Q(ℕ)} → Mathlib.Tactic.Ring.Common.ExSumNat a → Option Q(0 < «$a») | null | false |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.trans._proof_4 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.IsStableUnderBaseChange]
{S : AlgebraicGeometry.Scheme} {𝒰 : S.OpenCover} {i : 𝒰.I₀}, P.IsStableUnderBaseChangeAlong (𝒰.f i) | null | false |
Ideal.comap_map_of_bijective | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] (f : F)
[inst_3 : RingHomClass F R S], Function.Bijective ⇑f → ∀ {I : Ideal R}, Ideal.comap f (Ideal.map f I) = I | null | true |
MeasureTheory.ae_ball_iff | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {ι : Type u_4} {S : Set ι},
S.Countable →
∀ {p : α → (i : ι) → i ∈ S → Prop},
(∀ᵐ (x : α) ∂μ, ∀ (i : ι) (hi : i ∈ S), p x i hi) ↔ ∀ (i : ι) (hi : i ∈ S), ∀ᵐ (x : α) ∂μ, p x i hi | null | true |
_private.Batteries.Data.List.Lemmas.0.List.forIn'_cons.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {β : Type u_1} (motive : ForInStep β → Sort u_2) (b : β) (h_1 : (b : β) → motive (ForInStep.done b))
(h_2 : (b : β) → motive (ForInStep.yield b)),
(match ForInStep.done b with
| ForInStep.done b => h_1 b
| ForInStep.yield b => h_2 b) =
h_1 b | null | true |
DerivedWanted._sizeOf_inst | Batteries.Util.ProofWanted | (α : Sort u) → [SizeOf α] → SizeOf (DerivedWanted α) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.IsTuranMaximal.not_adj_trans._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
MeasureTheory.addMeasure_map_restrict_apply | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α]
(μ : MeasureTheory.Measure α) (s : Set α) {U : Set (Quotient (AddAction.orbitRel G α))},
MeasurableSet U →
(MeasureTheory.Measure.map (Quotient.mk (AddAction.orbitRel G α)) (μ.restrict s)) U =
μ (Quot... | null | true |
HahnSeries.embDomain | Mathlib.RingTheory.HahnSeries.Basic | {Γ : Type u_1} →
{Γ' : Type u_2} →
{R : Type u_3} →
[inst : PartialOrder Γ] →
[inst_1 : Zero R] → [inst_2 : PartialOrder Γ'] → Γ ↪o Γ' → HahnSeries Γ R → HahnSeries Γ' R | Extends the domain of a `HahnSeries` by an `OrderEmbedding`. | true |
Std.DTreeMap.Internal.Impl.Const.getKey?_alter | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k k' : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.getKey? k' =
if compare k k' = Ordering.eq then
if (f (Std.DTreeMap.Internal.Impl.Const.get? t... | null | true |
OrderIso.emptySumLex_apply_inr | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] [inst_2 : IsEmpty β] (x : α),
OrderIso.emptySumLex (toLex (Sum.inr x)) = x | null | true |
Pi.addCancelCommMonoid | Mathlib.Algebra.Group.Pi.Basic | {I : Type u} → {f : I → Type v₁} → [(i : I) → AddCancelCommMonoid (f i)] → AddCancelCommMonoid ((i : I) → f i) | null | true |
Std.Time.instReprDuration | Std.Time.Duration | Repr Std.Time.Duration | null | true |
Lean.Doc.Block._sizeOf_2_eq | Lean.DocString.Types | ∀ {i : Type u} {b : Type v} [inst : SizeOf i] [inst_1 : SizeOf b] (x : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))),
Lean.Doc.Block._sizeOf_2 x = sizeOf x | null | false |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceProjFn?.match_3 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.Expr → Sort u_1) →
(e? : Option Lean.Expr) → (Unit → motive none) → ((e : Lean.Expr) → motive (some e)) → motive e? | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.Basic.0.CategoryTheory.SimplicialObject.δ_comp_δ''._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {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 |
ModuleCat.instModuleElemForallObjCompForgetLinearMapIdCarrierSections._proof_8 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_1} [inst_1 : CategoryTheory.Category.{u_3, u_1} J]
(F : CategoryTheory.Functor J (ModuleCat R)) (x : ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections), 0 • x = 0 | null | false |
Submonoid.LocalizationMap.mk' | Mathlib.GroupTheory.MonoidLocalization.Basic | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} → {N : Type u_2} → [inst_1 : CommMonoid N] → S.LocalizationMap N → M → ↥S → N | Given a localization map `f : M →* N`, the surjection sending `(x, y) : M × S` to
`f x * (f y)⁻¹`. | true |
CategoryTheory.ShortComplex.LeftHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork_φH | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
(CategoryTheory.ShortComplex.LeftHomologyMap... | null | true |
powCardSubgroup._proof_3 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Group G] [inst_1 : Fintype G] (S : Set G),
1 ∈ S ^ Fintype.card G → S ^ Fintype.card G * S ^ Fintype.card G = S ^ Fintype.card G | null | false |
_private.ImportGraph.Tools.FindHome.0.Lean.Name.findHome.match_1 | ImportGraph.Tools.FindHome | (motive : Option Lean.Environment → Sort u_1) →
(env : Option Lean.Environment) →
((env : Lean.Environment) → motive (some env)) → ((x : Option Lean.Environment) → motive x) → motive env | null | false |
Lean.Grind.CommRing.Expr.toPolyS._sunfold | Init.Grind.Ring.CommSemiringAdapter | Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly | null | false |
_private.Lake.Util.Version.0.Lake.VerRange.ofClauses.fmtOrs | Lake.Util.Version | Array (Array Lake.VerComparator) → String | null | true |
Lean.instBEqAttributeKind.beq | Lean.Attributes | Lean.AttributeKind → Lean.AttributeKind → Bool | null | true |
CategoryTheory.Subgroupoid.mk.injEq | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (arrows : (c d : C) → Set (c ⟶ d))
(inv : ∀ {c d : C} {p : c ⟶ d}, p ∈ arrows c d → CategoryTheory.Groupoid.inv p ∈ arrows d c)
(mul :
∀ {c d e : C} {p : c ⟶ d},
p ∈ arrows c d → ∀ {q : d ⟶ e}, q ∈ arrows d e → CategoryTheory.CategoryStruct.comp p q ∈ arro... | null | true |
DFinsupp.Lex.orderBot._proof_1 | Mathlib.Data.DFinsupp.Lex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] (x : ι), x ∈ ∅ ∨ 0 x = 0 | null | false |
NFA.Path.ctorElimType | Mathlib.Computability.NFA | {α : Type u} →
{σ : Type v} →
{M : NFA α σ} →
{motive : (a a_1 : σ) → (a_2 : List α) → M.Path a a_1 a_2 → Sort u_1} →
ℕ → Sort (max 1 (imax (v + 1) u_1) (imax (v + 1) (v + 1) (v + 1) (u + 1) (u + 1) (max (u + 1) (v + 1)) u_1)) | null | false |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.eval.match_1.eq_1 | Mathlib.Computability.TuringMachine.Config | ∀ (motive : Turing.ToPartrec.Code → Sort u_1) (h_1 : Unit → motive Turing.ToPartrec.Code.zero')
(h_2 : Unit → motive Turing.ToPartrec.Code.succ) (h_3 : Unit → motive Turing.ToPartrec.Code.tail)
(h_4 : (f fs : Turing.ToPartrec.Code) → motive (f.cons fs)) (h_5 : (f g : Turing.ToPartrec.Code) → motive (f.comp g))
(h... | null | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.hasSum_pow_mul_geometric_of_norm_lt_one'._simp_1_1 | Mathlib.Analysis.SpecificLimits.Normed | ∀ {α : Type u_1} [inst : Semiring α] (m n : ℕ), ↑m ^ n = ↑(m ^ n) | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.DefEqCacheKey.mk.inj | Lean.Meta.Basic | ∀ {lhs rhs : Lean.Expr} {configKey : UInt64} {lhs_1 rhs_1 : Lean.Expr} {configKey_1 : UInt64},
{ lhs := lhs, rhs := rhs, configKey := configKey } = { lhs := lhs_1, rhs := rhs_1, configKey := configKey_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ configKey = configKey_1 | null | true |
Nat.isPowerOfTwo_one._simp_1 | Init.Data.Nat.Power2.Basic | Nat.isPowerOfTwo 1 = True | null | false |
AlgebraicGeometry.locallyQuasiFinite_iff_isFinite_fiber | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.QuasiCompact f],
AlgebraicGeometry.LocallyQuasiFinite f ↔
∀ (x : ↥Y), AlgebraicGeometry.IsFinite (AlgebraicGeometry.Scheme.Hom.fiberToSpecResidueField f x) | null | true |
MeasureTheory.TendstoInDistribution.add_of_tendstoInMeasure_const | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | ∀ {ι : Type u_1} {E : Type u_2} {Ω' : Type u_3} {Ω'' : Type u_4} {m' : MeasurableSpace Ω'}
{μ' : MeasureTheory.Measure Ω'} [inst : MeasureTheory.IsProbabilityMeasure μ'] {m'' : MeasurableSpace Ω''}
{μ'' : MeasureTheory.Measure Ω''} [inst_1 : MeasureTheory.IsProbabilityMeasure μ''] {mE : MeasurableSpace E}
{Z : Ω'... | null | true |
_private.Lean.Elab.ElabRules.0.Lean.Elab.Command.elabElab._regBuiltin.Lean.Elab.Command.elabElab_1 | Lean.Elab.ElabRules | IO Unit | null | false |
WithTop.decidableEq._aux_1 | Mathlib.Order.WithBot | {α : Type u_1} → [DecidableEq α] → DecidableEq (WithTop α) | null | false |
Std.DTreeMap.Raw.Equiv.constInsertMany_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t₁.WF →
t₂.WF →
t₁.Equiv t₂ →
∀ (l : List (α × β)), (Std.DTreeMap.Raw.Const.insertMany t₁ l).Equiv (Std.DTreeMap.Raw.Const.insertMany t₂ l) | null | true |
BoolAlg.Iso.mk._proof_9 | Mathlib.Order.Category.BoolAlg | ∀ {α β : BoolAlg} (e : ↑α ≃o ↑β) (a b : ↑β), e.symm (a ⊔ b) = e.symm a ⊔ e.symm b | null | false |
CategoryTheory.GradedObject.TriangleIndexData.casesOn | Mathlib.CategoryTheory.GradedObject.Unitor | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₃ : Type u_3} →
{J : Type u_4} →
[inst : Zero I₂] →
{r : I₁ × I₂ × I₃ → J} →
{π : I₁ × I₃ → J} →
{motive : CategoryTheory.GradedObject.TriangleIndexData r π → Sort u} →
(t : CategoryTheory.GradedObject.Triangle... | null | false |
cauchySeq_of_controlled | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] [inst : SemilatticeSup β] [Nonempty β] (U : β → SetRel α α),
(∀ s ∈ uniformity α, ∃ n, U n ⊆ s) → ∀ {f : β → α}, (∀ ⦃N m n : β⦄, N ≤ m → N ≤ n → (f m, f n) ∈ U N) → CauchySeq f | null | true |
VectorField.mlieBracketWithin_eq_zero_of_eq_zero | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {x : M} {V W : (x : M) → Ta... | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_neg._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
groupCohomology.H1π_comp_H1IsoOfIsTrivial_hom_assoc | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) [inst_2 : A.IsTrivial] {Z : ModuleCat k}
(h : ↧(Additive G →+ ↑A) ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupCohomology.H1π A)
(CategoryTheory.CategoryStruct.comp (groupCohomology.H1IsoOfIsTrivial A).hom h) =
CategoryTheor... | null | true |
SemimoduleCat.ofHom₂ | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u_1} → [inst : CommSemiring R] → {M N P : SemimoduleCat R} → (↑M →ₗ[R] ↑N →ₗ[R] ↑P) → (M ⟶ ↧(N ⟶ P)) | Turn a bilinear map into a homomorphism. | true |
SimpleGraph.Walk.isSubwalk_nil_end._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} (q : G.Walk u v), SimpleGraph.Walk.nil.IsSubwalk q = True | null | false |
CategoryTheory.Join.mapPairEquiv._proof_1 | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u_7} [inst : CategoryTheory.Category.{u_5, u_7} C] {D : Type u_8}
[inst_1 : CategoryTheory.Category.{u_6, u_8} D] {C' : Type u_3} [inst_2 : CategoryTheory.Category.{u_1, u_3} C']
{D' : Type u_4} [inst_3 : CategoryTheory.Category.{u_2, u_4} D'] (e : C ≌ C') (e' : D ≌ D')
(x : CategoryTheory.Join C D),
... | null | false |
LinearPMap.eq_of_eq_graph | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_4} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_5}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {f g : E →ₗ.[R] F}, f.graph = g.graph → f = g | null | true |
CategoryTheory.Subobject.Classifier.ofIso._proof_3 | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (𝒞 : CategoryTheory.Subobject.Classifier C) {Ω₀ Ω : C}
(eΩ : 𝒞.Ω ≅ Ω) (eΩ₀ : 𝒞.Ω₀ ≅ Ω₀) (t : Ω₀ ⟶ Ω),
t = CategoryTheory.CategoryStruct.comp eΩ₀.inv (CategoryTheory.CategoryStruct.comp 𝒞.truth eΩ.hom) →
CategoryTheory.Mono t | null | false |
Lean.Lsp.LeanLocationLink.ctorIdx | Lean.Data.Lsp.Internal | Lean.Lsp.LeanLocationLink → ℕ | null | false |
WeakDual.isClosed_closedBall | Mathlib.Analysis.Normed.Module.WeakDual | ∀ {𝕜 : Type u_1} {E : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] (x' : StrongDual 𝕜 E) (r : ℝ), IsClosed (⇑WeakDual.toStrongDual ⁻¹' Metric.closedBall x' r) | Closed balls in `StrongDual 𝕜 E` pull back to closed sets in `WeakDual 𝕜 E`. | true |
Real.volume_real_ball | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {a r : ℝ}, 0 ≤ r → MeasureTheory.volume.real (Metric.ball a r) = 2 * r | null | true |
CategoryTheory.MorphismProperty.exists_map_eq_of_presieve | Mathlib.CategoryTheory.MorphismProperty.CommaSites | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C} {S : C}
[P.IsStableUnderComposition],
∀ K ≤ P.precoverage,
∀ {X : P.Over ⊤ S} {R : CategoryTheory.Presieve ((CategoryTheory.MorphismProperty.Over.forget P ⊤ S).obj X)},
R ∈
(CategoryTheory.Prec... | null | true |
AddSubmonoid.closure_induction | Mathlib.Algebra.Group.Submonoid.Basic | ∀ {M : Type u_1} [inst : AddZeroClass M] {s : Set M} {motive : (x : M) → x ∈ AddSubmonoid.closure s → Prop},
(∀ (x : M) (h : x ∈ s), motive x ⋯) →
motive 0 ⋯ →
(∀ (x y : M) (hx : x ∈ AddSubmonoid.closure s) (hy : y ∈ AddSubmonoid.closure s),
motive x hx → motive y hy → motive (x + y) ⋯) →
... | An induction principle for additive closure membership. If `p` holds for `0` and all
elements of `s`, and is preserved under addition, then `p` holds for all elements of the
additive closure of `s`. | true |
Int.testBit_lnot | Mathlib.Data.Int.Bitwise | ∀ (n : ℤ) (k : ℕ), n.lnot.testBit k = !n.testBit k | null | true |
ExistsContDiffBumpBase.w._proof_1 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | null | false |
SzemerediRegularity.initialBound._proof_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | (99 + 1).AtLeastTwo | null | false |
CommAlgCat.Hom._mkInternal.injEq | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : CommAlgCat R} (hom' hom'_1 : ↑A →ₐ[R] ↑B),
({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | false |
Pi.lex_lt_of_lt | Mathlib.Order.PiLex | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → PartialOrder (β i)] {r : ι → ι → Prop},
WellFounded r → ∀ {x y : (i : ι) → β i}, x < y → Pi.Lex r (fun {i} x1 x2 => x1 < x2) x y | null | true |
Lean.Lsp.CodeActionLiteralSupportValueSet | Lean.Data.Lsp.CodeActions | Type | null | true |
hasBasis_nhdsSet_Ici_Ioi | Mathlib.Topology.Order.NhdsSet | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α] (a : α) [Nonempty ↑(Set.Iio a)],
(nhdsSet (Set.Ici a)).HasBasis (fun x => x < a) Set.Ioi | null | true |
Aesop.MVarCluster.state | Aesop.Tree.Data | Aesop.MVarCluster → Aesop.NodeState | null | true |
Primrec.eq | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α], PrimrecRel Eq | null | true |
OrderDual.mulLeftMono | Mathlib.Algebra.Order.Monoid.Unbundled.OrderDual | ∀ {α : Type u} [inst : LE α] [inst_1 : Mul α] [c : MulLeftMono α], MulLeftMono αᵒᵈ | null | true |
eventually_mem_nhds_iff | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (∀ᶠ (x' : X) in nhds x, s ∈ nhds x') ↔ s ∈ nhds x | null | true |
Subgroup.quotientiInfSubgroupOfEmbedding_apply | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {ι : Type u_2} (f : ι → Subgroup α) (H : Subgroup α)
(q : ↥H ⧸ (⨅ i, f i).subgroupOf H) (i : ι),
(Subgroup.quotientiInfSubgroupOfEmbedding f H) q i = Subgroup.quotientSubgroupOfMapOfLE H ⋯ q | null | true |
_private.Lean.Compiler.LCNF.ReduceArity.0.Lean.Compiler.LCNF.Decl.reduceArity.match_3 | Lean.Compiler.LCNF.ReduceArity | (motive : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.pure) →
((code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.DeclValue.code code)) →
((externAttrData : Lean.Extern... | null | false |
dotProduct_star_self_nonneg | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : PartialOrder R] [inst_2 : NonUnitalRing R]
[inst_3 : StarRing R] [StarOrderedRing R] (v : n → R), 0 ≤ star v ⬝ᵥ v | Note that this applies to `ℂ` via `RCLike.toStarOrderedRing`. | true |
Plausible.TotalFunction.noConfusionType | Plausible.Functions | Sort u_1 →
{α : Type u} →
{β : Type v} →
Plausible.TotalFunction α β → {α' : Type u} → {β' : Type v} → Plausible.TotalFunction α' β' → Sort u_1 | null | false |
MeasureTheory.TendstoInDistribution.casesOn | Mathlib.MeasureTheory.Function.ConvergenceInDistribution | {ι : Type u_1} →
{E : Type u_2} →
{Ω' : Type u_3} →
{Ω : ι → Type u_5} →
{m : (i : ι) → MeasurableSpace (Ω i)} →
{m' : MeasurableSpace Ω'} →
{mE : MeasurableSpace E} →
[inst : TopologicalSpace E] →
[inst_1 : OpensMeasurableSpace E] →
... | null | false |
LinearMap.baseChange_add | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N] [inst_5 : Module R M]
[inst_6 : Module R N] (f g : M →ₗ[R] N),
LinearMap.baseChange A (f + g) = LinearMap.baseChange A f + Linear... | null | true |
FreeSimplexQuiver.homRel.σ_comp_σ | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i j : Fin (n + 1)},
i ≤ j →
FreeSimplexQuiver.homRel
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ i.castSucc))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.σ j)))
(CategoryTheory.CategoryStru... | null | true |
mdifferentiableOn_extend_symm | Mathlib.Geometry.Manifold.MFDeriv.Atlas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {e : OpenPartialHomeomorph M H},
e ∈ ... | null | true |
nndist_comm | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (x y : α), nndist x y = nndist y x | null | true |
Std.DTreeMap.Raw.get_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqCmp cmp] (h : t.WF) {l : List ((a : α) × β a)}
{k : α} (contains : (List.map Sigma.fst l).contains k = false) {h' : k ∈ t.insertMan... | null | true |
Matrix.GeneralLinearGroup.rowScale._proof_3 | Mathlib.LinearAlgebra.Matrix.ElementaryRowOperations | ∀ {R : Type u_1} {m : Type u_2} [inst : DecidableEq m] [inst_1 : CommRing R] [inst_2 : Fintype m] (i : m) (c : Rˣ),
Matrix.rowScale i ↑c⁻¹ * Matrix.rowScale i ↑c = 1 | null | false |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.addSplitCandidatesForFunext | Lean.Meta.Tactic.Grind.Internalize | Lean.Expr → ℕ → optParam (Option Lean.Expr) none → Lean.Meta.Grind.GoalM Unit | Applies `addSplitCandidatesForExt` if `funext` is enabled. | true |
Equiv.cast_eq_iff_heq | Mathlib.Logic.Equiv.Defs | ∀ {α β : Sort u_1} (h : α = β) {a : α} {b : β}, (Equiv.cast h) a = b ↔ a ≍ b | null | true |
_private.Mathlib.Data.Sum.Basic.0.Sum.getLeft_eq_getLeft?._proof_1_2 | Mathlib.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α ⊕ β},
x.getLeft?.isSome = true → ∀ (val : α), Sum.inl val = x → (some val).isSome = true | null | false |
Matrix.cons_vecAlt1 | Mathlib.Data.Fin.VecNotation | ∀ {α : Type u} {m n : ℕ} (h : m + 1 + 1 = n + 1 + (n + 1)) (x y : α) (u : Fin m → α),
Matrix.vecAlt1 h (Matrix.vecCons x (Matrix.vecCons y u)) = Matrix.vecCons y (Matrix.vecAlt1 ⋯ u) | null | true |
ENNReal.lintegral_mul_le_Lp_mul_Lq | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {p q : ℝ},
p.HolderConjugate q →
∀ {f g : α → ENNReal},
AEMeasurable f μ →
AEMeasurable g μ →
∫⁻ (a : α), (f * g) a ∂μ ≤ (∫⁻ (a : α), f a ^ p ∂μ) ^ (1 / p) * (∫⁻ (a : α), g a ^ q ∂μ) ^ (1 / q) | Hölder's inequality for functions `α → ℝ≥0∞`. The integral of the product of two functions
is bounded by the product of their `ℒp` and `ℒq` seminorms when `p` and `q` are conjugate
exponents. | true |
MulRingSeminorm.toFun_eq_coe | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_1} [inst : NonAssocRing R] (p : MulRingSeminorm R), ⇑p.toAddGroupSeminorm = ⇑p | null | true |
HahnSeries.SummableFamily.smul_eq | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} {V : Type u_4} {β : Type u_6} [inst : PartialOrder Γ]
[inst_1 : PartialOrder Γ'] [inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid R] [inst_4 : SMulWithZero R V]
[inst_5 : VAdd Γ Γ'] [inst_6 : IsOrderedCancelVAdd Γ Γ'] {x : HahnSeries Γ R} {t : HahnSeries.SummableFam... | null | true |
CategoryTheory.Aut.instGroup._proof_14 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) (a : CategoryTheory.Aut X), a⁻¹ * a = 1 | null | false |
Metric.tendsto_nhds | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] {f : Filter β} {u : β → α} {a : α},
Filter.Tendsto u f (nhds a) ↔ ∀ ε > 0, ∀ᶠ (x : β) in f, dist (u x) a < ε | null | true |
CategoryTheory.Abelian.SpectralObject.dHomologyData_left_K | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ i₆ i₇ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅)
... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.