name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Meta.Hint.0.Lean.Meta.Hint.mkSuggestionsMessage._sparseCasesOn_5 | Lean.Meta.Hint | {motive : Lean.Meta.Hint.DiffGranularity → Sort u} →
(t : Lean.Meta.Hint.DiffGranularity) →
motive Lean.Meta.Hint.DiffGranularity.none → (Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Lean.PrettyPrinter.Formatter.State.mk.injEq | Lean.PrettyPrinter.Formatter | ∀ (stxTrav : Lean.Syntax.Traverser) (leadWord : String) (leadWordIdent isUngrouped mustBeGrouped : Bool)
(stack : Array Std.Format) (stxTrav_1 : Lean.Syntax.Traverser) (leadWord_1 : String)
(leadWordIdent_1 isUngrouped_1 mustBeGrouped_1 : Bool) (stack_1 : Array Std.Format),
({ stxTrav := stxTrav, leadWord := lead... | true |
UInt16.size_dvd_usizeSize | Init.Data.UInt.Lemmas | UInt16.size ∣ USize.size | true |
instIsLocalizedModuleToLinearMapToAlgHomOfIsLocalizationAlgebraMapSubmonoid | Mathlib.Algebra.Module.LocalizedModule.IsLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {A : Type u_2} {Aₛ : Type u_3} [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : CommSemiring Aₛ] [inst_4 : Algebra A Aₛ] [inst_5 : Algebra R Aₛ]
[inst_6 : IsScalarTower R A Aₛ] [IsLocalization (Algebra.algebraMapSubmonoid A S) Aₛ],
IsLocalizedMo... | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_15 | Init.Data.BitVec.Bitblast | ∀ {p : Prop} [Decidable p], (¬¬p) = p | false |
Std.HashSet.Raw.containsThenInsert_fst | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} {m : Std.HashSet.Raw α} [inst : BEq α] [inst_1 : Hashable α],
m.WF → ∀ {k : α}, (m.containsThenInsert k).1 = m.contains k | true |
spectrum.zero_notMem | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {a : A},
IsUnit a → 0 ∉ spectrum R a | true |
Std.ExtTreeMap.getKey?_minKey! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α], t ≠ ∅ → t.getKey? t.minKey! = some t.minKey! | true |
AffineEquiv.mk | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | {k : Type u_1} →
{P₁ : Type u_2} →
{P₂ : Type u_3} →
{V₁ : Type u_4} →
{V₂ : Type u_5} →
[inst : Ring k] →
[inst_1 : AddCommGroup V₁] →
[inst_2 : AddCommGroup V₂] →
[inst_3 : Module k V₁] →
[inst_4 : Module k V₂] →
... | true |
_private.Mathlib.Data.List.Cycle.0.List.next_getLast_eq_head_of_notMem_dropLast._proof_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α}, l ≠ [] → 0 < l.length | false |
Btw.btw.antisymm | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularPartialOrder α] {a b c : α}, btw a b c → btw c b a → a = b ∨ b = c ∨ c = a | true |
isEllDivSequence_id | Mathlib.NumberTheory.EllipticDivisibilitySequence | IsEllDivSequence id | true |
Concept.intent_swap | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} (c : Concept α β r), c.swap.intent = c.extent | true |
MeasureTheory.Ioo_ae_eq_Ioc' | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : PartialOrder α] {a b : α},
μ {b} = 0 → Set.Ioo a b =ᵐ[μ] Set.Ioc a b | true |
SkewMonoidAlgebra.toFinsupp_eq_zero._simp_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {a : SkewMonoidAlgebra k G}, (a.toFinsupp = 0) = (a = 0) | false |
ArithmeticFunction.vonMangoldt.residueClass_apply | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {q : ℕ} {a : ZMod q} [NeZero q],
IsUnit a →
∀ (n : ℕ),
↑(ArithmeticFunction.vonMangoldt.residueClass a n) =
(↑q.totient)⁻¹ * ∑ χ, χ a⁻¹ * χ ↑n * ↑(ArithmeticFunction.vonMangoldt n) | true |
TopologicalSpace.CompactOpens.coe_inf | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : QuasiSeparatedSpace α] (s t : TopologicalSpace.CompactOpens α),
↑(s ⊓ t) = ↑s ∩ ↑t | true |
AlgEquiv.aut_inv | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(ϕ : A₁ ≃ₐ[R] A₁), ϕ⁻¹ = ϕ.symm | true |
MeasureTheory.L2.instInnerSubtypeAEEqFunMemAddSubgroupLpOfNatENNReal._proof_1 | Mathlib.MeasureTheory.Function.L2Space | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
_private.Mathlib.NumberTheory.NumberField.Completion.FinitePlace.0.NumberField.FinitePlace.add_le._proof_1_5 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (v : NumberField.FinitePlace K)
(w : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)),
NumberField.place (NumberField.FinitePlace.embedding w) = ↑v →
∀ (x : K), ↑v x = (NumberField.HeightOneSpectrum.adicAbv K w) x | false |
FinBddDistLat.forget_map | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} (f : X ⟶ Y),
(CategoryTheory.forget FinBddDistLat).map f = ⇑(CategoryTheory.ConcreteCategory.hom f) | true |
Pi.zero_apply | Mathlib.Algebra.Notation.Pi.Defs | ∀ {ι : Type u_1} {M : ι → Type u_5} [inst : (i : ι) → Zero (M i)] (i : ι), 0 i = 0 | true |
List.toList_iter | Init.Data.Iterators.Lemmas.Producers.List | ∀ {β : Type w} {l : List β}, l.iter.toList = l | true |
_private.Mathlib.RingTheory.MvPowerSeries.Evaluation.0.MvPolynomial.toMvPowerSeries_uniformContinuous._simp_1_2 | Mathlib.RingTheory.MvPowerSeries.Evaluation | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iic b) = (x ≤ b) | false |
Std.Tactic.BVDecide.BVLogicalExpr.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVExpr.Assignment → Std.Tactic.BVDecide.BVLogicalExpr → Bool | true |
FinTopCat.instTopologicalSpaceObjFiniteObjFintypeCatForget₂ContinuousMapCarrierToTopHom._aux_1 | Mathlib.Topology.Category.FinTopCat | (X : FinTopCat) → TopologicalSpace ((CategoryTheory.forget₂ FinTopCat FintypeCat).obj X).obj | false |
Lean.Meta.RefinedDiscrTree.instToFormatLazyEntry | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Std.ToFormat Lean.Meta.RefinedDiscrTree.LazyEntry | true |
CategoryTheory.regularOfIsPullbackSndOfRegular._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S}
{k : R ⟶ S} (hr : CategoryTheory.RegularMono h)
(comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k)
(s :
CategoryTheory.Limits.Fork (CategoryTheory.CategoryStru... | false |
Set.mem_Icc | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, x ∈ Set.Icc a b ↔ a ≤ x ∧ x ≤ b | true |
HahnSeries.single_eq_zero | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] {a : Γ}, (HahnSeries.single a) 0 = 0 | true |
Sym2.mk_prod_swap_eq | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {a b : α}, s(a, b) = s(b, a) | true |
LieRinehartAlgebra.mk | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_1} {A : Type u_2} {L : Type u_3} [inst : CommRing A] [inst_1 : LieRing L] [inst_2 : Module A L]
[inst_3 : LieRingModule L A] [inst_4 : LieRinehartRing A L] [inst_5 : CommRing R] [inst_6 : Algebra R A]
[inst_7 : LieAlgebra R L] [toIsScalarTower : IsScalarTower R A L] [toLieModule : LieModule R L A],
... | true |
Std.Do.PostCond.entails.trans | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} {α : Type u} {P Q R : Std.Do.PostCond α ps}, P.entails Q → Q.entails R → P.entails R | true |
uniformity_eq_comap_mul_inv_nhds_one | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (Gᵣ : Type u_3) [inst : UniformSpace Gᵣ] [inst_1 : Group Gᵣ] [IsRightUniformGroup Gᵣ],
uniformity Gᵣ = Filter.comap (fun x => x.2 * x.1⁻¹) (nhds 1) | true |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.expandMatchAltsIntoMatchAux._unsafe_rec | Lean.Elab.Binders | Lean.Syntax → Bool → Bool → ℕ → Array Lean.Syntax → Array Lean.Ident → Lean.MacroM Lean.Syntax | false |
MeasureTheory.closedCompactCylinders.eq_1 | Mathlib.MeasureTheory.Constructions.ClosedCompactCylinders | ∀ {ι : Type u_1} (X : ι → Type u_2) [inst : (i : ι) → TopologicalSpace (X i)],
MeasureTheory.closedCompactCylinders X =
⋃ s, ⋃ S, ⋃ (_ : IsClosed S), ⋃ (_ : IsCompact S), {MeasureTheory.cylinder s S} | true |
Aesop.RulePatternIndex.getSingle | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM (Array (Aesop.RuleName × Aesop.Substitution)) | true |
UniformConvergenceCLM.coe_zero | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | true |
Ideal.mul_add_mem_pow_succ_unique | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] {P : Ideal S} [P_prime : P.IsPrime] [IsDedekindDomain S],
P ≠ ⊥ →
∀ {i : ℕ} (a d d' e e' : S),
a ∉ P ^ (i + 1) → e ∈ P ^ (i + 1) → e' ∈ P ^ (i + 1) → a * d + e - (a * d' + e') ∈ P ^ (i + 1) → d - d' ∈ P | true |
Std.ExtHashMap.size_alter_eq_add_one | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
k ∉ m → (f m[k]?).isSome = true → (m.alter k f).size = m.size + 1 | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.send | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded✝ α → α → BaseIO (Task (Except Std.CloseableChannel.Error Unit)) | true |
TopologicalSpace.IrreducibleCloseds.equivSubtype'._proof_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} [inst : TopologicalSpace α],
Function.LeftInverse (fun a => { carrier := ↑a, isIrreducible' := ⋯, isClosed' := ⋯ }) fun a => ⟨a.carrier, ⋯⟩ | false |
YoungDiagram.equivListRowLens._proof_3 | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (x : { w // w.SortedGE ∧ ∀ x ∈ w, 0 < x }),
(YoungDiagram.ofRowLens ↑x ⋯).rowLens.SortedGE ∧ ∀ x_1 ∈ (YoungDiagram.ofRowLens ↑x ⋯).rowLens, 0 < x_1 | false |
LieAlgebra.ofTwoCocycle._sizeOf_inst | Mathlib.Algebra.Lie.Extension | {R : Type u_5} →
{L : Type u_6} →
{M : Type u_7} →
{inst : CommRing R} →
{inst_1 : LieRing L} →
{inst_2 : LieAlgebra R L} →
{inst_3 : AddCommGroup M} →
{inst_4 : Module R M} →
{inst_5 : LieRingModule L M} →
{inst_6 : LieModule R L... | false |
AffineMap.nonempty | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
[inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2], Nonempty (P1 →ᵃ[k] P2) | true |
_private.Mathlib.Algebra.Order.Archimedean.Submonoid.0.SubmonoidClass.instMulArchimedean._simp_1 | Mathlib.Algebra.Order.Archimedean.Submonoid | ∀ {α : Type u_2} [inst : LT α] {p : α → Prop} {x y : Subtype p}, (x < y) = (↑x < ↑y) | false |
Submodule.span_prod_le | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_8}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (s : Set M) (t : Set M'),
Submodule.span R (s ×ˢ t) ≤ (Submodule.span R s).prod (Submodule.span R t) | true |
EReal.zero_mul | Mathlib.Data.EReal.Basic | ∀ (x : EReal), 0 * x = 0 | true |
Subfield.instSMulWithZeroSubtypeMem | Mathlib.Algebra.Field.Subfield.Basic | {K : Type u} →
[inst : DivisionRing K] →
{X : Type u_1} → [inst_1 : Zero X] → [SMulWithZero K X] → (F : Subfield K) → SMulWithZero (↥F) X | true |
_private.Mathlib.RingTheory.Invariant.Basic.0.Algebra.IsInvariant.orbit_eq_primesOver.match_1_1 | Mathlib.RingTheory.Invariant.Basic | ∀ (B : Type u_1) (G : Type u_2) [inst : CommRing B] [inst_1 : Group G] [inst_2 : MulSemiringAction G B] (Q R : Ideal B)
(motive : R ∈ MulAction.orbit G Q → Prop) (x : R ∈ MulAction.orbit G Q),
(∀ (g : G) (hg : (fun m => m • Q) g = R), motive ⋯) → motive x | false |
HasFDerivAtFilter.finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i : Fin n) → F... | true |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.findSignatureHelp?.match_1 | Lean.Server.FileWorker.SignatureHelp | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((range : Lean.Syntax.Range) → motive (some range)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x | false |
SSet.spine_vertex | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ (X : SSet) (n : ℕ) (Δ : X.obj (Opposite.op (SimplexCategory.mk n))) (i : Fin (n + 1)),
(X.spine n Δ).vertex i = X.map ((SimplexCategory.mk 0).const (SimplexCategory.mk n) i).op Δ | true |
AlgebraicGeometry.Scheme.IdealSheafData.mkOfMemSupportIff | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | {X : AlgebraicGeometry.Scheme} →
(ideal : (U : ↑X.affineOpens) → Ideal ↑(X.presheaf.obj (Opposite.op ↑U))) →
(∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) (ideal U) =
ideal (X.affineBasicOpen f)) →... | true |
IsPrecomplete.rec | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
{I : Ideal R} →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsPrecomplete I M → Sort u} →
((prec' :
∀ (f : ℕ → M),
(∀ {m n : ℕ}, m ≤ n → f m ≡ f n [... | false |
MeasureTheory.setLIntegral_subtype | Mathlib.MeasureTheory.Integral.Lebesgue.Map | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s →
∀ (t : Set ↑s) (f : α → ENNReal),
∫⁻ (x : ↑s) in t, f ↑x ∂MeasureTheory.Measure.comap Subtype.val μ = ∫⁻ (x : α) in Subtype.val '' t, f x ∂μ | true |
HomologicalComplex.doubleXIso₁._proof_1 | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) {ι : Type u_3} {c : ComplexShape ι}
{i₀ i₁ : ι} (hi₀₁ : c.Rel i₀ i₁), i₀ ≠ i₁ → (HomologicalComplex.double f hi₀₁).X i₁ = X₁ | false |
MeasureTheory.IsAddFundamentalDomain.setLIntegral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ (f : α → ENNReal) (t : Set α), ∫⁻... | true |
pseudoEMetricSpacePi._proof_1 | Mathlib.Topology.EMetricSpace.Pi | ∀ {β : Type u_1} {X : β → Type u_2} [inst : Fintype β] [inst_1 : (b : β) → PseudoEMetricSpace (X b)]
(f : (b : β) → X b), ∀ b ∈ Finset.univ, edist (f b) (f b) ≤ ⊥ | false |
Lean.Widget.RpcEncodablePacket.mk.sizeOf_spec._@.Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | ∀ (type exprExplicit doc : Lean.Json),
sizeOf { type := type, exprExplicit := exprExplicit, doc := doc } = 1 + sizeOf type + sizeOf exprExplicit + sizeOf doc | false |
conj_zpow | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : Group α] {i : ℤ} {a b : α}, (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ | true |
Nat.cast_le_pow_sub_div_sub | Mathlib.Algebra.Order.Field.Power | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a : α},
1 < a → ∀ (n : ℕ), ↑n ≤ (a ^ n - 1) / (a - 1) | true |
WType.Listα.cons.noConfusion | Mathlib.Data.W.Constructions | {γ : Type u} → {P : Sort u_1} → {a a' : γ} → WType.Listα.cons a = WType.Listα.cons a' → (a ≍ a' → P) → P | false |
SchwartzMap.norm_fourier_Lp_top_leq_toLp_one | Mathlib.Analysis.Distribution.SchwartzSpace.Fourier | ∀ {V : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : FiniteDimensional ℝ V]
[inst_3 : MeasurableSpace V] [inst_4 : BorelSpace V] {F : Type u_4} [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace ℂ F] (f : SchwartzMap V F),
‖(FourierTransform.fourier f).toLp ⊤ MeasureTheory.... | true |
SubMulAction.instSMulSubtypeMem.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] (p : SubMulAction R M),
p.instSMulSubtypeMem = { smul := fun c x => ⟨c • ↑x, ⋯⟩ } | true |
derivationToSquareZeroOfLift._proof_5 | Mathlib.RingTheory.Derivation.ToSquareZero | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B) [inst_5 : Algebra A B] [inst_6 : IsScalarTower R A B],
I ^ 2 = ⊥ →
∀ (f : A →ₐ[R] B) (e : (Ideal.Quotient.mkₐ R I).comp f = IsScalarT... | false |
AddUnits.neg_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (self : AddUnits α), self.neg + ↑self = 0 | true |
USize.shiftLeft_zero | Init.Data.UInt.Bitwise | ∀ {a : USize}, a <<< 0 = a | true |
CategoryTheory.Grp.mkIso._auto_3 | Mathlib.CategoryTheory.Monoidal.Grp_ | Lean.Syntax | false |
CategoryTheory.Functor.PullbackObjObj.mk.injEq | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₃ Y₃ : C₃}
{f₃ : X₃ ⟶ Y₃} (pt : C... | true |
IsOrderedMonoid.mk._flat_ctor | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α],
(∀ (a b : α), a ≤ b → ∀ (c : α), a * c ≤ b * c) → (∀ (a b : α), a ≤ b → ∀ (c : α), c * a ≤ c * b) → IsOrderedMonoid α | false |
Matrix.instLieRingToLieAlgebra._proof_29 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B]
(x y z : Matrix.ToLieAlgebra R CM), ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ | false |
MeasureTheory.SimpleFunc.coe_neg._simp_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Neg β] (f : MeasureTheory.SimpleFunc α β),
-⇑f = ⇑(-f) | false |
AddSubmonoid.map_equiv_eq_comap_symm | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {N : Type u_2} [inst : AddZeroClass N] {M : Type u_5} [inst_1 : AddZeroClass M] (f : M ≃+ N) (K : AddSubmonoid M),
AddSubmonoid.map f K = AddSubmonoid.comap f.symm K | true |
MeasureTheory.SignedMeasure.toMeasureOfZeroLE._proof_1 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} (s : MeasureTheory.SignedMeasure α) (i : Set α),
MeasurableSet i →
∀ (hi₂ : MeasureTheory.VectorMeasure.restrict 0 i ≤ MeasureTheory.VectorMeasure.restrict s i),
s.toMeasureOfZeroLE' i hi₂ ∅ ⋯ = 0 | false |
PartOrdEmb.hom_id | Mathlib.Order.Category.PartOrdEmb | ∀ {X : PartOrdEmb}, PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X) = RelEmbedding.refl fun x1 x2 => x1 ≤ x2 | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isAlreadyNorm? | Lean.Meta.Tactic.Grind.Intro | Lean.Expr → Option Lean.Expr | true |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.Topology.IsClosedEmbedding.weaklyLocallyCompactSpace.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace Y] {f : X → Y} (x : X)
(motive : (∃ s, IsCompact s ∧ s ∈ nhds (f x)) → Prop) (x_1 : ∃ s, IsCompact s ∧ s ∈ nhds (f x)),
(∀ (K : Set Y) (hK : IsCompact K) (hKx : K ∈ nhds (f x)), motive ⋯) → motive x_1 | false |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.matches'.match_1.eq_1 | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (motive : RegularExpression α → Sort u_2) (h_1 : Unit → motive RegularExpression.zero)
(h_2 : Unit → motive RegularExpression.epsilon) (h_3 : (a : α) → motive (RegularExpression.char a))
(h_4 : (P Q : RegularExpression α) → motive (P.plus Q)) (h_5 : (P Q : RegularExpression α) → motive (P.comp Q))
... | true |
_private.Lean.Util.Trace.0.Lean.printTraces.match_1 | Lean.Util.Trace | (motive : Lean.TraceElem → Sort u_1) →
(x : Lean.TraceElem) → ((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive { ref := ref, msg := msg }) → motive x | false |
Nat.modCore_lt | Init.Prelude | ∀ {x y : ℕ}, 0 < y → x.modCore y < y | true |
Fin2.insertPerm | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 n → Fin2 n → Fin2 n | true |
IntervalIntegrable.sub | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {f g : ℝ → E},
IntervalIntegrable f μ a b → IntervalIntegrable g μ a b → IntervalIntegrable (fun x => f x - g x) μ a b | true |
ProofWidgets.InteractiveExprProps._sizeOf_1 | ProofWidgets.Component.Basic | ProofWidgets.InteractiveExprProps → ℕ | false |
CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeFunctorFunctorCategoryOfHasPullbacks | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
[W.IsStableUnderBaseChange] (J : Type u'') [inst_2 : CategoryTheory.Category.{v'', u''} J]
[CategoryTheory.Limits.HasPullbacks C], (W.functorCategory J).IsStableUnderBaseChange | true |
Lean.Lsp.instToJsonMarkupKind | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.MarkupKind | true |
CategoryTheory.Sheaf.locallySurjective | Mathlib.CategoryTheory.Sites.EpiMono | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u') →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{FA : A → A → Type u_1} →
{CA : A → Type w} →
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA... | true |
CategoryTheory.Bicategory.LeftLift.whisker_unit | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(t : CategoryTheory.Bicategory.LeftLift f g) {x : B} (h : x ⟶ c),
(t.whisker h).unit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft h t.unit)
(CategoryTheory.Bicategory.associator h t.lift ... | true |
CategoryTheory.FreeBicategory.Rel.below.triangle | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B]
{motive :
{a b : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(a_1 a_2 : CategoryTheory.FreeBicategory.Hom₂ f g) → CategoryTheory.FreeBicategory.Rel a_1 a_2 → Prop}
{a b c : B} (f : CategoryTheory.FreeBicategory.Hom a b) (g : CategoryTheory.FreeBicategory.Hom... | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_176 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] 0 + 1 ≤ (List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] 0 < (List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
Rep.hom_whiskerRight | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Monoid G] {X₁ X₂ Y : Rep.{u, u, v} k G} (f : X₁ ⟶ X₂),
Rep.Hom.hom (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y) =
Representation.IntertwiningMap.rTensor Y.ρ (Rep.Hom.hom f) | true |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.Cutsat.UnsatProof} →
t = t' → Lean.Meta.Grind.Arith.Cutsat.UnsatProof.noConfusionType P t t' | false |
IsRightCancelMul.mulRightReflectLE_of_mulRightReflectLT | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (N : Type u_2) [inst : Mul N] [IsRightCancelMul N] [inst_2 : PartialOrder N] [MulRightReflectLT N],
MulRightReflectLE N | true |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valuation.isNontrivial_iff_not_a_field._simp_1_4 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono._proof_3 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [CategoryTheory.Epi φ.τ₁],
CategoryTheory.Mono (CategoryTheory.ShortComplex.opMap φ).τ₃ | false |
PFunctor.M.Agree'.below.casesOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : ℕ) → (a_1 a_2 : F.M) → PFunctor.M.Agree' a a_1 a_2 → Prop}
{motive_1 : {a : ℕ} → {a_1 a_2 : F.M} → (t : PFunctor.M.Agree' a a_1 a_2) → PFunctor.M.Agree'.below t → Prop} {a : ℕ}
{a_1 a_2 : F.M} {t : PFunctor.M.Agree' a a_1 a_2} (t_1 : PFunctor.M.Agree'.below t),
(∀ (x y : F... | false |
AffineSubspace.parallel_bot_iff_eq_bot._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P}, s.Parallel ⊥ = (s = ⊥) | false |
CategoryTheory.PreGaloisCategory.functorToAction_comp_forget₂_eq | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (F : CategoryTheory.Functor C FintypeCat),
(CategoryTheory.PreGaloisCategory.functorToAction F).comp
(CategoryTheory.forget₂ (Action FintypeCat (CategoryTheory.Aut F)) FintypeCat) =
F | true |
GradedRing.mem_support_iff | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜]
[inst_6 : (i : ι) → (x : ↥(𝒜 i)) → Decidable (x ≠ 0)] (r : A) (i : ι),
i ∈ DFinsupp.support ((DirectSum.... | true |
Std.TransCmp.isLE_trans | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [self : Std.TransCmp cmp] {a b c : α},
(cmp a b).isLE = true → (cmp b c).isLE = true → (cmp a c).isLE = true | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.