name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Pi.instBraidedForallEval._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_3} {C : I → Type u_2} [inst : (i : I) → CategoryTheory.Category.{u_1, u_2} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)]
(i : I) (X Y : (i : I) → C i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal... | false |
Aesop.BaseRuleSet.mk.injEq | Aesop.RuleSet | ∀ (normRules : Aesop.Index Aesop.NormRuleInfo) (unsafeRules : Aesop.Index Aesop.UnsafeRuleInfo)
(safeRules : Aesop.Index Aesop.SafeRuleInfo) (unfoldRules : Lean.PHashMap Lean.Name (Option Lean.Name))
(forwardRules : Aesop.ForwardIndex) (forwardRuleNames : Lean.PHashSet Aesop.RuleName)
(rulePatterns : Aesop.RulePa... | true |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.exprToMatcher.match_12 | Mathlib.Util.Notation3 | (motive : List Mathlib.Notation3.DelabKey × Lean.TSyntax `term → Sort u_1) →
(__discr : List Mathlib.Notation3.DelabKey × Lean.TSyntax `term) →
((keys : List Mathlib.Notation3.DelabKey) → (matchF : Lean.TSyntax `term) → motive (keys, matchF)) → motive __discr | false |
Std.Time.Month.instLawfulEqOrdOffset | Std.Time.Date.Unit.Month | Std.LawfulEqOrd Std.Time.Month.Offset | true |
BitVec.instRxcIsAlwaysFinite | Init.Data.Range.Polymorphic.BitVec | ∀ {n : ℕ}, Std.Rxc.IsAlwaysFinite (BitVec n) | true |
BddOrd.Iso.mk | Mathlib.Order.Category.BddOrd | {α β : BddOrd} → ↑α.toPartOrd ≃o ↑β.toPartOrd → (α ≅ β) | true |
_private.Mathlib.RingTheory.Smooth.StandardSmoothCotangent.0.Algebra.SubmersivePresentation.sectionCotangent_zero_of_notMem_range._proof_1_1 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_3} {S : Type u_4} {ι : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (i : ι),
(¬∀ (i_1 : σ), (if i = P.map i_1 then 1 else 0) = 0) → i ∈ Set.range P.map | false |
IsDiscrete.mono | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsDiscrete s → t ⊆ s → IsDiscrete t | true |
_private.Std.Time.Date.Basic.0.Std.Time.Millisecond.Offset.ofDays._proof_1 | Std.Time.Date.Basic | 86400 / ↑86400000 = 1 / 1000 | false |
instAddCommMonoidWithOneENNReal._proof_16 | Mathlib.Data.ENNReal.Basic | ∀ (a b : ENNReal), a + b = b + a | false |
Option.bind_eq_none' | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {o : Option α} {f : α → Option β},
o.bind f = none ↔ ∀ (b : β) (a : α), o = some a → f a ≠ some b | true |
_private.Mathlib.Data.Real.Archimedean.0.Real.exists_isLUB.match_1_4 | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ} (f : ℕ → ℤ) (n : ℕ) (motive : (∃ y ∈ s, ↑(↑(f n) / ↑n) ≤ y) → Prop) (x : ∃ y ∈ s, ↑(↑(f n) / ↑n) ≤ y),
(∀ (x : ℝ) (xS : x ∈ s) (hx : ↑(↑(f n) / ↑n) ≤ x), motive ⋯) → motive x | false |
MvQPF.Comp | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} → (TypeVec.{u} n → Type u_1) → (Fin2 n → TypeVec.{u} m → Type u) → TypeVec.{u} m → Type u_1 | true |
AddMonoidHom.toMultiplicative | Mathlib.Algebra.Group.TypeTags.Hom | {α : Type u_3} →
{β : Type u_4} →
[inst : AddZeroClass α] → [inst_1 : AddZeroClass β] → (α →+ β) ≃ (Multiplicative α →* Multiplicative β) | true |
CategoryTheory.MonoidalCategory.DayConvolution.unit_naturality | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(F G : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolution F G] {x x' y y... | true |
CategoryTheory.BasedFunctor.mk | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{𝒳 : CategoryTheory.BasedCategory 𝒮} →
{𝒴 : CategoryTheory.BasedCategory 𝒮} →
(toFunctor : CategoryTheory.Functor 𝒳.obj 𝒴.obj) →
autoParam (toFunctor.comp 𝒴.p = 𝒳.p) CategoryTheory.BasedFunctor.w._autoParam →
... | true |
ExpChar.congr | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] {p : ℕ} (q : ℕ) [hq : ExpChar R q], q = p → ExpChar R p | true |
Std.HashMap.getElem_filterMap'._proof_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : LawfulBEq α]
{f : α → β → Option γ} {k : α} {h : k ∈ Std.HashMap.filterMap f m}, (f k m[k]).isSome = true | false |
CategoryTheory.Enriched.Functor.functorHom_whiskerLeft_natTransEquiv_symm_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(K L : CategoryTheory.Functor C D) (X : C) (f : L ⟶ L)
(x :
CategoryTheory.MonoidalCategoryStruct.tensorObj ((K.functorHom L).obj X)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (Type ... | true |
String.utf8Len_le_of_infix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+: cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ | true |
FiniteAddGrp.of.eq_1 | Mathlib.Algebra.Category.Grp.FiniteGrp | ∀ (G : Type u) [inst : AddGroup G] [inst_1 : Finite G],
FiniteAddGrp.of G = { toAddGrp := AddGrpCat.of G, isFinite := inst_1 } | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.mem_part_ofSetSetoid_iff_rel._simp_1_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) {a b : α},
(a ∈ P.part b) = ∃ p ∈ P.parts, a ∈ p ∧ b ∈ p | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.negThm?._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Option (Option Lean.Expr) | false |
MonoidHom.inr_apply | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : MulOneClass M] [inst_1 : MulOneClass N] (y : N), (MonoidHom.inr M N) y = (1, y) | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs : Lean.Meta.Grind.Arith.Linear.LinExpr}
{c_1 : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c lhs =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c_1 lhs_1... | true |
Std.DTreeMap.Internal.Impl.Equiv.minEntry_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → ∀ (h : t₁.Equiv t₂) {he : t₁.isEmpty = false}, t₁.minEntry he = t₂.minEntry ⋯ | true |
constFormalMultilinearSeries.match_1 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((x : ℕ) → motive x) → motive x | false |
Lean.Doc.Block.rec_5 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1... | false |
_private.Lean.Server.InfoUtils.0.Lean.Elab.Info.type?._sparseCasesOn_1 | Lean.Server.InfoUtils | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo i)) →
((i : Lean.Elab.FieldInfo) → motive (Lean.Elab.Info.ofFieldInfo i)) →
((i : Lean.Elab.DelabTermInfo) → motive (Lean.Elab.Info.ofDelabTermInfo i)) →
(Nat.hasNotBit... | false |
Std.DTreeMap.getKey!_eq_get!_getKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {a : α}, t.getKey! a = (t.getKey? a).get! | true |
NormedGroup.toENormedMonoid._proof_4 | Mathlib.Analysis.Normed.Group.Continuity | ∀ {F : Type u_1} [inst : NormedGroup F] (x y : F), ‖x * y‖ₑ ≤ ‖x‖ₑ + ‖y‖ₑ | false |
IsLocalization.IsInteger.eq_1 | Mathlib.RingTheory.Localization.Rat | ∀ (R : Type u_1) [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (a : S),
IsLocalization.IsInteger R a = (a ∈ (algebraMap R S).rangeS) | true |
CategoryTheory.Limits.equalizerSubobject_arrow | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizerSubobjectIso f g).hom
(CategoryTheory.Limits.equalizer.ι f g) =
(CategoryTheory.Limits.equalizerSubobject f... | true |
MeasureTheory.AECover.integral_tendsto_of_countably_generated | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [l.IsCountablyGenerated] {φ : ι → Set α},
MeasureTheory.AECover μ l φ →
∀ {f : α → E},
MeasureTheory.Integrable f μ → Filter.Ten... | true |
ScottContinuous.comp | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
{f : α → β} {g : β → γ}, ScottContinuous f → ScottContinuous g → ScottContinuous (g ∘ f) | true |
FiniteField.exists_nonsquare | Mathlib.FieldTheory.Finite.Basic | ∀ {F : Type u_3} [inst : Field F] [Finite F], ringChar F ≠ 2 → ∃ a, ¬IsSquare a | true |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.toString.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} (motive : (x : Substring.Raw) → Substring.Raw.ValidFor l m r x → Prop) (x : Substring.Raw)
(x_1 : Substring.Raw.ValidFor l m r x),
(∀ (a : Unit),
motive
{ str := String.ofList (l ++ m ++ r), startPos := { byteIdx := String.utf8Len l },
stopPos := { byteIdx := String.utf... | false |
Lean.Meta.ArgsPacker.noConfusionType | Lean.Meta.ArgsPacker.Basic | Sort u → Lean.Meta.ArgsPacker → Lean.Meta.ArgsPacker → Sort u | false |
Interval.recBotCoe | Mathlib.Order.Interval.Basic | {α : Type u_1} →
[inst : LE α] → {C : Interval α → Sort u_6} → C ⊥ → ((a : NonemptyInterval α) → C ↑a) → (n : Interval α) → C n | true |
Fin.univ_def | Mathlib.Data.Fintype.Basic | ∀ (n : ℕ), Finset.univ = { val := ↑(List.finRange n), nodup := ⋯ } | true |
EuclideanGeometry.Sphere.isIntTangent_self_iff | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [Nontrivial V] {s : EuclideanGeometry.Sphere P}, s.IsIntTangent s ↔ 0 ≤ s.radius | true |
Lean.Meta.reduceBoolNativeUnsafe | Lean.Meta.WHNF | Lean.Name → Lean.MetaM Bool | true |
Lean.Elab.Command.Scope.levelNames._default | Lean.Elab.Command.Scope | List Lean.Name | false |
Polynomial.div_tendsto_atBot_zero_iff_degree_lt | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P Q : Polynomial 𝕜)
[OrderTopology 𝕜],
Q ≠ 0 →
(Filter.Tendsto (fun x => Polynomial.eval x P / Polynomial.eval x Q) Filter.atBot (nhds 0) ↔ P.degree < Q.degree) | true |
CategoryTheory.Deterministic | Mathlib.CategoryTheory.CopyDiscardCategory.Deterministic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → [CategoryTheory.CopyDiscardCategory C] → {X Y : C} → (X ⟶ Y) → Prop | true |
_private.Batteries.Data.RBMap.Depth.0.Batteries.RBNode.Balanced.le_size.match_1_7 | Batteries.Data.RBMap.Depth | ∀ {α : Type u_1},
let funType_1 := fun {t} {c} {n} x => 2 ^ Batteries.RBNode.depthLB c n ≤ t.size + 1;
∀
(motive :
(n : ℕ) →
(c : Batteries.RBColor) →
(t : Batteries.RBNode α) → (x : t.Balanced c n) → Batteries.RBNode.Balanced.below x → Prop)
(n : ℕ) (c : Batteries.RBColor) (t : Batt... | false |
OrderIso.map_ciSup_set_of_directedOn | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : ConditionallyCompletePartialOrderSup α]
[inst_1 : ConditionallyCompletePartialOrderSup β] (e : α ≃o β) {s : Set γ} {f : γ → α},
DirectedOn (fun x1 x2 => x1 ≤ x2) (f '' s) → BddAbove (f '' s) → s.Nonempty → e (⨆ i, f ↑i) = ⨆ i, e (f ↑i) | true |
Subgroup.exists_pow_mem_of_index_ne_zero | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.index ≠ 0 → ∀ (a : G), ∃ n, 0 < n ∧ n ≤ H.index ∧ a ^ n ∈ H | true |
CategoryTheory.ShortComplex.SnakeInput.mono_v₀₁_τ₂ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Mono S.v₀₁.τ₂ | true |
Nat.fact_prime_two | Mathlib.Data.Nat.Prime.Defs | Fact (Nat.Prime 2) | true |
DirichletCharacter.isPrimitive_one_level_one | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R], DirichletCharacter.IsPrimitive 1 | true |
Std.ExtDTreeMap.le_minKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, (∀ (k' : α), t.minKey? = some k' → (cmp k k').isLE = true) ↔ ∀ k' ∈ t, (cmp k k').isLE = true | true |
lp.singleAddMonoidHom | Mathlib.Analysis.Normed.Lp.lpSpace | {α : Type u_3} →
{E : α → Type u_4} →
[inst : (i : α) → NormedAddCommGroup (E i)] → [DecidableEq α] → (p : ENNReal) → (i : α) → E i →+ ↥(lp E p) | true |
UpperSet.coe_zero | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α], ↑0 = Set.Ici 0 | true |
isSelfAdjoint_iff_isStarNormal_and_quasispectrumRestricts | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | ∀ {A : Type u_1} [inst : TopologicalSpace A] [inst_1 : NonUnitalRing A] [inst_2 : StarRing A] [inst_3 : Module ℂ A]
[inst_4 : IsScalarTower ℂ A A] [inst_5 : SMulCommClass ℂ A A] [NonUnitalContinuousFunctionalCalculus ℂ A IsStarNormal]
{a : A}, IsSelfAdjoint a ↔ IsStarNormal a ∧ QuasispectrumRestricts a ⇑Complex.reC... | true |
ProbabilityTheory.lintegral_condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) [MeasureTheory.IsFiniteMeasure ρ] (x : ℝ),
∫⁻ (a : α), ENNReal.ofReal (↑(ProbabilityTheory.condCDF ρ a) x) ∂ρ.fst = ρ (Set.univ ×ˢ Set.Iic x) | true |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_9 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι},
b ≤ c → ∀ val ∈ Finset.Ioc a b, b ∈ Finset.Ioc a c | false |
Filter.boundedFilterSubalgebra._proof_2 | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ (𝕜 : Type u_3) {α : Type u_1} {β : Type u_2} [inst : SeminormedCommRing 𝕜] [inst_1 : SeminormedRing β]
[inst_2 : Algebra 𝕜 β] [inst_3 : IsBoundedSMul 𝕜 β] (l : Filter α) (f g : α → β),
f ∈ Filter.boundedFilterSubmodule 𝕜 l →
g ∈ Filter.boundedFilterSubmodule 𝕜 l → f * g ∈ Filter.boundedFilterSubmodule �... | false |
_private.Init.Data.SInt.Lemmas.0.ISize.ofNat_mul._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, ISize.ofNat n = ISize.ofInt ↑n | false |
TrivSqZeroExt.snd_mul | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} {M : Type v} [inst : Mul R] [inst_1 : Add M] [inst_2 : SMul R M] [inst_3 : SMul Rᵐᵒᵖ M]
(x₁ x₂ : TrivSqZeroExt R M), (x₁ * x₂).snd = x₁.fst • x₂.snd + MulOpposite.op x₂.fst • x₁.snd | true |
AddSubgroup.nontrivial_iff_exists_ne_zero | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), Nontrivial ↥H ↔ ∃ x ∈ H, x ≠ 0 | true |
ByteArray.Iterator.casesOn | Init.Data.ByteArray.Basic | {motive : ByteArray.Iterator → Sort u} →
(t : ByteArray.Iterator) → ((array : ByteArray) → (idx : ℕ) → motive { array := array, idx := idx }) → motive t | false |
BitVec.hash._unary.eq_def | Init.Data.BitVec.Basic | ∀ (_x : (n : ℕ) ×' BitVec n),
BitVec.hash._unary _x =
PSigma.casesOn _x fun n bv =>
if n ≤ 64 then (↑bv.toFin).toUInt64
else mixHash (↑bv.toFin).toUInt64 (BitVec.hash._unary ⟨n - 64, BitVec.setWidth (n - 64) (bv >>> 64)⟩) | false |
Std.DTreeMap.Internal.Unit.RoiSliceData.mk | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] → (Std.DTreeMap.Internal.Impl α fun x => Unit) → Std.Roi α → Std.DTreeMap.Internal.Unit.RoiSliceData α | true |
Complex.norm_ofNat | Mathlib.Analysis.Complex.Norm | ∀ (n : ℕ) [inst : n.AtLeastTwo], ‖OfNat.ofNat n‖ = OfNat.ofNat n | true |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.ExProd.evalInv.match_13 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
(_a₂ : Q(ℕ)) →
(_b₁ _b₃ : Q(«$α»)) →
(motive :
Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExProd sα) q(«$_b₃» * («$_b₁» ^ «$_a₂» * Nat.rawCast 1)) →
Sort u_1) →
(__discr :
... | false |
Lean.Lsp.instFromJsonSignatureHelpTriggerKind | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SignatureHelpTriggerKind | true |
iterate_map_sub | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} {F : Type u_11} [inst : AddGroup M] [inst_1 : FunLike F M M] [AddMonoidHomClass F M M] (f : F) (n : ℕ)
(x y : M), (⇑f)^[n] (x - y) = (⇑f)^[n] x - (⇑f)^[n] y | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_495 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
List.idxOfNth w [g (g a)] {g a, g (g a)}.card + 1 ≤ (List.filter (fun x => decide (x = w)) []).length →
List.idxOfNth w [g (g a)] {g a, g (g a)}.card < (List.filter (fun x => decide (x = w)) []).length | false |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.nonzero_span_atom._simp_1_1 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M)
(p : Submodule R M), (R ∙ m ≤ p) = (m ∈ p) | false |
Sigma.Lex.linearOrder._proof_4 | Mathlib.Data.Sigma.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)] (a b : (i : ι) × α i),
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) a b ∨
Sigma.Lex (fun x1 x2 => x1 < x2) (fun x x1 x2 => x1 ≤ x2) b a | false |
ContDiffMapSupportedIn.instSMul | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {E : Type u_2} →
{F : Type u_3} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{R : Type u_5} →
[inst_4 ... | true |
Lean.Expr.foldRelevantConstants | Lean.LibrarySuggestions.Basic | {α : Type} → Lean.Expr → α → (Lean.Name → α → Lean.MetaM α) → Lean.MetaM α | true |
NormedField.instRankOneNNRealValuation._proof_4 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {K : Type u_1} [inst : NontriviallyNormedField K] [inst_1 : IsUltrametricDist K],
StrictMono ⇑MonoidWithZeroHom.ValueGroup₀.embedding | false |
Subalgebra.involutiveStar._proof_11 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] (S : Subalgebra R A),
{
carrier :=
star
{ carrier := star S.carrier, mul_mem' := ⋯, one_mem' := ⋯, add_mem' := ⋯, zero_me... | false |
StieltjesFunction.instModuleNNReal._proof_5 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (x : NNReal), x • 0 = 0 | false |
BoundedOrder.noConfusionType | Mathlib.Order.BoundedOrder.Basic | Sort u_1 → {α : Type u} → [inst : LE α] → BoundedOrder α → {α' : Type u} → [inst' : LE α'] → BoundedOrder α' → Sort u_1 | false |
_private.Mathlib.Data.Set.Finite.Lattice.0.Set.Finite.bddAbove_biUnion._simp_1_1 | Mathlib.Data.Set.Finite.Lattice | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], BddAbove ∅ = True | false |
CategoryTheory.Functor.instEffectiveEpiEffectiveEpiOver | Mathlib.CategoryTheory.EffectiveEpi.Enough | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) [inst_2 : F.EffectivelyEnough]
(X : D), CategoryTheory.EffectiveEpi (F.effectiveEpiOver X) | true |
derivWithin_fun_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (fun x => c) s = 0 | true |
CoeOut.mk | Init.Coe | {α : Sort u} → {β : semiOutParam (Sort v)} → (α → β) → CoeOut α β | true |
CategoryTheory.Functor.IsCoverDense.sheafYonedaHom | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{K : CategoryTheory.GrothendieckTopology D} →
{A : Type u_4} →
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] →
{G : CategoryTheory... | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.IsCompact.nhds_hausdorff_eq_nhds_vietoris._simp_1_2 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | false |
Stream'.Seq1.bind_assoc | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.Seq1 α) (f : α → Stream'.Seq1 β) (g : β → Stream'.Seq1 γ),
(s.bind f).bind g = s.bind fun x => (f x).bind g | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.II.0.SimplexCategory.II.last_mem_finset._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.II | ∀ {n m : ℕ} (f : Fin (n + 1) →o Fin (m + 1)) (x : Fin (m + 2)) (i : Fin (n + 2)),
(i ∈ SimplexCategory.II.finset f x) =
(i = Fin.last (n + 1) ∨ ∃ (h : i ≠ Fin.last (n + 1)), x ≤ (f (i.castPred h)).castSucc) | false |
Std.Time.Month.instInhabitedOrdinal | Std.Time.Date.Unit.Month | Inhabited Std.Time.Month.Ordinal | true |
Nat.le_three_of_sqrt_eq_one | Mathlib.Data.Nat.Sqrt | ∀ {n : ℕ}, n.sqrt = 1 → n ≤ 3 | true |
Derivation.couple._proof_10 | Mathlib.RingTheory.Derivation.Lie | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A | false |
_private.Mathlib.Order.ModularLattice.0.Set.Iic.isCompl_inf_inf_of_isCompl_of_le._simp_1_1 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | false |
Lean.Elab.Term.TacticMVarKind.term.sizeOf_spec | Lean.Elab.Term.TermElabM | sizeOf Lean.Elab.Term.TacticMVarKind.term = 1 | true |
Lean.PrettyPrinter.Delaborator.delabHOrElse._regBuiltin.Lean.PrettyPrinter.Delaborator.delabHOrElse_1 | Lean.PrettyPrinter.Delaborator.Builtins | IO Unit | false |
Lean.Parser.Term.app._regBuiltin.Lean.Parser.Term.ellipsis.formatter_11 | Lean.Parser.Term | IO Unit | false |
_private.Mathlib.Analysis.Normed.Field.Dense.0.IsAlgClosed.of_denseRange._simp_1_3 | Mathlib.Analysis.Normed.Field.Dense | ∀ {α : Type u_1} {s : Finset α}, (¬s.Nonempty) = (s = ∅) | false |
CategoryTheory.Functor.WellOrderInductionData.Extension.limit._proof_3 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_2} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_1)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} [inst_3 : WellFoundedLT J] (j : J)
(hj : Order.IsSuccLimit j) (e : (i : J) → i < j → d.Extension val₀ i),
F.map (CategoryTh... | false |
Partition.mk._flat_ctor | Mathlib.Order.Partition.Basic | {α : Type u_1} →
[inst : CompleteLattice α] → {s : α} → (parts : Set α) → sSupIndep parts → ⊥ ∉ parts → sSup parts = s → Partition s | false |
instCStarAlgebraSubtypeMemStarSubalgebraComplexElemental._proof_5 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : CStarAlgebra A], ContinuousStar A | false |
MvPolynomial.degrees_neg | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {R : Type u} {σ : Type u_1} [inst : CommRing R] (p : MvPolynomial σ R), (-p).degrees = p.degrees | true |
Mathlib.Tactic.BicategoryLike.MkMor₂.casesOn | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{motive : Mathlib.Tactic.BicategoryLike.MkMor₂ m → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.MkMor₂ m) →
((ofExpr : Lean.Expr → m Mathlib.Tactic.BicategoryLike.Mor₂) → motive { ofExpr := ofExpr }) → motive t | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_5 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) | false |
CategoryTheory.RightRigidCategory.noConfusionType | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.RightRigidCategory C →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
[inst'_1 : CategoryTheory.MonoidalCategory C'] ... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.