name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearMap.map_domRestrict | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₂₁ : R₂ →+* R}
[inst_6 : RingHomSurjective σ₂₁] (p : Submodule R₂ M₂) (f : M₂ →ₛₗ[σ₂₁] M) (p' : Submodule ... | null | true |
Subgroup.coe_subgroupOf | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), ↑(H.subgroupOf K) = ⇑K.subtype ⁻¹' ↑H | null | true |
ProfiniteGrp.ProfiniteCompletion.adjunction._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {X' X : GrpCat} {Y : ProfiniteGrp.{u_1}} (f : X' ⟶ X)
(g : X ⟶ (CategoryTheory.forget₂ ProfiniteGrp.{u_1} GrpCat).obj Y),
(ProfiniteGrp.ProfiniteCompletion.homEquiv X' Y).symm (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (ProfiniteGrp.profiniteCompletion.map f)
((Profini... | null | false |
MeasureTheory.VectorMeasure.instIsFiniteMeasureVariationMap | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {X : Type u_1} {V : Type u_2} {mX : MeasurableSpace X} [inst : TopologicalSpace V] [inst_1 : ENormedAddCommMonoid V]
[inst_2 : T2Space V] {μ : MeasureTheory.VectorMeasure X V} {Y : Type u_3} [inst_3 : MeasurableSpace Y] {φ : X → Y}
[MeasureTheory.IsFiniteMeasure μ.variation], MeasureTheory.IsFiniteMeasure (μ.map ... | null | true |
NonUnitalStarSubalgebra.coe_add | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : Star A] (S : NonUnitalStarSubalgebra R A) (x y : ↥S), ↑(x + y) = ↑x + ↑y | null | true |
inv_add_inv | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : Semifield K] {a b : K}, a ≠ 0 → b ≠ 0 → a⁻¹ + b⁻¹ = (a + b) / (a * b) | null | true |
IsDedekindDomain.HeightOneSpectrum.instAlgebraSubtypeAdicCompletionMemValuationSubringAdicCompletionIntegers._proof_6 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_1) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R)
(x : ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v)),
{
toFun := fun r =>
... | null | false |
Submodule.spanRank_finite_iff_fg._simp_1 | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p : Submodule R M},
(p.spanRank < Cardinal.aleph0) = p.FG | null | false |
MvPolynomial.decomposition | Mathlib.RingTheory.MvPolynomial.Homogeneous | {σ : Type u_1} →
{R : Type u_3} → [inst : CommSemiring R] → DirectSum.Decomposition (MvPolynomial.homogeneousSubmodule σ R) | The decomposition of `MvPolynomial σ R` into homogeneous submodules. | true |
Lean.pp.safeShadowing | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool | null | true |
Polynomial.shiftedLegendre | Mathlib.RingTheory.Polynomial.ShiftedLegendre | ℕ → Polynomial ℤ | `shiftedLegendre n` is an integer polynomial for each `n : ℕ`, defined by:
`Pₙ(x) = ∑ k ∈ Finset.range (n + 1), (-1)ᵏ * choose n k * choose (n + k) n * xᵏ`
These polynomials appear in combinatorics and the theory of orthogonal polynomials. | true |
ENat.top_sub_one | Mathlib.Data.ENat.Basic | ⊤ - 1 = ⊤ | null | true |
CategoryTheory.Over.coprod._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
{A : C} {X Y : CategoryTheory.Over A} (k : X ⟶ Y) (f g : CategoryTheory.Over A) (k_1 : f ⟶ g),
CategoryTheory.CategoryStruct.comp (X.coprodObj.map k_1)
(CategoryTheory.Over.homMk
(Cate... | null | false |
KaehlerDifferential.derivationQuotKerTotal._proof_5 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
((KaehlerDifferential.kerTotal R S).mkQ fun₀ | 1 => 1) = 0 | null | false |
AlgebraicGeometry.IsClosedImmersion.comp_iff | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {g : Y ⟶ Z} [AlgebraicGeometry.IsClosedImmersion g],
AlgebraicGeometry.IsClosedImmersion (CategoryTheory.CategoryStruct.comp f g) ↔ AlgebraicGeometry.IsClosedImmersion f | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (U : ↑X.affineOpens), ↑U ∈ X.affineOpens | null | false |
CategoryTheory.Distributive.«_aux_Mathlib_CategoryTheory_Distributive_Monoidal___macroRules_CategoryTheory_Distributive_term∂R_1» | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.Macro | null | false |
ContDiffMapSupportedIn.coe_of_support_subset | 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} {f : E → F} (hf : ContDiff ℝ (↑n) f)
(hsupp : Function.support f ⊆ ↑K) (a : E), (ContDiffMapSupportedIn.of_support_subset hf ... | null | true |
MulActionHom.instCoeTCOfMulActionSemiHomClass.eq_1 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{F : Type u_8} [inst_2 : FunLike F X Y] [inst_3 : MulActionSemiHomClass F φ X Y],
MulActionHom.instCoeTCOfMulActionSemiHomClass = { coe := MulActionSemiHomClass.toMulActionHom } | null | true |
Bundle.Trivialization.zeroSection | Mathlib.Topology.VectorBundle.Basic | ∀ (R : Type u_1) {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : NontriviallyNormedField R]
[inst_1 : (x : B) → AddCommMonoid (E x)] [inst_2 : (x : B) → Module R (E x)] [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace R F] [inst_5 : TopologicalSpace B] [inst_6 : TopologicalSpace (Bundle.TotalSpace F E... | null | true |
AddAction.fixedPoints | Mathlib.GroupTheory.GroupAction.Defs | (M : Type u_1) → (α : Type u_3) → [inst : AddMonoid M] → [AddAction M α] → Set α | The set of elements fixed under the whole action. | true |
_private.Mathlib.MeasureTheory.Measure.LevyConvergence.0.MeasureTheory.isTightMeasureSet_of_tendsto_charFun._proof_1_6 | Mathlib.MeasureTheory.Measure.LevyConvergence | (3 + 1).AtLeastTwo | null | false |
finite_mulSupport_of_finprod_ne_one | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M}, ∏ᶠ (i : α), f i ≠ 1 → Function.HasFiniteMulSupport f | **Alias** of `hasFiniteMulSupport_of_finprod_ne_one`. | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.EMatchTheorem | ∀ (symPrios : Lean.Meta.Grind.SymbolPriorities) (minPrio : ℕ),
sizeOf { symPrios := symPrios, minPrio := minPrio } = 1 + sizeOf symPrios + sizeOf minPrio | null | true |
trichotomous_def | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop}, Std.Trichotomous r ↔ ∀ ⦃a b : α⦄, ¬r a b → ¬r b a → a = b | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {ka : ℤ} {ca? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {kb : ℕ}
{cb? : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr} {ka_1 : ℤ} {ca?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr}
{kb_1 : ℕ} {cb?_1 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr},
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow ka ca? kb cb?... | null | true |
Mathlib.Tactic.ModCases.IntMod.proveOnModCases | Mathlib.Tactic.ModCases | {u : Lean.Level} →
(n : Q(ℕ)) →
(a : Q(ℤ)) →
(b : Q(ℕ)) →
(p : Q(Sort u)) →
Lean.MetaM (Q(Mathlib.Tactic.ModCases.IntMod.OnModCases «$n» «$a» «$b» «$p») × List Lean.MVarId) | Proves an expression of the form `OnModCases n a b p` where `n` and `b` are raw nat literals
and `b ≤ n`. Returns the list of subgoals `?gi : a ≡ i [ZMOD n] → p`.
| true |
Lean.Kernel.Exception.unknownConstant.elim | Lean.Environment | {motive : Lean.Kernel.Exception → Sort u} →
(t : Lean.Kernel.Exception) →
t.ctorIdx = 0 →
((env : Lean.Kernel.Environment) → (name : Lean.Name) → motive (Lean.Kernel.Exception.unknownConstant env name)) →
motive t | null | false |
CategoryTheory.imageOpUnop | Mathlib.CategoryTheory.Abelian.Opposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X Y : C} → (f : X ⟶ Y) → Opposite.unop (CategoryTheory.Limits.image f.op) ≅ CategoryTheory.Limits.image f | The image of `f.op` is the opposite of the image of `f`. | true |
CategoryTheory.RingObjCat.mk.injEq | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C) [ringObj : CategoryTheory.RingObj X] (X_1 : C)
(ringObj_1 : CategoryTheory.RingObj X_1),
({ X := X, ringObj := ringObj } = { X := X_1, ringObj := ringO... | null | true |
UInt64.le_antisymm_iff | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b ↔ a ≤ b ∧ b ≤ a | null | true |
NormedAddCommGroup.toSeminormedAddCommGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_5} → [NormedAddCommGroup E] → SeminormedAddCommGroup E | null | true |
GaloisCoinsertion.liftCompleteLattice | Mathlib.Order.GaloisConnection.Basic | {α : Type u} →
{β : Type v} →
{u : α → β} →
{l : β → α} → [inst : PartialOrder β] → [inst_1 : CompleteLattice α] → GaloisCoinsertion l u → CompleteLattice β | Lift all suprema and infima along a Galois coinsertion | true |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic.0.exists_continuous_add_one_of_isCompact_nnreal._simp_1_2 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
PadicInt.modPart | Mathlib.NumberTheory.Padics.RingHoms | ℕ → ℚ → ℤ | `modPart p r` is an integer that satisfies
`‖(r - modPart p r : ℚ_[p])‖ < 1` when `‖(r : ℚ_[p])‖ ≤ 1`,
see `PadicInt.norm_sub_modPart`.
It is the unique non-negative integer that is `< p` with this property.
(Note that this definition assumes `r : ℚ`.
See `PadicInt.zmodRepr` for a version that takes values in `ℕ`
and ... | true |
SimpleGraph.UnitDistEmbedding.mk | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | {V : Type u_1} →
{G : SimpleGraph V} →
{E : Type u_3} →
[inst : MetricSpace E] → (p : V ↪ E) → (∀ {u v : V}, G.Adj u v → dist (p u) (p v) = 1) → G.UnitDistEmbedding E | null | true |
Polynomial.card_roots_le_map | Mathlib.Algebra.Polynomial.Roots | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : IsDomain A] [inst_3 : IsDomain B]
{p : Polynomial A} {f : A →+* B}, Polynomial.map f p ≠ 0 → p.roots.card ≤ (Polynomial.map f p).roots.card | null | true |
isProperMap_iff_isCompact_preimage | Mathlib.Topology.Maps.Proper.CompactlyGenerated | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space Y]
[CompactlyCoherentSpace Y] {f : X → Y},
IsProperMap f ↔ Continuous f ∧ ∀ ⦃K : Set Y⦄, IsCompact K → IsCompact (f ⁻¹' K) | If `Y` is Hausdorff and compactly generated, then proper maps `X → Y` are exactly
continuous maps such that the preimage of any compact set is compact. This is in particular true
if `Y` is Hausdorff and sequential or locally compact.
There was an older version of this theorem which was changed to this one to make use
... | true |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_2 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_1} {R' : Type u_2} {M : Type u_3} {M' : Type u_4} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_5} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommCla... | null | false |
mul_invOf_cancel_right | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] (a b : α) [inst_1 : Invertible b], a * b * ⅟b = a | null | true |
CategoryTheory.Limits.pullbackPullbackRightIsPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X₁ X₂ X₃ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₁)
(f₃ : X₂ ⟶ Y₂) (f₄ : X₃ ⟶ Y₂) [inst_1 : CategoryTheory.Limits.HasPullback f₁ f₂]
[inst_2 : CategoryTheory.Limits.HasPullback f₃ f₄]
[inst_3 :
CategoryTheory.Limits.HasPullback f₁
(CategoryTh... | null | false |
MonoidHom.coe_mrangeRestrict | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} [inst : MulOneClass M] {N : Type u_5} [inst_1 : MulOneClass N] (f : M →* N) (x : M),
↑(f.mrangeRestrict x) = f x | null | true |
_private.Mathlib.Analysis.Normed.Group.Bounded.0.Bornology.IsBounded.exists_pos_norm_le'.match_1_1 | Mathlib.Analysis.Normed.Group.Bounded | ∀ {E : Type u_1} [inst : SeminormedGroup E] {s : Set E} (motive : (∃ C, ∀ x ∈ s, ‖x‖ ≤ C) → Prop)
(x : ∃ C, ∀ x ∈ s, ‖x‖ ≤ C), (∀ (R₀ : ℝ) (hR₀ : ∀ x ∈ s, ‖x‖ ≤ R₀), motive ⋯) → motive x | null | false |
LinearMap.BilinForm.SeparatingRight.toMatrix | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} {M₂ : Type u_4} [inst : CommRing R₂] [inst_1 : AddCommGroup M₂] [inst_2 : Module R₂ M₂] {ι : Type u_6}
[inst_3 : DecidableEq ι] [inst_4 : Fintype ι] {B : LinearMap.BilinForm R₂ M₂},
LinearMap.SeparatingRight B → ∀ (b : Module.Basis ι R₂ M₂), ((LinearMap.BilinForm.toMatrix b) B).SeparatingRight | null | true |
Std.DTreeMap.Internal.Impl.ExplorationStep.casesOn | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
{motive : Std.DTreeMap.Internal.Impl.ExplorationStep α β k → Sort u_1} →
(t : Std.DTreeMap.Internal.Impl.ExplorationStep α β k) →
((a : α) →
(a_1 : k a = Ordering.lt) →
(a_... | null | false |
NumberField.mixedEmbedding.convexBodySum_isBounded | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B : ℝ),
Bornology.IsBounded (NumberField.mixedEmbedding.convexBodySum K B) | null | true |
FreeAlgebra.instNoZeroDivisors | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R] [NoZeroDivisors R], NoZeroDivisors (FreeAlgebra R X) | `FreeAlgebra R X` has no zero-divisors when `R` has no zero-divisors. | true |
CategoryTheory.Comma.mapLeftId | 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] →
(L : CategoryTheory.Functor A T) →
(R : CategoryTheory.Functor B T) →
... | The functor `Comma L R ⥤ Comma L R` induced by the identity natural transformation on `L` is
naturally isomorphic to the identity functor. | true |
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {n : Q(ℕ)} →
{P : Sort u} →
{n' : Q(ℕ)} →
{pf : «$n» =Q «$n'».succ} →
{n'' : Q(ℕ)} →
{pf' : «$n» =Q «$n''».succ} →
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n' pf = Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n'' pf' →
(n' = n'' → P) → P | null | false |
Filter.EventuallyEq.isTheta | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {l : Filter α} {f g : α → E}, f =ᶠ[l] g → f =Θ[l] g | null | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun.visitLambda | Mathlib.Tactic.Translate.Core | Mathlib.Tactic.Translate.TranslateData →
Lean.Expr →
List Lean.Expr →
optParam (Array Lean.Expr) #[] → optParam Lean.LocalContext { } → Mathlib.Tactic.Translate.ReplacementM Lean.Expr | null | true |
Lean.Lsp.TextDocumentClientCapabilities.completion? | Lean.Data.Lsp.Capabilities | Lean.Lsp.TextDocumentClientCapabilities → Option Lean.Lsp.CompletionClientCapabilities | null | true |
Std.DTreeMap.Const.minKey!_modify_eq_minKey! | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey! = t.minKey! | null | true |
List.replaceIf | Mathlib.Data.List.Defs | {α : Type u_1} → List α → List Bool → List α → List α | Given a starting list `old`, a list of Booleans and a replacement list `new`,
read the items in `old` in succession and either replace them with the next element of `new` or
not, according as to whether the corresponding Boolean is `true` or `false`. | true |
MonCat.FilteredColimits.colimitCocone._proof_2 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J] ⦃X Y : J⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (MonCat.FilteredColimits.coconeMorphism F Y) =
CategoryTheory.CategoryStruct.comp (MonCat.FilteredColimits.coc... | null | false |
Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (Q : Ideal S)
[inst_3 : Q.IsPrime] [Algebra.FiniteType R S] [Algebra.IsUnramifiedAt R Q], ∃ f ∉ Q, HasStandardEtaleSurjectionOn R f | null | true |
Std.Internal.Small.casesOn | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
{motive : Std.Internal.Small α → Sort u_1} →
(t : Std.Internal.Small α) → ((h : Nonempty (Std.Internal.ComputableSmall α)) → motive ⋯) → motive t | null | false |
LieEquiv.left_inv | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {L' : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (self : L ≃ₗ⁅R⁆ L'),
Function.LeftInverse self.invFun (↑self.toLieHom).toFun | The inverse function of an equivalence of Lie algebras is a left inverse of the underlying
function. | true |
_private.Mathlib.Data.Finset.Sigma.0.Finset.filter_sigma._simp_1_2 | Mathlib.Data.Finset.Sigma | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.recOn | Lean.Elab.Tactic.Do.Attr | {motive : Lean.Elab.Tactic.Do.SpecAttr.SpecProof → Sort u} →
(t : Lean.Elab.Tactic.Do.SpecAttr.SpecProof) →
((declName : Lean.Name) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecProof.global declName)) →
((fvarId : Lean.FVarId) → motive (Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local fvarId)) →
((id : Le... | null | false |
_private.Mathlib.MeasureTheory.Measure.Restrict.0.MeasureTheory.Measure.restrictₗ._simp_2 | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_1} (a b c : Set α), a ∩ (b \ c) = (a ∩ b) \ c | null | false |
AlgebraicGeometry.PresheafedSpace.instInhabited | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → [Inhabited C] → Inhabited (AlgebraicGeometry.PresheafedSpace C) | null | true |
String.Slice.Pos.skip?_bool_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String.Slice} {pos res : s.Pos},
pos.skip? p = some res ↔ ∃ (h : pos ≠ s.endPos), res = pos.next h ∧ p (pos.get h) = true | null | true |
CategoryTheory.SingleFunctors.postcompIsoOfIso_hom_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E] {A : Type u_5}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | null | true |
IsAlgClosure.of_exists_root | Mathlib.FieldTheory.Isaacs | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[alg : Algebra.IsAlgebraic F E],
(∀ (p : Polynomial F), p.Monic → Irreducible p → ∃ x, (Polynomial.aeval x) p = 0) → IsAlgClosure F E | null | true |
CategoryTheory.Limits.MulticospanIndex.mk | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(left : J.L → C) →
(right : J.R → C) →
((b : J.R) → left (J.fst b) ⟶ right b) →
((b : J.R) → left (J.snd b) ⟶ right b) → CategoryTheory.Limits.MulticospanIndex J C | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_negAddY_of_eq._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
bddAbove_smul_iff_of_neg._simp_1 | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β]
{s : Set β} {a : α}, a < 0 → BddAbove (a • s) = BddBelow s | null | false |
Matrix.frobeniusNormedRing._proof_10 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {α : Type u_2} [inst : Fintype m] [inst_1 : RCLike α] (n : ℕ) (a : Matrix m m α),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | null | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_22 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (j : ℕ), j - 1 + 1 ≤ tail.length → j - 1 < tail.length | null | false |
ByteArray.utf8Decode?.eq_1 | Init.Data.String.Basic | ∀ (b : ByteArray), b.utf8Decode? = ByteArray.utf8Decode?.go b 0 #[] ⋯ | null | true |
_private.Batteries.Tactic.Init.0.Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_byContra_1.match_1 | Batteries.Tactic.Init | (motive : Option (Lean.TSyntax `term) → Sort u_1) →
(ty? : Option (Lean.TSyntax `term)) →
((ty? : Lean.TSyntax `term) → motive (some ty?)) → ((x : Option (Lean.TSyntax `term)) → motive x) → motive ty? | null | false |
MvFunctor.exists_iff_exists_of_mono | Mathlib.Control.Functor.Multivariate | ∀ {n : ℕ} {α β : TypeVec.{u} n} (F : TypeVec.{u} n → Type v) [inst : MvFunctor F] [LawfulMvFunctor F] {P : F α → Prop}
{q : F β → Prop} (f : α.Arrow β) (g : β.Arrow α),
TypeVec.comp f g = TypeVec.id → (∀ (u : F α), P u ↔ q (MvFunctor.map f u)) → ((∃ u, P u) ↔ ∃ u, q u) | null | true |
IsometryEquiv.subRight_apply | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd Gᵃᵒᵖ G] (c b : G),
(IsometryEquiv.subRight c) b = b - c | null | true |
PresheafOfModules.Derivation.d_one | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor Dᵒᵖ CommRingCat}
{M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat Ring... | null | true |
Lean.Lsp.SemanticTokenType.ctorElimType | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SemanticTokenType → Sort u} → ℕ → Sort (max 1 u) | null | false |
Mathlib.Tactic.GCongr.GCongrHyp.isContra | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrHyp → Bool | Whether the order of the two varying arguments is the opposite from in the conclusion. | true |
Subgroup.HasDetOne.recOn | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | {n : Type u_1} →
[inst : Fintype n] →
[inst_1 : DecidableEq n] →
{R : Type u_2} →
[inst_2 : CommRing R] →
{Γ : Subgroup (GL n R)} →
{motive : Γ.HasDetOne → Sort u} →
(t : Γ.HasDetOne) →
((det_eq : ∀ {g : GL n R}, g ∈ Γ → Matrix.GeneralLinearGroup.d... | null | false |
MonoidHom.submonoidComap_surjective_of_surjective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : M →* N) (N' : Submonoid N),
Function.Surjective ⇑f → Function.Surjective ⇑(f.submonoidComap N') | null | true |
String.Pos.next.congr_simp | Init.Data.String.Basic | ∀ {s : String} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.endPos), pos.next h = pos_1.next ⋯ | null | true |
AddSubmonoidClass.subtype | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_1} →
{A : Type u_3} → [inst : AddZeroClass M] → [inst_1 : SetLike A M] → [hA : AddSubmonoidClass A M] → (S' : A) → ↥S' →+ M | The natural monoid hom from an `AddSubmonoid` of `AddMonoid` `M` to `M`. | true |
IO.Error.illegalOperation.sizeOf_spec | Init.System.IOError | ∀ (osCode : UInt32) (details : String),
sizeOf (IO.Error.illegalOperation osCode details) = 1 + sizeOf osCode + sizeOf details | null | true |
UInt8.add_right_neg | Init.Data.UInt.Lemmas | ∀ (a : UInt8), a + -a = 0 | null | true |
ENNReal.div_eq_div_iff | Mathlib.Data.ENNReal.Inv | ∀ {a b c d : ENNReal}, a ≠ 0 → a ≠ ⊤ → b ≠ 0 → b ≠ ⊤ → (c / b = d / a ↔ a * c = b * d) | null | true |
Lean.Meta.getIntrosSize._unsafe_rec | Lean.Meta.Tactic.Intro | Lean.Expr → ℕ | null | false |
CategoryTheory.Functor.instMonoidalMonMapAddMon | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
[inst_4 :... | null | true |
InnerProductSpace.laplacianWithin.congr_simp | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] (f f_1 : E → F),
f = f_1 →
∀ (s s_1 : Set E),
s = s_1 →
∀ (a a_1 : E), a = a_1 → InnerProductSpace.laplacianWit... | null | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.TFAE_mem_nhdsGE.match_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} (s : Set α) (motive : (∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s) → Prop)
(x : ∃ u ∈ Set.Ioc a b, Set.Ico a u ⊆ s),
(∀ (u : α) (umem : u ∈ Set.Ioc a b) (hu : Set.Ico a u ⊆ s), motive ⋯) → motive x | null | false |
CategoryTheory.ObjectProperty.instIsTriangulatedMinOfIsClosedUnderIsomorphisms | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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] [inst_5 : CategoryTheory.Pretriangulated C]
(P : CategoryT... | null | true |
Finsupp.lsingle_apply | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : α) (b : M), (Finsupp.lsingle a) b = fun₀ | a => b | null | true |
Function.Injective.cancelMonoid.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : Pow M₁ ℕ] [inst_3 : CancelMonoid M₂]
(f : M₁ → M₂) (hf : Function.Injective f) (one : f 1 = 1) (mul : ∀ (x y : M₁), f (x * y) = f x * f y)
(npow : ∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n),
Function.Injective.cancelMonoid f hf one mul np... | null | true |
FourierPair.fourierInv_fourier_eq | Mathlib.Analysis.Fourier.Notation | ∀ {E : Type u_5} {F : Type u_6} {inst : FourierTransform E F} {inst_1 : FourierTransformInv F E}
[self : FourierPair E F] (f : E), FourierTransformInv.fourierInv (FourierTransform.fourier f) = f | null | true |
Complex.log_zero | Mathlib.Analysis.SpecialFunctions.Complex.Log | Complex.log 0 = 0 | null | true |
CategoryTheory.Functor.rightDerived_fac_assoc | Mathlib.CategoryTheory.Functor.Derived.RightDerived | ∀ {C : Type u_3} {D : Type u_1} {H : Type u_2} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Category.{v_3, u_1} D] [inst_2 : CategoryTheory.Category.{v_5, u_2} H]
(RF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : F ⟶ L.comp RF) (W : ... | null | true |
PadicInt.instIsDiscreteValuationRing | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)], IsDiscreteValuationRing ℤ_[p] | null | true |
DivInvMonoid.mk | Mathlib.Algebra.Group.Defs | {G : Type u} →
[toMonoid : Monoid G] →
[toInv : Inv G] →
[toDiv : Div G] →
autoParam (∀ (a b : G), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam →
(zpow : ℤ → G → G) →
autoParam (∀ (a : G), zpow 0 a = 1) DivInvMonoid.zpow_zero'._autoParam →
autoParam (∀ ... | null | true |
CategoryTheory.PreservesImage.hom_comp_map_image_ι | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Images | ∀ {A : Type u₁} {B : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Limits.HasEqualizers A] [inst_3 : CategoryTheory.Limits.HasImages A]
[inst_4 : CategoryTheory.StrongEpiCategory B] [inst_5 : CategoryTheory.Limits.HasImages B]
(L : Cate... | null | true |
Homeomorph.piSplitAt | Mathlib.Topology.Homeomorph.Lemmas | {ι : Type u_7} →
[DecidableEq ι] →
(i : ι) →
(Y : ι → Type u_8) →
[inst : (j : ι) → TopologicalSpace (Y j)] → ((j : ι) → Y j) ≃ₜ Y i × ((j : { j // j ≠ i }) → Y ↑j) | A product of topological spaces can be split as the binary product of one of the spaces and
the product of all the remaining spaces. | true |
Lean.Meta.ExtractLets.LocalDecl'.noConfusion | Lean.Meta.Tactic.Lets | {P : Sort u} →
{t t' : Lean.Meta.ExtractLets.LocalDecl'} → t = t' → Lean.Meta.ExtractLets.LocalDecl'.noConfusionType P t t' | null | false |
Std.ExtTreeMap.getElem?_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a b : α},
cmp a b = Ordering.eq → t[a]? = t[b]? | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.