name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE.0.CategoryTheory.Triangulated.TStructure.isLE_iff_orthogonal._proof_1_1 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ (n₀ n₁ : ℤ), n₀ + 1 = n₁ → n₀ < n₁ | false |
CategoryTheory.Sieve.generate_of_singleton_isSplitEpi | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : Y ⟶ X) [CategoryTheory.IsSplitEpi f],
CategoryTheory.Sieve.generate (CategoryTheory.Presieve.singleton f) = ⊤ | true |
Rep.coinvariantsTensorFreeLEquiv._proof_1 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (α : Type u_1)
[inst_2 : DecidableEq α] (i : α) (x : ↑A),
((A.coinvariantsTensorFreeToFinsupp α ∘ₗ A.finsuppToCoinvariantsTensorFree α) fun₀ | i => x) =
LinearMap.id fun₀ | i => x | false |
CategoryTheory.Abelian.SpectralObject.isIso_map._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
EStateM.run'_get | Batteries.Lean.EStateM | ∀ {σ ε : Type u_1} (s : σ), get.run' s = some s | true |
MeasureTheory.OuterMeasure.le_boundedBy' | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} {m : Set α → ENNReal} {μ : MeasureTheory.OuterMeasure α},
μ ≤ MeasureTheory.OuterMeasure.boundedBy m ↔ ∀ (s : Set α), s.Nonempty → μ s ≤ m s | true |
algebraMap.smul' | Mathlib.Algebra.Algebra.Defs | ∀ {A : Type u_1} {B : Type u_2} (a : A) (b : B) (C : Type u_3) [inst : SMul A B] [inst_1 : CommSemiring B]
[inst_2 : Semiring C] [inst_3 : Algebra B C] [inst_4 : Monoid A] [inst_5 : MulDistribMulAction A C]
[SMulDistribClass A B C], (algebraMap B C) (a • b) = a • (algebraMap B C) b | true |
Lean.Compiler.LCNF.normCode | Lean.Compiler.LCNF.CompilerM | {m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{t : Bool} →
[MonadLiftT Lean.Compiler.LCNF.CompilerM m] →
[Monad m] →
[Lean.Compiler.LCNF.MonadFVarSubst m pu t] → Lean.Compiler.LCNF.Code pu → m (Lean.Compiler.LCNF.Code pu) | true |
MeasureTheory.uniformIntegrable_subsingleton | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup β] {p : ENNReal} {f : ι → α → β} [Subsingleton ι],
1 ≤ p → p ≠ ⊤ → (∀ (i : ι), MeasureTheory.MemLp (f i) p μ) → MeasureTheory.UniformIntegrable f p μ | true |
upperClosure_union | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s t : Set α), upperClosure (s ∪ t) = upperClosure s ⊓ upperClosure t | true |
OrderDual.instSemifield._proof_5 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [Semifield K], Nontrivial Kᵒᵈ | false |
Lean.Meta.NormCast.countCoes | Lean.Meta.Tactic.NormCast | Lean.Expr → Lean.MetaM ℕ | true |
ofDual_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : αᵒᵈ), OrderDual.ofDual (￢a) = (OrderDual.ofDual a)ᶜ | true |
CategoryTheory.evaluationAdjunctionLeft._proof_4 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] (D : Type u_3)
[inst_1 : CategoryTheory.Category.{u_1, u_3} D]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] (c : C) (F : CategoryTheory.Functor C D)
(d : D),
Function.RightInverse
(fun f =>
CategoryTheory.CategoryStruct.comp (f.app c)
(CategoryTheory.Limits.Pi.π (fun x => d) (CategoryTheory.CategoryStruct.id c)))
fun f =>
{ app := fun x => CategoryTheory.Limits.Pi.lift fun g => CategoryTheory.CategoryStruct.comp (F.map g) f,
naturality := ⋯ } | false |
Turing.TM0to1.Λ' | Mathlib.Computability.TuringMachine.PostTuringMachine | Type u_1 → Type u_2 → Type (max u_1 u_2) | true |
_private.Mathlib.Topology.Filter.0.Filter.nhds_eq._simp_1_1 | Mathlib.Topology.Filter | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) | false |
Relation.comp_assoc | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {r : α → β → Prop} {p : β → γ → Prop} {q : γ → δ → Prop},
Relation.Comp (Relation.Comp r p) q = Relation.Comp r (Relation.Comp p q) | true |
Preorder.restrictLe | Mathlib.Order.Restriction | {α : Type u_1} → [inst : Preorder α] → {π : α → Type u_2} → (a : α) → ((a : α) → π a) → (a_1 : ↑(Set.Iic a)) → π ↑a_1 | true |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.IsStoppingTime.max._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (max a b ≤ c) = (a ≤ c ∧ b ≤ c) | false |
Aesop.PhaseSpec.norm.noConfusion | Aesop.Builder.Basic | {P : Sort u} →
{info info' : Aesop.NormRuleInfo} → Aesop.PhaseSpec.norm info = Aesop.PhaseSpec.norm info' → (info = info' → P) → P | false |
_private.Init.Data.Order.LemmasExtra.0.Std.instLawfulEqOrdOfLawfulOrderOrdOfIsPartialOrder._simp_1 | Init.Data.Order.LemmasExtra | ∀ {α : Type u} [inst : Ord α] [inst_1 : LE α] [Std.LawfulOrderOrd α] {a b : α}, (a ≤ b) = ((compare a b).isLE = true) | false |
Ideal.KerLift.map_smul | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R₁ : Type u_1} {A : Type u_3} {B : Type u_4} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A]
[inst_3 : Semiring B] [inst_4 : Algebra R₁ B] (f : A →ₐ[R₁] B) (r : R₁) (x : A ⧸ RingHom.ker f),
f.kerLift (r • x) = r • f.kerLift x | true |
monTypeEquivalenceMon._proof_3 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ (A : MonCat) (x x_1 : (MonTypeEquivalenceMon.inverse.obj A).X),
(Equiv.refl (MonTypeEquivalenceMon.inverse.obj A).X).toFun (x * x_1) =
(Equiv.refl (MonTypeEquivalenceMon.inverse.obj A).X).toFun (x * x_1) | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin._simp_9 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (c ≤ min a b) = (c ≤ a ∧ c ≤ b) | false |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Add.0.MeasureTheory.lintegral_iSup._simp_1_4 | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} (f : MeasureTheory.SimpleFunc α ENNReal) (μ : MeasureTheory.Measure α),
f.lintegral μ = ∫⁻ (a : α), f a ∂μ | false |
bihimp_le_iff_left | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : BooleanAlgebra α] (a b : α), bihimp a b ≤ a ↔ Codisjoint a b | true |
_private.Mathlib.Algebra.Algebra.Subalgebra.Lattice.0.AlgHom.equalizer_eq_top._simp_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = ∀ (x : B), x ∈ p ↔ x ∈ q | false |
Lean.instCoeNatDataValue | Lean.Data.KVMap | Coe ℕ Lean.DataValue | true |
Lean.NamingContext.ctorIdx | Lean.Message | Lean.NamingContext → ℕ | false |
Vector.mem_zipIdx._proof_2 | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {x : α} {i : ℕ} {xs : Vector α n} {k : ℕ}, (x, i) ∈ xs.zipIdx k → i - k < n | false |
symmDiff_of_le | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, a ≤ b → symmDiff a b = b \ a | true |
Ring.zsmul_succ' | Mathlib.Algebra.Ring.Defs | ∀ {R : Type u} [self : Ring R] (n : ℕ) (a : R), Ring.zsmul (↑n.succ) a = Ring.zsmul (↑n) a + a | true |
Asymptotics.IsBigOWith.norm_left | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {c : ℝ} {g : α → F}
{f' : α → E'} {l : Filter α}, Asymptotics.IsBigOWith c l f' g → Asymptotics.IsBigOWith c l (fun x => ‖f' x‖) g | true |
Differentiable.rpow_const | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {p : ℝ},
Differentiable ℝ f → (∀ (x : E), f x ≠ 0 ∨ 1 ≤ p) → Differentiable ℝ fun x => f x ^ p | true |
_private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowAsserted._regBuiltin._private.Lean.Elab.Tactic.Grind.ShowState.0.Lean.Elab.Tactic.Grind.evalShowAsserted_1 | Lean.Elab.Tactic.Grind.ShowState | IO Unit | false |
MeasureTheory.Measure.map_mono_of_aemeasurable | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {α : Type u_2} {δ : Type u_5} {m0 : MeasurableSpace α} [inst : MeasurableSpace δ] {μ ν : MeasureTheory.Measure α}
{f : α → δ}, μ ≤ ν → AEMeasurable f ν → MeasureTheory.Measure.map f μ ≤ MeasureTheory.Measure.map f ν | true |
IO.setStderr | Init.System.IO | IO.FS.Stream → BaseIO IO.FS.Stream | true |
Lean.Meta.InjectionsResult._sizeOf_1 | Lean.Meta.Tactic.Injection | Lean.Meta.InjectionsResult → ℕ | false |
Aesop.GoalState.isProvenByNormalization | Aesop.Tree.Data | Aesop.GoalState → Bool | true |
CategoryTheory.Pretriangulated.Triangle.instNegHom._proof_2 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} [inst_2 : CategoryTheory.Preadditive C] (f : T₁ ⟶ T₂),
CategoryTheory.CategoryStruct.comp T₁.mor₁ (-f.hom₂) = CategoryTheory.CategoryStruct.comp (-f.hom₁) T₂.mor₁ | false |
_private.Std.Data.DTreeMap.Raw.Lemmas.0.Std.DTreeMap.Raw.Equiv.union_right.match_1_1 | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₂ t₃ : Std.DTreeMap.Raw α β cmp}
(motive : t₂.Equiv t₃ → Prop) (equiv : t₂.Equiv t₃), (∀ (equiv : t₂.inner.Equiv t₃.inner), motive ⋯) → motive equiv | false |
Std.Time.FormatPart.string | Std.Time.Format.Basic | String → Std.Time.FormatPart | true |
Mathlib.Tactic.Push.initFn._@.Mathlib.Tactic.Push.Attr.3484215244._hygCtx._hyg.2 | Mathlib.Tactic.Push.Attr | IO (Lean.SimpleScopedEnvExtension Mathlib.Tactic.Push.PullTheorem (Lean.Meta.DiscrTree Mathlib.Tactic.Push.PullTheorem)) | false |
Lean.Macro.Exception.ctorElim | Init.Prelude | {motive : Lean.Macro.Exception → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Macro.Exception) → ctorIdx = t.ctorIdx → Lean.Macro.Exception.ctorElimType ctorIdx → motive t | false |
fderivWithin_comp_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (a : E), fderivWithin 𝕜 (fun x => f (x - a)) s x = fderivWithin 𝕜 f (-a +ᵥ s) (x - a) | true |
HomologicalComplex.extendOpIso._proof_1 | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_4} {ι' : Type u_1} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (K : HomologicalComplex C c) (e : c.Embedding c') (x x_1 : ι'),
c'.symm.Rel x x_1 →
CategoryTheory.CategoryStruct.comp (HomologicalComplex.extend.XOpIso K (e.op.r x)).hom
(HomologicalComplex.extend.d K (e.r x_1) (e.op.r x)).op =
CategoryTheory.CategoryStruct.comp (HomologicalComplex.extend.d K.op (e.op.r x) (e.r x_1))
(HomologicalComplex.extend.XOpIso K (e.r x_1)).hom | false |
Lean.Compiler.LCNF.CSE.State.subst._default | Lean.Compiler.LCNF.CSE | Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure | false |
CategoryTheory.EffectiveEpi.uniq | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y W : C} (f : Y ⟶ X)
[inst_1 : CategoryTheory.EffectiveEpi f] (e : Y ⟶ W)
(h :
∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e)
(m : X ⟶ W), CategoryTheory.CategoryStruct.comp f m = e → m = CategoryTheory.EffectiveEpi.desc f e ⋯ | true |
MeasureTheory.MeasurePreserving.add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Add G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddLeftInvariant] (g : G) {X : Type u_3} [inst_4 : MeasurableSpace X] {μ' : MeasureTheory.Measure X} {f : X → G},
MeasureTheory.MeasurePreserving f μ' μ → MeasureTheory.MeasurePreserving (fun x => g + f x) μ' μ | true |
Std.Internal.IO.Process.getId | Std.Internal.Async.Process | IO Std.Internal.IO.Process.PId | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Coskeletal.0.SSet.StrictSegal.isPointwiseRightKanExtensionAt.fac_aux₂._proof_1_9 | Mathlib.AlgebraicTopology.SimplicialSet.Coskeletal | 2 ≤ 2 | false |
CategoryTheory.Precoverage.Saturate.casesOn | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.Precoverage C}
{motive : (X : C) → (a : CategoryTheory.Sieve X) → J.Saturate X a → Prop} {X : C} {a : CategoryTheory.Sieve X}
(t : J.Saturate X a),
(∀ (X : C) (S : CategoryTheory.Presieve X) (hS : S ∈ J.coverings X), motive X (CategoryTheory.Sieve.generate S) ⋯) →
(∀ (X : C), motive X ⊤ ⋯) →
(∀ (X : C) (S : CategoryTheory.Sieve X) (a : J.Saturate X S) (Y : C) (f : Y ⟶ X),
motive Y (CategoryTheory.Sieve.pullback f S) ⋯) →
(∀ (X : C) (S R : CategoryTheory.Sieve X) (a : J.Saturate X S)
(a_1 : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → J.Saturate Y (CategoryTheory.Sieve.pullback f R)),
motive X R ⋯) →
motive X a t | false |
Filter.Subsingleton.of_subsingleton._simp_1 | Mathlib.Order.Filter.Subsingleton | ∀ {α : Type u_1} {l : Filter α} [Subsingleton α], l.Subsingleton = True | false |
Lean.Widget.HighlightedMsgEmbed.expr.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | ∀ (a : Lean.Widget.HighlightedCodeWithInfos), sizeOf (Lean.Widget.HighlightedMsgEmbed.expr a) = 1 + sizeOf a | true |
subset_interior_vadd | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace β] [inst_1 : AddGroup α] [inst_2 : AddAction α β]
[ContinuousConstVAdd α β] {s : Set α} {t : Set β} [inst_4 : TopologicalSpace α],
interior s +ᵥ interior t ⊆ interior (s +ᵥ t) | true |
Mathlib.Meta.FunProp.transitionTheoremsExt | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.GeneralTheoremsExt | true |
Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt_apply_zero | Mathlib.RingTheory.Valuation.Discrete.RankOne | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {R : Type u_2} [inst_1 : Ring R] (v : Valuation R Γ)
[hv : v.IsRankOneDiscrete], (Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt v) 0 = 0 | true |
Lean.MonadCacheT.instMonadRef | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] → [inst_2 : Hashable α] → [Lean.MonadRef m] → Lean.MonadRef (Lean.MonadCacheT α β m) | true |
AddMonoidAlgebra.nonAssocSemiring._proof_3 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddZeroClass M], AddMonoidAlgebra.single 0 ↑0 = 0 | false |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.0.definition._simp_7._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.588747923._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.mahlerMeasure_pos_of_ne_zero._proof_1_2 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {p : Polynomial ℂ}, p ≠ 0 → 0 < p.mahlerMeasure | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addMonToLaxMonoidal_obj | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(A : CategoryTheory.AddMon C),
(CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addMonToLaxMonoidal C).obj A =
CategoryTheory.LaxMonoidalFunctor.of (CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.addMonToLaxMonoidalObj A) | true |
Batteries.CodeAction.getMatchHeaderRange?._sparseCasesOn_1 | Batteries.CodeAction.Match | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Lean.Widget.TaggedText.tag.elim | Lean.Widget.TaggedText | {α : Type u} →
{motive_1 : Lean.Widget.TaggedText α → Sort u_1} →
(t : Lean.Widget.TaggedText α) →
t.ctorIdx = 2 →
((a : α) → (a_1 : Lean.Widget.TaggedText α) → motive_1 (Lean.Widget.TaggedText.tag a a_1)) → motive_1 t | false |
CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) →
[CategoryTheory.Limits.HasLimitsOfShape K C] → CategoryTheory.Limits.DiagramOfCones F | true |
Associates.count_mul | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α]
[inst_2 : DecidableEq (Associates α)] [inst_3 : (p : Associates α) → Decidable (Irreducible p)] {a : Associates α},
a ≠ 0 →
∀ {b : Associates α},
b ≠ 0 → ∀ {p : Associates α}, Irreducible p → p.count (a * b).factors = p.count a.factors + p.count b.factors | true |
Submodule.finrank_le | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M] (s : Submodule R M), Module.finrank R ↥s ≤ Module.finrank R M | true |
ArchimedeanClass.instCommRingFiniteElement._aux_20 | Mathlib.Algebra.Order.Ring.StandardPart | (K : Type u_1) →
[inst : LinearOrder K] → [inst_1 : Field K] → [inst_2 : IsOrderedRing K] → ArchimedeanClass.FiniteElement K | false |
Module.quotientAnnihilator._proof_2 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.IsTorsionBySet R M ↑(Module.annihilator R M) | false |
Std.Sat.AIG.ExtendTarget.mk.sizeOf_spec | Std.Sat.AIG.Basic | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {newWidth : ℕ} [inst_2 : SizeOf α]
(w : ℕ) (vec : aig.RefVec w), sizeOf { w := w, vec := vec } = 1 + sizeOf w + sizeOf vec | true |
HahnSeries.SummableFamily.instZero._proof_2 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_3} {R : Type u_2} {α : Type u_1} [inst : PartialOrder Γ] [inst_1 : AddCommMonoid R] (g : Γ),
{a | (0 a).coeff g ≠ 0}.Finite | false |
Valuation.IsEquiv.val_eq | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} {Γ'₀ : Type u_5} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀]
[inst_2 : LinearOrderedCommMonoidWithZero Γ'₀] {v₁ : Valuation R Γ₀} {v₂ : Valuation R Γ'₀},
v₁.IsEquiv v₂ → ∀ {r s : R}, v₁ r = v₁ s ↔ v₂ r = v₂ s | true |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.LinearMap.instIsSimpleModuleEndOfNontrivial.match_1 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {M : Type u_1} [inst : AddCommGroup M] (R : Type u_2) [inst_1 : DivisionRing R] [inst_2 : Module R M] (v w : M)
(motive : (∃ h, h ∘ₗ LinearMap.toSpanSingleton R M v = LinearMap.toSpanSingleton R M w) → Prop)
(x : ∃ h, h ∘ₗ LinearMap.toSpanSingleton R M v = LinearMap.toSpanSingleton R M w),
(∀ (f : M →ₗ[R] M) (eq : f ∘ₗ LinearMap.toSpanSingleton R M v = LinearMap.toSpanSingleton R M w), motive ⋯) → motive x | false |
CommRingCat.mkUnder_ext | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ {R : CommRingCat} {A : Type u} [inst : CommRing A] [inst_1 : Algebra (↑R) A] {B : CategoryTheory.Under R}
{f g : R.mkUnder A ⟶ B},
(∀ (a : A), (CategoryTheory.ConcreteCategory.hom f.right) a = (CategoryTheory.ConcreteCategory.hom g.right) a) → f = g | true |
CategoryTheory.Limits.pullbackProdSndIsoProd_inv_fst_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) (Z : C)
[inst_1 : CategoryTheory.Limits.HasBinaryProduct Z Y] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Z X]
[inst_3 : CategoryTheory.Limits.HasPullback CategoryTheory.Limits.prod.snd f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackProdSndIsoProd f Z).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst CategoryTheory.Limits.prod.snd f)
CategoryTheory.Limits.prod.fst) =
CategoryTheory.Limits.prod.fst | true |
Turing.TM0to1.Λ'.normal | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → Λ → Turing.TM0to1.Λ' Γ Λ | true |
Std.DTreeMap.Raw.getKey?_of_isEmpty | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, t.isEmpty = true → t.getKey? a = none | true |
SSet.RelativeMorphism.botEquiv._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.Homotopy | ∀ {X Y : SSet}, Function.LeftInverse (fun f => { map := f, comm := ⋯ }) fun f => f.map | false |
Bundle.Trivialization.coordChange.eq_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e₁ e₂ : Bundle.Trivialization F proj) (b : B) (x : F),
e₁.coordChange e₂ b x = (↑e₂ (↑e₁.symm (b, x))).2 | true |
Std.Time.Modifier.eorc.injEq | Std.Time.Format.Basic | ∀ (presentation presentation_1 : Std.Time.Number ⊕ Std.Time.Text),
(Std.Time.Modifier.eorc presentation = Std.Time.Modifier.eorc presentation_1) = (presentation = presentation_1) | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt8.reduceBNe.declare_66._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx.3.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.781669616._hygCtx._hyg.303 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
Tree.«term_△_» | Mathlib.Data.Tree.Basic | Lean.TrailingParserDescr | true |
Finset.smul_finset_inter_subset | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] {s₁ s₂ : Finset β} {a : α},
a • (s₁ ∩ s₂) ⊆ a • s₁ ∩ a • s₂ | true |
Std.ExtDTreeMap.maxKey?_insert | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insert k v).maxKey? = some (t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k') | true |
OrderIso.setIsotypicComponents.eq_1 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsSemisimpleModule R M],
OrderIso.setIsotypicComponents =
{ toFun := fun s => ⨆ c ∈ s, ⟨↑c, ⋯⟩, invFun := fun m => {c | ↑c ≤ ↑m}, left_inv := ⋯, right_inv := ⋯,
map_rel_iff' := ⋯ } | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.findPrefixTranslation?.go._sparseCasesOn_1 | Mathlib.Tactic.Translate.Core | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
circleMap_sub_center | Mathlib.Analysis.SpecialFunctions.Complex.CircleMap | ∀ (c : ℂ) (R θ : ℝ), circleMap c R θ - c = circleMap 0 R θ | true |
Std.DHashMap.Raw.getKey?_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
{k k' : α} {f : Option (β k) → Option (β k)},
m.WF →
(m.alter k f).getKey? k' =
if (k == k') = true then if (f (m.get? k)).isSome = true then some k else none else m.getKey? k' | true |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.d | Mathlib.NumberTheory.PellMatiyasevic | {a : ℕ} → 1 < a → ℕ | true |
ContinuousMap.toLp_comp_toContinuousMap | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {p : ENNReal} (μ : MeasureTheory.Measure α)
[inst : TopologicalSpace α] [inst_1 : BorelSpace α] [inst_2 : NormedAddCommGroup E]
[inst_3 : SecondCountableTopologyEither α E] [inst_4 : CompactSpace α] [inst_5 : MeasureTheory.IsFiniteMeasure μ]
{𝕜 : Type u_3} [inst_6 : Fact (1 ≤ p)] [inst_7 : NormedRing 𝕜] [inst_8 : Module 𝕜 E] [inst_9 : IsBoundedSMul 𝕜 E]
(f : BoundedContinuousFunction α E),
(ContinuousMap.toLp p μ 𝕜) f.toContinuousMap = (BoundedContinuousFunction.toLp p μ 𝕜) f | true |
Lean.Lsp.LeanLocationLink | Lean.Data.Lsp.Internal | Type | true |
pow_le_pow_iff_right₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀]
[ZeroLEOneClass M₀], 1 < a → (a ^ n ≤ a ^ m ↔ n ≤ m) | true |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.State.fieldIdx | Lean.Elab.Structure | Lean.Elab.Command.Structure.State✝ → Lean.NameMap ℕ | true |
MeasureTheory.Measure.haar.is_left_invariant_addCHaar | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
{K₀ : TopologicalSpace.PositiveCompacts G} (g : G) (K : TopologicalSpace.Compacts G),
MeasureTheory.Measure.haar.addCHaar K₀ (TopologicalSpace.Compacts.map (fun x => g + x) ⋯ K) =
MeasureTheory.Measure.haar.addCHaar K₀ K | true |
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.Monic.not_irreducible_iff_exists_add_mul_eq_coeff._simp_1_1 | Mathlib.Algebra.Polynomial.Monic | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | false |
AddSubmonoid.fromLeftNeg.eq_1 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubmonoid M) (x : ↥S.leftNeg), S.fromLeftNeg x = Exists.choose ⋯ | true |
CompleteLattice.IsCompactElement.exists_finset_of_le_iSup | Mathlib.Order.CompactlyGenerated.Basic | ∀ (α : Type u_2) [inst : CompleteLattice α] {k : α},
IsCompactElement k → ∀ {ι : Type u_3} (f : ι → α), k ≤ ⨆ i, f i → ∃ s, k ≤ ⨆ i ∈ s, f i | true |
Lean.versionStringCore | Init.Meta.Defs | String | true |
Lean.Elab.WF.floatRecApp | Lean.Elab.PreDefinition.WF.FloatRecApp | Lean.Expr → Lean.CoreM Lean.Expr | true |
Finset.seqLeft_def | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} [inst : (P : Prop) → Decidable P] (s : Finset α) (t : Finset β), s <* t = if t = ∅ then ∅ else s | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.