name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
RootPairing.IsIrreducible.mk' | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommGroup M] [inst_1 : AddCommGroup N] {K : Type u_5}
[inst_2 : Field K] [inst_3 : Module K M] [inst_4 : Module K N] [Nontrivial M] (P : RootPairing ι K M N),
(∀ (q : Submodule K M), (∀ (i : ι), q ∈ Module.End.invtSubmodule ↑(P.reflection i)) → q ≠ ⊥ → q = ⊤... | When the coefficients are a field, the coroot conditions for irreducibility follow from those
for the roots. | true |
BooleanSubalgebra.subtype_comp_inclusion | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {L M : BooleanSubalgebra α} (h : L ≤ M),
M.subtype.comp (BooleanSubalgebra.inclusion h) = L.subtype | null | true |
FiniteIndexNormalAddSubgroup.rec | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | {G : Type u_1} →
[inst : AddGroup G] →
{motive : FiniteIndexNormalAddSubgroup G → Sort u} →
((toAddSubgroup : AddSubgroup G) →
(isNormal' : toAddSubgroup.Normal) →
(isFiniteIndex' : toAddSubgroup.FiniteIndex) →
motive { toAddSubgroup := toAddSubgroup, isNormal' := isNorma... | null | false |
_private.Mathlib.Topology.Order.0.TopologicalSpace.nhds_mkOfNhds_single._simp_1_2 | Mathlib.Topology.Order | ∀ {α : Type u_1} {a : α} {p : α → Prop}, (∀ᶠ (x : α) in pure a, p x) = p a | null | false |
continuousAt_gauge_zero | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} [inst_2 : TopologicalSpace E]
[ContinuousSMul ℝ E], s ∈ nhds 0 → ContinuousAt (gauge s) 0 | If `s` is a neighborhood of the origin, then `gauge s` is continuous at the origin.
See also `continuousAt_gauge`. | true |
CategoryTheory.SimplicialObject.IsCoskeletal.isRightKanExtension | Mathlib.AlgebraicTopology.SimplicialObject.Coskeletal | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X : CategoryTheory.SimplicialObject C} {n : ℕ}
[self : X.IsCoskeletal n],
CategoryTheory.Functor.IsRightKanExtension X
(CategoryTheory.CategoryStruct.id ((SimplexCategory.Truncated.inclusion n).op.comp X)) | null | true |
Lean.Meta.SimpAll.M | Lean.Meta.Tactic.Simp.SimpAll | Type → Type | null | true |
Differentiable.fun_add_iff_right | 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 g : E → F},
Differentiable 𝕜 f → ((Differentiable 𝕜 fun i => f i + g i) ↔ Differentiable 𝕜 g) | Eta-expanded form of `Differentiable.add_iff_right` | true |
MeasureTheory.llr.eq_1 | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) (x : α),
MeasureTheory.llr μ ν x = Real.log (μ.rnDeriv ν x).toReal | null | true |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_ultrafilter._simp_1_2 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
SemistandardYoungTableau.col_strict' | Mathlib.Combinatorics.Young.SemistandardTableau | ∀ {μ : YoungDiagram} (self : SemistandardYoungTableau μ) {i1 i2 j : ℕ},
i1 < i2 → (i2, j) ∈ μ → self.entry i1 j < self.entry i2 j | The entries in each column are strictly increasing (top to bottom). | true |
FirstOrder.Language.instUniqueStructureEmpty | Mathlib.ModelTheory.Basic | {M : Type w} → Unique (FirstOrder.Language.empty.Structure M) | null | true |
CategoryTheory.SmallObject.SuccStruct.mk | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
C → (succ : C → C) → ((X : C) → X ⟶ succ X) → CategoryTheory.SmallObject.SuccStruct C | null | true |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.sum_insertNth_go._f | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : AddCommMonoid M] (x : ℕ)
(f :
Nat.below (motive := fun x =>
∀ (x_1 : ℕ) (x_2 : x_1 < x + 1) (x_3 : M) (x_4 : Fin x → M),
∑ j, ⟨x_1, x_2⟩.insertNth x_3 x_4 j = x_3 + ∑ j, x_4 j)
x)
(x_1 : ℕ) (x_2 : x_1 < x + 1) (x_3 : M) (x_4 : Fin x → M), ∑ j, ⟨x_1, x_2⟩.insertNth x_... | null | false |
ContinuousMonoidHom.comp | Mathlib.Topology.Algebra.ContinuousMonoidHom | {A : Type u_2} →
{B : Type u_3} →
{C : Type u_4} →
[inst : Monoid A] →
[inst_1 : Monoid B] →
[inst_2 : Monoid C] →
[inst_3 : TopologicalSpace A] →
[inst_4 : TopologicalSpace B] → [inst_5 : TopologicalSpace C] → (B →ₜ* C) → (A →ₜ* B) → A →ₜ* C | Composition of two continuous homomorphisms. | true |
Lean.JsonRpc.Message.noConfusion | Lean.Data.JsonRpc | {P : Sort u} → {t t' : Lean.JsonRpc.Message} → t = t' → Lean.JsonRpc.Message.noConfusionType P t t' | null | false |
MvPolynomial.restrictSupportIdeal.congr_simp | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {σ : Type u} (R : Type v) [inst : CommSemiring R] (s s_1 : Set (σ →₀ ℕ)) (e_s : s = s_1) (hs : IsUpperSet s),
MvPolynomial.restrictSupportIdeal R s hs = MvPolynomial.restrictSupportIdeal R s_1 ⋯ | null | true |
UniformSpace.Completion.mapRingEquiv_symm_apply | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [inst_2 : IsTopologicalRing α] [inst_3 : IsUniformAddGroup α]
{β : Type u} [inst_4 : UniformSpace β] [inst_5 : Ring β] [inst_6 : IsUniformAddGroup β] [inst_7 : IsTopologicalRing β]
(f : α ≃+* β) (hf : Continuous ⇑f) (hf' : Continuous ⇑f.symm) (a : UniformSp... | null | true |
Lean.Grind.Bool.or_eq_of_eq_true_left | Init.Grind.Lemmas | ∀ {a b : Bool}, a = true → (a || b) = true | null | true |
HilbertBasis.hasSum_repr_symm | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] (b : HilbertBasis ι 𝕜 E) (f : ↥(lp (fun x => 𝕜) 2)),
HasSum (fun i => ↑f i • b i) (b.repr.symm f) | null | true |
AdjoinRoot.instCommRing._proof_3 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R) (a b c : AdjoinRoot f), a + b + c = a + (b + c) | null | false |
Std.Format.MonadPrettyFormat.mk | Init.Data.Format.Basic | {m : Type → Type} →
(String → m Unit) → (ℕ → m Unit) → m ℕ → (ℕ → m Unit) → (ℕ → m Unit) → Std.Format.MonadPrettyFormat m | null | true |
Lean.ErrorExplanation.rec | Lean.ErrorExplanation | {motive : Lean.ErrorExplanation → Sort u} →
((doc : String) →
(metadata : Lean.ErrorExplanation.Metadata) →
(declLoc? : Option Lean.DeclarationLocation) →
motive { doc := doc, metadata := metadata, declLoc? := declLoc? }) →
(t : Lean.ErrorExplanation) → motive t | null | false |
Real.HolderTriple.pos' | Mathlib.Basic.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → 0 < r | For `r`, instead of `p` | true |
Algebra.PreSubmersivePresentation.differential._proof_2 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u_1} {S : Type u_4} {ι : Type u_2} {σ : Type u_3} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ), SMulCommClass P.Ring P.Ring (σ → P.Ring) | null | false |
AddUnits.mk_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (u : AddUnits α) (y : α) (h₁ : ↑u + y = 0) (h₂ : y + ↑u = 0),
{ val := ↑u, neg := y, val_neg := h₁, neg_val := h₂ } = u | null | true |
MeasureTheory.Lp.const._proof_7 | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : NormedAddCommGroup E] [inst_1 : MeasureTheory.IsFiniteMeasure μ] (x x_1 : E),
⟨MeasureTheory.AEEqFun.const α (x + x_1), ⋯⟩ = ⟨MeasureTheory.AEEqFun.const α (x + x_1), ⋯⟩ | null | false |
Lean.Lsp.CompletionList.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.CompletionList → Sort u} →
(t : Lean.Lsp.CompletionList) →
((isIncomplete : Bool) →
(items : Array Lean.Lsp.CompletionItem) → motive { isIncomplete := isIncomplete, items := items }) →
motive t | null | false |
round.eq_1 | Mathlib.Algebra.Order.Round | ∀ {α : Type u_2} [inst : Ring α] [inst_1 : LinearOrder α] [inst_2 : FloorRing α] (x : α),
round x = if 2 * Int.fract x < 1 then ⌊x⌋ else ⌈x⌉ | null | true |
_private.Init.Data.SInt.Lemmas.0.Int16.toISize_ne_minValue._proof_1_2 | Init.Data.SInt.Lemmas | ∀ (a : Int16), -2 ^ 15 ≤ a.toInt → ISize.minValue.toInt ≤ -2 ^ 31 → a.toInt = ISize.minValue.toInt → False | null | false |
Nat.ToInt.of_eq | Init.Data.Int.OfNat | ∀ {a b : ℕ} {a' b' : ℤ}, ↑a = a' → ↑b = b' → a = b → a' = b' | null | true |
IsValuativeTopology.hasBasis_nhds_zero' | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ (R : Type u_1) [inst : Ring R] [inst_1 : ValuativeRel R] [inst_2 : TopologicalSpace R] [IsValuativeTopology R],
(nhds 0).HasBasis (fun x => x ≠ 0) fun x => {x_1 | (ValuativeRel.valuation R) x_1 < x} | A variant of `hasBasis_nhds_zero` where `· ≠ 0` is unbundled. | true |
MeasureTheory.«_aux_Mathlib_MeasureTheory_OuterMeasure_AE___macroRules_MeasureTheory_term∀ᵐ_∂_,__1» | Mathlib.MeasureTheory.OuterMeasure.AE | Lean.Macro | null | false |
pinGroup.instStarMulSubtypeCliffordAlgebraMemSubmonoid._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(pinGroup Q)), star (star x) = x | null | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.OrderRel.ne | Mathlib.Tactic.Positivity.Core | Mathlib.Meta.Positivity.OrderRel✝ | null | true |
Std.TreeMap.Raw.getElem_insertMany_list.match_1 | Std.Data.TreeMap.Raw.Lemmas | {β : Type u_1} →
(motive : Option β → Sort u_2) →
(x : Option β) → ((v : β) → x = some v → motive (some v)) → (x = none → motive none) → motive x | null | false |
WithLp.ofLp_multisetSum | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) (V : Type u_4) [inst : AddCommGroup V] (s : Multiset (WithLp p V)),
s.sum.ofLp = (Multiset.map WithLp.ofLp s).sum | null | true |
AlgebraicGeometry.Scheme.kerFunctor._proof_4 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ (Y : AlgebraicGeometry.Scheme) {X Y_1 Z : (CategoryTheory.Over Y)ᵒᵖ} (x : X ⟶ Y_1) (x : Y_1 ⟶ Z),
AlgebraicGeometry.Scheme.Hom.ker (Opposite.unop X).hom ≤ AlgebraicGeometry.Scheme.Hom.ker (Opposite.unop Z).hom | null | false |
CategoryTheory.bifunctorComp₂₃FunctorObj_obj | Mathlib.CategoryTheory.Functor.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₂₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
EuclideanDomain.toNontrivial | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u} [self : EuclideanDomain R], Nontrivial R | null | true |
BoxIntegral.TaggedPrepartition.noConfusionType | Mathlib.Analysis.BoxIntegral.Partition.Tagged | Sort u →
{ι : Type u_1} →
{I : BoxIntegral.Box ι} →
BoxIntegral.TaggedPrepartition I →
{ι' : Type u_1} → {I' : BoxIntegral.Box ι'} → BoxIntegral.TaggedPrepartition I' → Sort u | null | false |
ContinuousMap.instCompactSpaceElemCoeCompacts | Mathlib.Topology.ContinuousMap.Compact | ∀ {X : Type u_4} [inst : TopologicalSpace X] (K : TopologicalSpace.Compacts X), CompactSpace ↑↑K | null | true |
FloatArray.instEmptyCollection | Init.Data.FloatArray.Basic | EmptyCollection FloatArray | null | true |
ProbabilityTheory.defaultRatCDF | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ℚ → ℝ | A function with the property `IsMeasurableRatCDF`.
Used in a piecewise construction to convert a function which only satisfies the properties
defining `IsMeasurableRatCDF` on some set into a true `IsMeasurableRatCDF`. | true |
Real.rpowIntegrand₀₁_eqOn_pow_div | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p x : ℝ},
p ∈ Set.Ioo 0 1 →
0 ≤ x → Set.EqOn (fun x_1 => p.rpowIntegrand₀₁ x_1 x) (fun t => t ^ (p - 1) * x / (t + x)) (Set.Ioi 0) | null | true |
_private.Mathlib.Algebra.Module.LocalizedModule.Basic.0.IsLocalizedModule.instLiftOfLE._simp_3 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] {R₀ : Type u_6} [inst_6 : SMul R₀ R] [inst_7 : SMul R₀ M] [inst_8 : SMul R₀ ... | null | false |
List.attach_filterMap | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : α → Option β},
(List.filterMap f l).attach =
List.filterMap
(fun x =>
match x with
| ⟨x, h⟩ => (f x).pbind fun b m => some ⟨b, ⋯⟩)
l.attach | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite.0.SimpleGraph.completeEquipartiteGraph_succ_isContained_iff._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
UniformContinuousConstVAdd.uniformContinuous_const_vadd | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} {inst : UniformSpace X} {inst_1 : VAdd M X} [self : UniformContinuousConstVAdd M X] (c : M),
UniformContinuous fun x => c +ᵥ x | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.unsafe.parenthesizer_233 | Lean.Parser.Command | IO Unit | null | false |
WithTop.mul_eq_top_iff | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {a b : WithTop α},
a * b = ⊤ ↔ a ≠ 0 ∧ b = ⊤ ∨ a = ⊤ ∧ b ≠ 0 | null | true |
CategoryTheory.Presieve.singleton.rec | Mathlib.CategoryTheory.Sites.Sieves.Presieve | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} →
{f : Y ⟶ X} →
{motive : ⦃Y_1 : C⦄ → (a : Y_1 ⟶ X) → CategoryTheory.Presieve.singleton f a → Sort u} →
motive f ⋯ → ⦃Y_1 : C⦄ → {a : Y_1 ⟶ X} → (t : CategoryTheory.Presieve.singleton f a) → motive a t | null | false |
Submonoid.LocalizationMap.map | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{P : Type u_3} →
[inst_2 : CommMonoid P] →
S.LocalizationMap N →
{g : M →* P} →
{T : Submonoid P} →
(∀ (y ... | Given a `CommMonoid` homomorphism `g : M →* P` where for Submonoids `S ⊆ M, T ⊆ P` we have
`g(S) ⊆ T`, the induced Monoid homomorphism from the Localization of `M` at `S` to the
Localization of `P` at `T`: if `f : M →* N` and `k : P →* Q` are Localization maps for `S` and
`T` respectively, we send `z : N` to `k (g x) *... | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unsafe_rec | Std.Sat.AIG.CNF | (aig : Std.Sat.AIG ℕ) →
(upper : ℕ) →
(h : upper < aig.decls.size) →
(state : Std.Sat.AIG.toCNF.State✝ aig) → { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state out upper h } | null | false |
AlgebraicGeometry.IsAffineOpen.isoSpec_hom | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U), hU.isoSpec.hom = U.toSpecΓ | null | true |
CategoryTheory.Comma.mapLeftIso | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
(R : CategoryTheory.Functor B T) →
{L₁ L₂ : CategoryTheory.Functor A T} → ... | A natural isomorphism `L₁ ≅ L₂` induces an equivalence of categories
`Comma L₁ R ≌ Comma L₂ R`. | true |
_private.Mathlib.CategoryTheory.ConnectedComponents.0.CategoryTheory.instIsConnectedComponent._proof_10 | Mathlib.CategoryTheory.ConnectedComponents | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (j₁ j₂ : J)
(hj₁ : CategoryTheory.ConnectedComponents.objectProperty (Quotient.mk'' j₂) j₁) (l : List J)
(hf : ∀ a ∈ l, CategoryTheory.Zigzag a j₂),
¬(j₁ :: l).length - 1 = 0 →
({ obj := j₁, property := ⋯ } :: List.pmap (fun x h => { obj := x, pro... | null | false |
TopModuleCat.instIsRightAdjointTopCatForget₂ContinuousLinearMapIdCarrierContinuousMapCarrier | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u) [inst : Ring R] [inst_1 : TopologicalSpace R],
(CategoryTheory.forget₂ (TopModuleCat R) TopCat).IsRightAdjoint | null | true |
SheafOfModules.GeneratingSections.map | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
{C' : Type u₁} →
... | Let `F` be a functor from sheaf of `R`-module to sheaf of `S`-module, if `F` preserves
colimits and `F.obj (unit R) ≅ unit S`, given generating sections `G : M.GeneratingSections`,
then we obtain generating sections of `F.obj M`. | true |
Complex.UnitDisc | Mathlib.Analysis.Complex.UnitDisc.Basic | Type | The complex unit disc, denoted as `𝔻` within the Complex namespace | true |
CochainComplex.HomComplex.Cochain.rightShift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | IsRightCancelAdd ℤ | null | false |
_private.Mathlib.NumberTheory.EllipticDivisibilitySequence.0.IsEllipticNet.rel_eq._simp_1_5 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [LeftDistribClass R] (a b c : R), a * b + a * c = a * (b + c) | null | false |
Lean.Meta.Grind.TopSort.State.recOn | Lean.Meta.Tactic.Grind.EqResolution | {motive : Lean.Meta.Grind.TopSort.State → Sort u} →
(t : Lean.Meta.Grind.TopSort.State) →
((tempMark permMark : Std.HashSet Lean.Expr) →
(result : Array Lean.Expr) → motive { tempMark := tempMark, permMark := permMark, result := result }) →
motive t | null | false |
cfc_const._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Std.Packages.LinearPreorderOfLEArgs.rec | Init.Data.Order.PackageFactories | {α : Type u} →
{motive : Std.Packages.LinearPreorderOfLEArgs α → Sort u_1} →
((toPreorderOfLEArgs : Std.Packages.PreorderOfLEArgs α) →
(ord :
let this := toPreorderOfLEArgs.le;
let this := toPreorderOfLEArgs.decidableLE;
Ord α) →
(le_total : ∀ (a b : α), a ≤ b... | null | false |
ENNReal.mul_div_cancel_right | Mathlib.Basic.ENNReal.Inv | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → a * b / b = a | See `ENNReal.mul_div_cancel_right'` for a stronger version. | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.getEntryD.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a : α) (fallback : (a : α) × β a)
(x : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.getEntryD a fallback x =
match x with
| Std.DHashMap.Internal.AssocList.nil => fallback
| Std.DHashMap.Internal.AssocList.cons k v es =>
if (... | null | true |
Lean.Lsp.DidSaveTextDocumentParams.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.DidSaveTextDocumentParams → Sort u} →
((textDocument : Lean.Lsp.TextDocumentIdentifier) →
(text? : Option String) → motive { textDocument := textDocument, text? := text? }) →
(t : Lean.Lsp.DidSaveTextDocumentParams) → motive t | null | false |
Polynomial.coeff_comp_degree_mul_degree | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
q.natDegree ≠ 0 → (p.comp q).coeff (p.natDegree * q.natDegree) = p.leadingCoeff * q.leadingCoeff ^ p.natDegree | null | true |
WeierstrassCurve.valuation_Δ_aux.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] (W : WeierstrassCurve K),
WeierstrassCurve.valuation_Δ_aux R W =
if h : WeierstrassCurve.IsIntegral R W then
⟨(IsDedekindDo... | null | true |
NonUnitalCommCStarAlgebra.rec | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : NonUnitalCommCStarAlgebra A → Sort u} →
([toNonUnitalNormedCommRing : NonUnitalNormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedSpace : NormedSpace ℂ A] →
... | null | false |
AlgHom.liftOfSurjective._proof_4 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f).IsTwoSided | null | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_right._simp_1_2 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) | null | false |
HDiv.hDiv | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HDiv α β γ] → α → β → γ | `a / b` computes the result of dividing `a` by `b`.
The meaning of this notation is type-dependent.
* For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`.
* For `Nat`, `a / b` rounds downwards.
* For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative.
It is impl... | true |
Valuation.toMonoidWithZeroHom | Mathlib.RingTheory.Valuation.Basic | {R : Type u_3} →
{Γ₀ : Type u_4} → [inst : LinearOrderedCommMonoidWithZero Γ₀] → [inst_1 : Ring R] → Valuation R Γ₀ → R →*₀ Γ₀ | null | true |
Lean.Meta.Grind.EMatch.SearchState._sizeOf_inst | Lean.Meta.Tactic.Grind.EMatch | SizeOf Lean.Meta.Grind.EMatch.SearchState | null | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.guessReorder.visit._sparseCasesOn_11 | Mathlib.Tactic.Translate.Reorder | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuse_1 | Mathlib.Tactic.DefEqAbuse | Lean.Elab.Tactic.Tactic | > **WARNING:** `#defeq_abuse` is an experimental tool intended to assist with breaking
changes to transparency handling. Its syntax may change at any time, and it may not behave as
expected. Please report unexpected behavior [on Zulip](https://leanprover.zulipchat.com/#narrow/channel/113488-general/topic/backward.2EisD... | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isNoncomputable._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.ComputeKind → Sort u} →
(t : Lean.Elab.ComputeKind) →
motive Lean.Elab.ComputeKind.noncomputable → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_85 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
MeasureTheory.Measure.addHaarMeasure.eq_1 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] (K₀ : TopologicalSpace.PositiveCompacts G),
MeasureTheory.Measure.addHaarMeasure K₀ =
((MeasureTheory.Measure.haar.addHaarContent K₀).measure ↑K₀)⁻¹ •
... | null | true |
CategoryTheory.Functor.HomObj.naturality_assoc | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)} (self : F.HomObj G A) {c d : C} (f : c ⟶ d)
(a : A.obj c) {Z : D} (h : G.obj d ⟶ Z),
CategoryTheory.CategoryStruct.comp (F... | null | true |
Lean.Meta.getElimExprInfo | Lean.Meta.Tactic.ElimInfo | Lean.Expr → optParam (Option Lean.Name) none → Lean.MetaM Lean.Meta.ElimInfo | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._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 : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (Category... | null | false |
_private.Std.Async.UDP.0.Std.Async.UDP.Socket.ofNative._flat_ctor | Std.Async.UDP | Std.Internal.UV.UDP.Socket → Std.Async.UDP.Socket | null | false |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.disjoint_withBotCoe._simp_1_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b ≤ ⊥) | null | false |
TopologicalSpace.IrreducibleCloseds.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isIrreducible' : IsIrreducible carrier)
(isClosed' : IsClosed carrier) (carrier_1 : Set α) (isIrreducible'_1 : IsIrreducible carrier_1)
(isClosed'_1 : IsClosed carrier_1),
({ carrier := carrier, isIrreducible' := isIrreducible', isClosed' := isClosed... | null | true |
TopologicalSpace.IsTopologicalBasis.nhds_hasBasis | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {b : Set (Set α)},
TopologicalSpace.IsTopologicalBasis b → ∀ {a : α}, (nhds a).HasBasis (fun t => t ∈ b ∧ a ∈ t) fun t => t | null | true |
Lean.Meta.Sym.Arith.CommRing.mk.inj | Lean.Meta.Sym.Arith.Types | ∀ {toRing : Lean.Meta.Sym.Arith.Ring} {invFn? : Option Lean.Expr} {semiringId? : Option ℕ}
{commSemiringInst commRingInst : Lean.Expr} {noZeroDivInst? fieldInst? : Option Lean.Expr}
{toRing_1 : Lean.Meta.Sym.Arith.Ring} {invFn?_1 : Option Lean.Expr} {semiringId?_1 : Option ℕ}
{commSemiringInst_1 commRingInst_1 : ... | null | true |
Int.divisorsAntidiag_neg_natCast._proof_1 | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ),
Disjoint
(Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))))
n.divisorsAntidiagonal)
(Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding)
n.divisorsAntidiagonal) | null | false |
Distribution.TemperedDistribution.IsVanishingOn.lineDerivOp | Mathlib.Analysis.Distribution.Support | ∀ {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ E]
[inst_3 : NormedSpace ℂ F] {f : TemperedDistribution E F} {s : Set E},
Distribution.IsVanishingOn (⇑f) s → ∀ (m : E), Distribution.IsVanishingOn (⇑(LineDeriv.lineDerivOp m f)) s | null | true |
Lean.MetavarContext.incDepth | Lean.MetavarContext | Lean.MetavarContext → optParam Bool false → Lean.MetavarContext | null | true |
AddMonoidHom.compHom'_apply_apply | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type uM} {N : Type uN} {P : Type uP} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] [inst_2 : AddCommMonoid P]
(f : M →+ N) (y : N →+ P) (x : M), (f.compHom' y) x = y (f x) | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique.0.AlgebraNorm.instFieldCopy._proof_41 | Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique | ∀ {K : Type u_1} {L : Type u_2} [inst : NontriviallyNormedField K] [inst_1 : Field L] [inst_2 : Algebra K L]
(_f : AlgebraNorm K L) (x : L),
autoParam (∀ (n : ℕ) (a : AlgebraNorm.copy✝ _f x), Int.negSucc n • a = -(↑n.succ • a))
SubNegMonoid.zsmul_neg'._autoParam | null | false |
Matrix.circulant_col_zero_eq | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} {n : Type u_3} [inst : SubtractionMonoid n] (v : n → α) (i : n), Matrix.circulant v i 0 = v i | null | true |
CategoryTheory.toSkeleton | Mathlib.CategoryTheory.Skeletal | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → C → CategoryTheory.Skeleton C | The class of an object in the skeleton. | true |
Homotopy.mkInductiveAux₂._proof_4 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero + CategoryTheory.CategoryStruct.comp one (Q.d 2 1))
(su... | null | false |
Ideal.radical_le_jacobson | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical ≤ I.jacobson | null | true |
Lean.DataValue.ofString.injEq | Lean.Data.KVMap | ∀ (v v_1 : String), (Lean.DataValue.ofString v = Lean.DataValue.ofString v_1) = (v = v_1) | null | true |
Lean.Elab.Term.PostponeBehavior.partial.sizeOf_spec | Lean.Elab.SyntheticMVars | sizeOf Lean.Elab.Term.PostponeBehavior.partial = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.