name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting_0_CategoryTheory_Limits_termX₁_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.Macro | false |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.folder.match_6.congr_eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (motive : Option (Std.HashMap (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) Bool) → Sort u_1)
(acc : Option (Std.HashMap (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) Bool)) (h_1 : Unit → motive none)
(h_2 : (map : Std.HashMap (Std.Tactic.BVDecide.LRAT.Internal.PosFin n) Bool) → motive (some map)),
acc = none →
(match acc with
| none => h_1 ()
| some map => h_2 map) ≍
h_1 () | true |
instNegNonemptyInterval.eq_1 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedAddMonoid α],
instNegNonemptyInterval = { neg := fun s => { fst := -s.toProd.2, snd := -s.toProd.1, fst_le_snd := ⋯ } } | true |
PadicInt.withValIntegersRingEquiv._proof_7 | Mathlib.NumberTheory.Padics.WithVal | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (x : (Rat.padicValuation p).Completion),
Valued.v x ≤ 1 ↔ ‖Padic.withValUniformEquiv x‖ ≤ 1 | false |
Multiset.prod_lt_prod' | Mathlib.Algebra.Order.BigOperators.Group.Multiset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α] [IsOrderedCancelMonoid α]
[MulLeftStrictMono α] {s : Multiset ι} {f g : ι → α},
(∀ i ∈ s, f i ≤ g i) → (∃ i ∈ s, f i < g i) → (Multiset.map f s).prod < (Multiset.map g s).prod | true |
Units.val_neg._simp_1 | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] (u : αˣ), -↑u = ↑(-u) | false |
ultrafilterBasis | Mathlib.Topology.Compactification.StoneCech | (α : Type u) → Set (Set (Ultrafilter α)) | true |
Lean.JsonRpc.Message.ctorElimType | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.Message → Sort u} → ℕ → Sort (max 1 u) | false |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.rayleighQuotient_le_of_mem_resolventSet | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(T : E →L[𝕜] E) (t : ℝ),
0 < t →
(algebraMap ℝ 𝕜) t ∈ resolventSet 𝕜 T → ∃ c > 0, ∀ (x : E), T.rayleighQuotient x ≤ (t ^ 2 + ‖T‖ ^ 2) / (2 * t) - c | true |
HasCountableSeparatingOn.range_Iio | Mathlib.Topology.Order.CountableSeparating | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : LinearOrder X] [OrderTopology X] [SecondCountableTopology X]
{s : Set X}, HasCountableSeparatingOn X (fun x => x ∈ Set.range Set.Iio) s | true |
Finset.fold_hom | Mathlib.Data.Finset.Fold | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op]
{f : α → β} {b : β} {s : Finset α} {op' : γ → γ → γ} [inst : Std.Commutative op'] [inst_1 : Std.Associative op']
{m : β → γ},
(∀ (x y : β), m (op x y) = op' (m x) (m y)) → Finset.fold op' (m b) (fun x => m (f x)) s = m (Finset.fold op b f s) | true |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.mk_mem_graph_iff._simp_1_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b | false |
_private.Mathlib.Algebra.Homology.HomotopyCategory.Triangulated.0.CochainComplex.MappingConeCompHomotopyEquiv.hom._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ (p : ℤ), p + 2 + -1 = p + 1 | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_133 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (w_1 n : ℕ)
(expr : Std.Tactic.BVDecide.BVExpr w_1) (h : w = w_1 * n),
¬llhs.shiftLeft lrhs = Std.Tactic.BVDecide.BVExpr.replicate n expr h | false |
MeasureTheory.isMulRightInvariant_map_mul_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : Semigroup G] [MeasurableMul G] {μ : MeasureTheory.Measure G}
[μ.IsMulRightInvariant] (g : G), (MeasureTheory.Measure.map (fun x => g * x) μ).IsMulRightInvariant | true |
FirstOrder.Language.Term.lt | Mathlib.ModelTheory.Order | {L : FirstOrder.Language} →
{α : Type w} → {n : ℕ} → [L.IsOrdered] → L.Term (α ⊕ Fin n) → L.Term (α ⊕ Fin n) → L.BoundedFormula α n | true |
Lean.NameMap.insert | Lean.Data.NameMap.Basic | {α : Type} → Lean.NameMap α → Lean.Name → α → Std.TreeMap Lean.Name α Lean.Name.quickCmp | true |
Polynomial.degree_smul_of_smul_regular | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {S : Type u_1} [inst_1 : SMulZeroClass S R] {k : S} (p : Polynomial R),
IsSMulRegular R k → (k • p).degree = p.degree | true |
Bornology.relativelyCompact | Mathlib.Topology.Separation.Basic | (X : Type u_1) → [inst : TopologicalSpace X] → [R0Space X] → Bornology X | true |
MonCat.forget_reflects_isos | Mathlib.Algebra.Category.MonCat.Basic | (CategoryTheory.forget MonCat).ReflectsIsomorphisms | true |
Lean.Elab.Command.ElabHeaderResult.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{t t' : Lean.Elab.Command.ElabHeaderResult} → t = t' → Lean.Elab.Command.ElabHeaderResult.noConfusionType P t t' | false |
ValuationSubring.ofPrime_localization | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K) (P : Ideal ↥A) [inst_1 : P.IsPrime],
IsLocalization.AtPrime (↥(A.ofPrime P)) P | true |
MeasureTheory.HasFundamentalDomain.ExistsIsFundamentalDomain | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_6} {α : Type u_7} {inst : One G} {inst_1 : SMul G α} {inst_2 : MeasurableSpace α}
{ν : autoParam (MeasureTheory.Measure α) MeasureTheory.HasFundamentalDomain._auto_1}
[self : MeasureTheory.HasFundamentalDomain G α ν], ∃ s, MeasureTheory.IsFundamentalDomain G s ν | true |
SemilatSupCat.isOrderBot | Mathlib.Order.Category.Semilat | (self : SemilatSupCat) → OrderBot self.X | true |
Filter.Germ.instPow.eq_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_5} {G : Type u_6} [inst : Pow G M],
Filter.Germ.instPow = { pow := fun f n => Filter.Germ.map (fun x => x ^ n) f } | true |
IsIntegrallyClosed.of_isIntegrallyClosed_of_isIntegrallyClosedIn | Mathlib.RingTheory.IntegralClosure.IntegrallyClosed | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [IsDomain S]
[FaithfulSMul R S] [IsIntegrallyClosed S] [IsIntegrallyClosedIn R S], IsIntegrallyClosed R | true |
CategoryTheory.ShortComplex.mapHomologyIso'._proof_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (S : CategoryTheory.ShortComplex C)
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] [inst_5 : S.HasHomology]
[F.PreservesRightHomologyOf S], S.homologyData.right.IsPreservedBy F | false |
DFinsupp.update | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{β : ι → Type v} →
[inst : (i : ι) → Zero (β i)] → [DecidableEq ι] → (Π₀ (i : ι), β i) → (i : ι) → β i → Π₀ (i : ι), β i | true |
SeparationQuotient.instUniformSpace._proof_2 | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u_1} [inst : UniformSpace α] (y : SeparationQuotient α),
nhds y = Filter.comap (Prod.mk y) (Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (uniformity α)) | false |
CategoryTheory.Adjunction.Triple.leftToRight.congr_simp | Mathlib.CategoryTheory.Adjunction.Triple | ∀ {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} {G : CategoryTheory.Functor D C}
{H : CategoryTheory.Functor C D} (t t_1 : CategoryTheory.Adjunction.Triple F G H),
t = t_1 → ∀ [inst_2 : F.Full] [inst_3 : F.Faithful], t.leftToRight = t_1.leftToRight | true |
Std.DTreeMap.Raw.instDecidableEquiv | Std.Data.DTreeMap.Raw.DecidableEquiv | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] →
[Std.LawfulEqCmp cmp] →
[inst : (k : α) → BEq (β k)] →
[∀ (k : α), LawfulBEq (β k)] → {t₁ t₂ : Std.DTreeMap.Raw α β cmp} → t₁.WF → t₂.WF → Decidable (t₁.Equiv t₂) | true |
Filter.ZeroAtFilter.neg | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace β] [inst_1 : SubtractionMonoid β] [ContinuousNeg β]
{l : Filter α} {f : α → β}, l.ZeroAtFilter f → l.ZeroAtFilter (-f) | true |
WithZero.lift'._proof_4 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulZeroOneClass β],
Function.LeftInverse (fun F => (↑F).comp WithZero.coeMonoidHom) fun f =>
{ toFun := fun n => WithZero.recZeroCoe 0 (⇑f) n, map_zero' := ⋯, map_one' := ⋯, map_mul' := ⋯ } | false |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S.cons | Mathlib.Tactic.DeriveEncodable | Mathlib.Deriving.Encodable.S✝ → Mathlib.Deriving.Encodable.S✝ → Mathlib.Deriving.Encodable.S✝¹ | true |
Std.Internal.UV.System.UnameInfo.mk.injEq | Std.Internal.UV.System | ∀ (sysname release version machine sysname_1 release_1 version_1 machine_1 : String),
({ sysname := sysname, release := release, version := version, machine := machine } =
{ sysname := sysname_1, release := release_1, version := version_1, machine := machine_1 }) =
(sysname = sysname_1 ∧ release = release_1 ∧ version = version_1 ∧ machine = machine_1) | true |
Lean.Order.instCCPOIO._proof_1 | Init.Internal.Order.Basic | ∀ {α : Type} {x : EIO IO.Error α}, Lean.Order.instCCPOEIOOfNonempty._aux_1 x x | false |
ContinuousLinearMap.mul._proof_1 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_2) [inst : NontriviallyNormedField 𝕜] (R : Type u_1) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R] [inst_3 : IsScalarTower 𝕜 R R] [inst_4 : SMulCommClass 𝕜 R R] (x y : R),
‖((LinearMap.mul 𝕜 R) x) y‖ ≤ 1 * ‖x‖ * ‖y‖ | false |
ZLattice.covolume.tendsto_card_le_div' | Mathlib.Algebra.Module.ZLattice.Covolume | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (L : Submodule ℤ E) [inst_5 : DiscreteTopology ↥L]
[IsZLattice ℝ L] [Nontrivial E] {X : Set E} {F : E → ℝ},
(∀ ⦃x : E⦄ ⦃r : ℝ⦄, x ∈ X → 0 < r → r • x ∈ X) →
(∀ (x : E) ⦃r : ℝ⦄, 0 ≤ r → F (r • x) = r ^ Module.finrank ℝ E * F x) →
Bornology.IsBounded {x | x ∈ X ∧ F x ≤ 1} →
MeasurableSet {x | x ∈ X ∧ F x ≤ 1} →
MeasureTheory.volume (frontier {x | x ∈ X ∧ F x ≤ 1}) = 0 →
Filter.Tendsto (fun c => ↑(Nat.card ↑({x | x ∈ X ∧ F x ≤ c} ∩ ↑L)) / c) Filter.atTop
(nhds (MeasureTheory.volume.real {x | x ∈ X ∧ F x ≤ 1} / ZLattice.covolume L MeasureTheory.volume)) | true |
Std.Broadcast.instHashableError | Std.Sync.Broadcast | Hashable Std.Broadcast.Error | true |
GeneralizingMap.stableUnderGeneralization_range | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
GeneralizingMap f → StableUnderGeneralization (Set.range f) | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_477 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[{g (g a)}.card] + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[{g (g a)}.card] <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_19 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(0 + size ≤ 1 ∨ 0 ≤ 3 * size ∧ size ≤ 3 * 0) ∧ ls = 0 + 1 + size →
(3 * (0 + 1 + (l.size + 1 + r.size)) ≤ 3 * 3 * 0 + 3 * 0 + 0 + 3 ∧ 0 + 1 ≤ 0 + 1 + (l.size + 1 + r.size) ∨
(0 + 1 + (l.size + 1 + r.size) + (0 + 1) ≤ 1 ∨
0 + 1 + (l.size + 1 + r.size) ≤ 3 * (0 + 1) ∧ 0 + 1 ≤ 3 * (0 + 1 + (l.size + 1 + r.size))) ∨
0 + 1 + (l.size + 1 + r.size) + 0 ≤ 1 ∨
0 + 1 + (l.size + 1 + r.size) ≤ 3 * 0 ∧ 0 ≤ 3 * (0 + 1 + (l.size + 1 + r.size))) ∨
3 * 0 ≤
3 * 3 * (0 + 1 + (l.size + 1 + r.size)) + 3 * (0 + 1 + (l.size + 1 + r.size)) +
(0 + 1 + (l.size + 1 + r.size)) +
3 ∧
0 + 1 + (l.size + 1 + r.size) + 1 ≤ 0 ∨
(0 + (0 + 1 + (l.size + 1 + r.size) + 1) ≤ 1 ∨
0 ≤ 3 * (0 + 1 + (l.size + 1 + r.size) + 1) ∧ 0 + 1 + (l.size + 1 + r.size) + 1 ≤ 3 * 0) ∨
0 + (0 + 1 + (l.size + 1 + r.size)) ≤ 1 ∨
0 ≤ 3 * (0 + 1 + (l.size + 1 + r.size)) ∧ 0 + 1 + (l.size + 1 + r.size) ≤ 3 * 0 →
¬(l.size = 0 ∧ r.size = 0) → False | false |
Std.Internal.UV.TCP.Socket.new | Std.Internal.UV.TCP | IO Std.Internal.UV.TCP.Socket | true |
Lean.Expr.fvar.sizeOf_spec | Lean.Expr | ∀ (fvarId : Lean.FVarId), sizeOf (Lean.Expr.fvar fvarId) = 1 + sizeOf fvarId | true |
Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.rec | Lean.Elab.GuardMsgs | {motive : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode → Sort u} →
motive Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.exact →
motive Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.normalized →
motive Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.lax → (t : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode) → motive t | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.noMVars.elim | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝¹) →
Lean.Meta.PreprocessKind.ctorIdx✝ t = 0 → motive Lean.Meta.PreprocessKind.noMVars✝ → motive t | false |
MeasureTheory.OuterMeasure.map._proof_2 | Mathlib.MeasureTheory.OuterMeasure.Operations | IsScalarTower ENNReal ENNReal ENNReal | false |
IsArtinianRing.localization_surjective | Mathlib.RingTheory.Artinian.Ring | ∀ {R : Type u_1} [inst : CommRing R] [IsArtinianRing R] (S : Submonoid R) (L : Type u_2) [inst_2 : CommSemiring L]
[inst_3 : Algebra R L] [IsLocalization S L], Function.Surjective ⇑(algebraMap R L) | true |
RootPairing.posRootForm_posForm_anisotropic | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
(S : Type u_5) [inst_6 : CommRing S] [inst_7 : LinearOrder S] [inst_8 : IsStrictOrderedRing S] [IsDomain R]
[inst_10 : Algebra S R] [inst_11 : FaithfulSMul S R] [inst_12 : P.IsValuedIn S] [inst_13 : Module S M]
[inst_14 : IsScalarTower S R M] [inst_15 : Module S N] [IsScalarTower S R N],
(LinearMap.BilinMap.toQuadraticMap (P.posRootForm S).posForm).Anisotropic | true |
Lean.MessageLog.reportedPlusUnreported | Lean.Message | Lean.MessageLog → Lean.PersistentArray Lean.Message | true |
Filter.ZeroAtFilter.boundedAtFilter | Mathlib.Order.Filter.ZeroAndBoundedAtFilter | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddGroup β] {l : Filter α} {f : α → β},
l.ZeroAtFilter f → l.BoundedAtFilter f | true |
Multiset.coe_fold_r | Mathlib.Data.Multiset.Fold | ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α) (l : List α),
Multiset.fold op b ↑l = List.foldr op b l | true |
Std.Internal.IO.Process.instOrdPId.ord | Std.Internal.Async.Process | Std.Internal.IO.Process.PId → Std.Internal.IO.Process.PId → Ordering | true |
Char.utf8Size_eq | Init.Data.String.Decode | ∀ (c : Char), c.utf8Size = 1 ∨ c.utf8Size = 2 ∨ c.utf8Size = 3 ∨ c.utf8Size = 4 | true |
Std.Time.Hour.instDecidableEqOffset | Std.Time.Time.Unit.Hour | DecidableEq Std.Time.Hour.Offset | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkHCongrWithArity'.process.match_1 | Mathlib.Lean.Meta.CongrTheorems | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((fvar val : Lean.Expr) → motive (fvar, val)) → motive x | false |
cfcHomSuperset_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Ring A] [inst_6 : StarRing A]
[inst_7 : TopologicalSpace A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R A p] {a : A} (ha : p a)
{s : Set R} (hs : spectrum R a ⊆ s), (cfcHomSuperset ha hs) (ContinuousMap.restrict s (ContinuousMap.id R)) = a | true |
PiTensorProduct.toDualContinuousMultilinearMap._proof_5 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (F : Type u_2) [inst_1 : SeminormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.toInt_eq_ofNat_toNat_rotate_sub._proof_1_8 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x : BitVec (n + 1)), ↑x.toNat < 2 ^ n → ¬↑x.toNat + 2 ^ n < 2 ^ (n + 1) → False | false |
antitoneOn_of_succ_le | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_3} {β : Type u_4} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : SuccOrder α]
[IsSuccArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMax a → a ∈ s → Order.succ a ∈ s → f (Order.succ a) ≤ f a) → AntitoneOn f s | true |
Mathlib.Tactic.Linarith.runLinarith | Mathlib.Tactic.Linarith.Frontend | Mathlib.Tactic.Linarith.LinarithConfig → Option Lean.Expr → Lean.MVarId → List Lean.Expr → Lean.MetaM (List ℕ) | true |
SeminormedRing.toRingSeminorm._proof_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ (R : Type u_1) [inst : SeminormedRing R], ‖0‖ = 0 | false |
Module.freeLocus_eq_univ_iff | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ {R : Type uR} {M : Type uM} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[Module.FinitePresentation R M], Module.freeLocus R M = Set.univ ↔ Module.Projective R M | true |
Subsemigroup.toAddSubsemigroup._proof_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Mul M],
Function.LeftInverse (fun S => { carrier := ⇑Additive.ofMul ⁻¹' ↑S, mul_mem' := ⋯ }) fun S =>
{ carrier := ⇑Additive.toMul ⁻¹' ↑S, add_mem' := ⋯ } | false |
Lean.Elab.Command.Structure.StructFieldDefault.noConfusionType | Lean.Elab.Structure | Sort u → Lean.Elab.Command.Structure.StructFieldDefault → Lean.Elab.Command.Structure.StructFieldDefault → Sort u | false |
Std.TreeMap.Raw.maxKey?_erase_eq_iff_not_compare_eq_maxKey? | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.erase k).maxKey? = t.maxKey? ↔ ∀ {km : α}, t.maxKey? = some km → ¬cmp k km = Ordering.eq | true |
Mathlib.Meta.FunProp.LambdaTheoremType._sizeOf_inst | Mathlib.Tactic.FunProp.Theorems | SizeOf Mathlib.Meta.FunProp.LambdaTheoremType | false |
CategoryTheory.tensorHom_eComp_op_eq_assoc | Mathlib.CategoryTheory.Enriched.Opposite | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V]
[inst_2 : CategoryTheory.BraidedCategory V] {C : Type u} [inst_3 : CategoryTheory.EnrichedCategory V C] {x y z : Cᵒᵖ}
{v w : V} (f : v ⟶ z ⟶[V] y) (g : w ⟶ y ⟶[V] x) {Z : V} (h : (z ⟶[V] x) ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eComp V z y x) h) =
CategoryTheory.CategoryStruct.comp (β_ v w).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom g f)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.eComp V (Opposite.unop x) (Opposite.unop y) (Opposite.unop z)) h)) | true |
CategoryTheory.Pretriangulated.comp_distTriang_mor_zero₂₃_assoc | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles,
∀ {Z : C} (h : (CategoryTheory.shiftFunctor C 1).obj T.obj₁ ⟶ Z),
CategoryTheory.CategoryStruct.comp T.mor₂ (CategoryTheory.CategoryStruct.comp T.mor₃ h) =
CategoryTheory.CategoryStruct.comp 0 h | true |
ExteriorAlgebra.ι_eq_algebraMap_iff | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : M) (r : R),
(ExteriorAlgebra.ι R) x = (algebraMap R (ExteriorAlgebra R M)) r ↔ x = 0 ∧ r = 0 | true |
MonCat.coe_comp | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : MonCat} {f : X ⟶ Y} {g : Y ⟶ Z},
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) =
⇑(CategoryTheory.ConcreteCategory.hom g) ∘ ⇑(CategoryTheory.ConcreteCategory.hom f) | true |
exteriorPower.presentation.relationsSolutionEquiv_symm_apply_var | Mathlib.LinearAlgebra.ExteriorPower.Basic | ∀ {R : Type u} [inst : CommRing R] {N : Type u_2} [inst_1 : AddCommGroup N] [inst_2 : Module R N] {ι : Type u_4}
[inst_3 : DecidableEq ι] {M : Type u_5} [inst_4 : AddCommGroup M] [inst_5 : Module R M] (f : M [⋀^ι]→ₗ[R] N)
(m : (exteriorPower.presentation.relations R ι M).G),
(exteriorPower.presentation.relationsSolutionEquiv.symm f).var m = f m | true |
UpperHalfPlane.casesOn | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | {motive : UpperHalfPlane → Sort u} →
(t : UpperHalfPlane) →
((coe : ℂ) → (coe_im_pos : 0 < coe.im) → motive { coe := coe, coe_im_pos := coe_im_pos }) → motive t | false |
Aesop.UnsafeRuleInfo.mk | Aesop.Rule | Aesop.Percent → Aesop.UnsafeRuleInfo | true |
exp_neg_integrableOn_Ioi | Mathlib.MeasureTheory.Integral.ExpDecay | ∀ (a : ℝ) {b : ℝ}, 0 < b → MeasureTheory.IntegrableOn (fun x => Real.exp (-b * x)) (Set.Ioi a) MeasureTheory.volume | true |
Batteries.Tactic.Lint.instInhabitedLintVerbosity | Batteries.Tactic.Lint.Frontend | Inhabited Batteries.Tactic.Lint.LintVerbosity | true |
Std.TreeSet.Raw.minD_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback : α}, t.minD fallback ∈ t | true |
CategoryTheory.SimplicialThickening.instCategoryStruct._proof_4 | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ (J : Type u_1) [inst : LinearOrder J] {i j k : CategoryTheory.SimplicialThickening J}
(f : CategoryTheory.SimplicialThickening.Path i.as j.as) (g : CategoryTheory.SimplicialThickening.Path j.as k.as),
∀ l ∈ f.I ∪ g.I, i.as ≤ l | false |
_private.Mathlib.Analysis.Calculus.DifferentialForm.Basic.0.extDeriv_apply._simp_1_1 | Mathlib.Analysis.Calculus.DifferentialForm.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(ω : E → E [⋀^Fin n]→L[𝕜] F), extDeriv ω = extDerivWithin ω Set.univ | false |
alternatingGroup.stabilizer.surjective_toPerm | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {s : Set α},
sᶜ.Nontrivial → Function.Surjective MulAction.toPerm | true |
LinearEquiv.extendScalarsOfIsLocalizationEquiv._proof_3 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_4} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_3) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_1} {N : Type u_2} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[inst_9 : Module R N] [inst_10 : Module A N] [inst_11 : IsScalarTower R A N] (e : M ≃ₗ[A] N),
(fun e => LinearEquiv.extendScalarsOfIsLocalization S A e) ((fun e => LinearEquiv.restrictScalars R e) e) = e | false |
Lean.Doc.output._regBuiltin.Lean.Doc.output.getArgs.declRange_7 | Lean.Elab.DocString.Builtin | IO Unit | false |
_private.Mathlib.Analysis.SpecialFunctions.Stirling.0.Stirling.factorial_isEquivalent_stirling._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Stirling | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
FixedDetMatrices.repsFintype._proof_2 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ (k : ℤ) ⦃M N : ↑(FixedDetMatrices.reps k)⦄, ((fun i j => ⟨↑↑M i j, ⋯⟩) = fun i j => ⟨↑↑N i j, ⋯⟩) → M = N | false |
AlgebraicGeometry.HasRingHomProperty.inf | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P P' : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q Q' : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P fun {R S} [CommRing R] [CommRing S] => Q]
[AlgebraicGeometry.HasRingHomProperty P' fun {R S} [CommRing R] [CommRing S] => Q'],
AlgebraicGeometry.HasRingHomProperty (P ⊓ P') fun {R S} [CommRing R] [CommRing S] f => Q f ∧ Q' f | true |
ProbabilityTheory.Kernel.IndepFun.comp₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {β : Type u_4} {β' : Type u_5} {γ : Type u_6} {γ' : Type u_7} {mα : MeasurableSpace α}
{mΩ : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {f : Ω → β} {g : Ω → β'}
{mβ : MeasurableSpace β} {mβ' : MeasurableSpace β'} {mγ : MeasurableSpace γ} {mγ' : MeasurableSpace γ'} {φ : β → γ}
{ψ : β' → γ'},
ProbabilityTheory.Kernel.IndepFun f g κ μ →
AEMeasurable f (μ.bind ⇑κ) →
AEMeasurable g (μ.bind ⇑κ) →
AEMeasurable φ (MeasureTheory.Measure.map f (μ.bind ⇑κ)) →
AEMeasurable ψ (MeasureTheory.Measure.map g (μ.bind ⇑κ)) →
ProbabilityTheory.Kernel.IndepFun (φ ∘ f) (ψ ∘ g) κ μ | true |
Std.DHashMap.Internal.AssocList.AssocListIterator.recOn | Std.Data.DHashMap.Internal.AssocList.Iterator | {α : Type u} →
{β : α → Type v} →
{motive : Std.DHashMap.Internal.AssocList.AssocListIterator α β → Sort u_1} →
(t : Std.DHashMap.Internal.AssocList.AssocListIterator α β) →
((l : Std.DHashMap.Internal.AssocList α β) → motive { l := l }) → motive t | false |
Lean.Omega.Fin.ofNat_val_sub | Init.Omega.Int | ∀ {n : ℕ} {x y : Fin n}, ↑↑(x - y) = (↑(n - ↑y) + ↑↑x) % ↑n | true |
MeasureTheory.integral_of_isEmpty | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [IsEmpty α] {f : α → G}, ∫ (x : α), f x ∂μ = 0 | true |
Sym.coe_replicate | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} {a : α}, ↑(Sym.replicate n a) = Multiset.replicate n a | true |
TopCat.Presheaf.stalkFunctor_map_germ_assoc | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
{F G : TopCat.Presheaf C X} (U : TopologicalSpace.Opens ↑X) (x : ↑X) (hx : x ∈ U) (f : F ⟶ G) {Z : C}
(h : (TopCat.Presheaf.stalkFunctor C x).obj G ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.germ U x hx)
(CategoryTheory.CategoryStruct.comp ((TopCat.Presheaf.stalkFunctor C x).map f) h) =
CategoryTheory.CategoryStruct.comp (f.app (Opposite.op U)) (CategoryTheory.CategoryStruct.comp (G.germ U x hx) h) | true |
List.Sublist.append_left | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → ∀ (l : List α), (l ++ l₁).Sublist (l ++ l₂) | true |
_private.Mathlib.RingTheory.PowerBasis.0.PowerBasis.aeval_minpolyGen._simp_1_3 | Mathlib.RingTheory.PowerBasis | ∀ (α : Sort u), (∀ (a : α), True) = True | false |
NormedRing.npow._inherited_default | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} → (mul : α → α → α) → (∀ (a b c : α), a * b * c = a * (b * c)) → α → ℕ → α → α | false |
norm_add_sq_eq_norm_sq_add_norm_sq_of_inner_eq_zero | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x y : E), inner 𝕜 x y = 0 → ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ | true |
_private.Init.Data.Array.QSort.Basic.0.Array.qpartition.loop._unary._proof_16 | Init.Data.Array.QSort.Basic | ∀ {n : ℕ} (lo hi i k : ℕ), autoParam (lo ≤ i) Array.qpartition._auto_2✝ → lo ≤ i + 1 | false |
Holor.instAddCommSemigroup | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddCommSemigroup α] → AddCommSemigroup (Holor α ds) | true |
SmoothBumpFunction.isOpen_support | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M}
(f : SmoothBumpFunction I c) [inst_5 : FiniteDimensional ℝ E], IsOpen (Function.support ↑f) | true |
TensorProduct.tensorQuotMapSMulEquivTensorQuot._proof_13 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), IsScalarTower R R (R ⧸ I) | false |
OrderedFinpartition.compAlongOrderedFinpartition._proof_2 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_1}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
(f : ContinuousMultilinearMap 𝕜 (fun i => F) G) (p : (i : Fin c.length) → ContinuousMultilinearMap 𝕜 (fun i => E) F)
(v : Fin n → E) (i : Fin n) (c_1 : 𝕜) (x : E),
(fun v => f (c.applyOrderedFinpartition p v)) (Function.update v i (c_1 • x)) =
c_1 • (fun v => f (c.applyOrderedFinpartition p v)) (Function.update v i x) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.