name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.RingTheory.FiniteType.0.Algebra.FiniteType.of_surjective._simp_1_2 | Mathlib.RingTheory.FiniteType | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) {y : B}, (y ∈ φ.range) = ∃ x, φ x = y | false |
Lean.Lsp.LeanDidOpenTextDocumentParams.rec | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanDidOpenTextDocumentParams → Sort u} →
((toDidOpenTextDocumentParams : Lean.Lsp.DidOpenTextDocumentParams) →
(dependencyBuildMode? : Option Lean.Lsp.DependencyBuildMode) →
motive
{ toDidOpenTextDocumentParams := toDidOpenTextDocumentParams,
dependencyBuildMode... | false |
Lean.IR.IRType.erased.sizeOf_spec | Lean.Compiler.IR.Basic | sizeOf Lean.IR.IRType.erased = 1 | true |
MeasureTheory.hausdorffMeasure_orthogonalProjection_le | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {𝕜 : Type u_4} {E : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (K : Submodule 𝕜 E) [inst_5 : K.HasOrthogonalProjection] (d : ℝ)
(s : Set E),
0 ≤ d →
(MeasureTheory.Measure.hausdorffMeasure d) (⇑K.ortho... | true |
_private.Mathlib.Algebra.Homology.Additive.0.CategoryTheory.NatIso.mapHomologicalComplex._simp_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (c : ComplexShape ι) {F G H : CategoryTheory.Functor W₁ W₂}
[in... | false |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Basic.0.Polynomial.coprime_of_root_cyclotomic._simp_1_2 | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | false |
Lean.Elab.Info.ofPartialTermInfo.elim | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
t.ctorIdx = 2 → ((i : Lean.Elab.PartialTermInfo) → motive (Lean.Elab.Info.ofPartialTermInfo i)) → motive t | false |
_private.Mathlib.AlgebraicGeometry.Cover.QuasiCompact.0.AlgebraicGeometry.QuasiCompactCover.instPullback₁Scheme._simp_2 | Mathlib.AlgebraicGeometry.Cover.QuasiCompact | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
OrderIso.dualAntisymmetrization._proof_2 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a : α),
Quotient.map' id ⋯ (Quotient.map' id ⋯ (Quotient.mk'' a)) = Quotient.mk'' a | false |
_private.Mathlib.Tactic.Algebraize.0.Lean.Attr.algebraizeGetParam.match_1 | Mathlib.Tactic.Algebraize | (motive : Lean.Name → Sort u_1) →
(thm : Lean.Name) → ((t : String) → motive (`RingHom.str t)) → ((x : Lean.Name) → motive x) → motive thm | false |
_private.Mathlib.CategoryTheory.CommSq.0.CategoryTheory.CommSq.LiftStruct.ext.match_1 | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_2} {inst : CategoryTheory.Category.{u_1, u_2} C} {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
{g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (motive : sq.LiftStruct → Prop) (h : sq.LiftStruct),
(∀ (l : B ⟶ X)
(fac_left :
autoParam (CategoryTheory.CategoryStruct.comp i l = f) Categ... | false |
ProbabilityTheory.iCondIndepSet | Mathlib.Probability.Independence.Conditional | {Ω : Type u_1} →
{ι : Type u_2} →
(m' : MeasurableSpace Ω) →
{mΩ : MeasurableSpace Ω} →
[StandardBorelSpace Ω] →
m' ≤ mΩ →
(ι → Set Ω) →
(μ : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.iCondIndepSet._auto_1) →
[MeasureTheory.IsFiniteMeas... | true |
IdemSemiring.ofSemiring | Mathlib.Algebra.Order.Kleene | {α : Type u_1} → [inst : Semiring α] → (∀ (a : α), a + a = a) → IdemSemiring α | true |
Quot.lift₂._proof_1 | Mathlib.Data.Quot | ∀ {α : Sort u_3} {β : Sort u_1} {γ : Sort u_2} {r : α → α → Prop} {s : β → β → Prop} (f : α → β → γ)
(hr : ∀ (a : α) (b₁ b₂ : β), s b₁ b₂ → f a b₁ = f a b₂),
(∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → f a₁ b = f a₂ b) → ∀ (a₁ a₂ : α), r a₁ a₂ → Quot.lift (f a₁) ⋯ = Quot.lift (f a₂) ⋯ | false |
Mathlib.Tactic.Says.says.verify | Mathlib.Tactic.Says | Lean.Option Bool | true |
_private.Mathlib.Data.List.Permutation.0.List.count_permutations'Aux_self._simp_1_2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | false |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.mk.inj | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)} {unit : CategoryTheory.Functor.id C ⟶ F.comp G}
{counit : G.comp ... | true |
List.snd_idxToSigmaCount._proof_2 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs : List α} {i : Fin xs.length},
List.countBefore xs[↑i] xs ↑i < List.count (xs.idxToSigmaCount i).fst xs | false |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go._unary._proof_1 | Lean.Data.RArray | ∀ {n : ℕ},
WellFounded
(invImage
(fun x =>
PSigma.casesOn x fun lb ub => PSigma.casesOn ub fun ub h1 => PSigma.casesOn h1 fun h1 h2 => (ub, ub - lb))
Prod.instWellFoundedRelation).1 | false |
MonoidHom.mker | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : MulOneClass M] →
[inst_1 : MulOneClass N] →
{F : Type u_4} → [inst_2 : FunLike F M N] → [mc : MonoidHomClass F M N] → F → Submonoid M | true |
Multiset.decidableExistsMultiset._proof_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {p : α → Prop} (l : List α), (∃ a ∈ l, p a) ↔ ∃ x ∈ ⟦l⟧, p x | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.List.filterMap.match_1.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b | true |
TwoSidedIdeal.equivMatrix.congr_simp | Mathlib.LinearAlgebra.Matrix.Ideal | ∀ {R : Type u_1} {n : Type u_2} [inst : NonAssocRing R] [inst_1 : Fintype n] [inst_2 : Nonempty n]
[inst_3 : DecidableEq n], TwoSidedIdeal.equivMatrix = TwoSidedIdeal.equivMatrix | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_alterKey._simp_1_4 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValueCast a l h) = Std.Internal.List.getValueCast? a l | false |
LinearIndependent.fintypeLinearCombination_injective | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Fintype ι],
LinearIndependent R v → Function.Injective ⇑(Fintype.linearCombination R v) | true |
instAlgebraCliffordAlgebra | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (Q : QuadraticForm R M) → Algebra R (CliffordAlgebra Q) | true |
Lean.SubExpr.Pos.fromString? | Lean.SubExpr | String → Except String Lean.SubExpr.Pos | true |
LinearEquiv.piRing.eq_1 | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) (ι : Type x) [inst : Semiring R] (S : Type u_4) [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : Semiring S] [inst_4 : AddCommMonoid M] [inst_5 : Module R M] [inst_6 : Module S M]
[inst_7 : SMulCommClass R S M],
LinearEquiv.piRing R M ι S =
(LinearMap.lsum R (fun x => R) S).... | true |
_private.Mathlib.RepresentationTheory.FiniteIndex.0.Rep.coindToInd_of_support_subset_orbit._simp_1_2 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | false |
LieModule.isNilpotent_of_top_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [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] [LieModule R L M],
LieModule.IsNilpotent (↥⊤) M = LieModule.IsNilpotent L M | false |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[inst_3 : CategoryTheory.BraidedCategory D] →
CategoryTheory.Functor.id (CategoryTheory.CommMon (Category... | true |
«_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_→ₗ⁅_⁆__1» | Mathlib.Algebra.Lie.Basic | Lean.Macro | false |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.tryTheoremCore.match_1 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
(Unit → motive none) → ((r : Lean.Meta.Simp.Result) → motive (some r)) → motive __do_lift | false |
SymmetricPower.«_aux_Mathlib_LinearAlgebra_TensorPower_Symmetric___delab_app_SymmetricPower_term⨂ₛ[_]_,__1» | Mathlib.LinearAlgebra.TensorPower.Symmetric | Lean.PrettyPrinter.Delaborator.Delab | false |
CategoryTheory.Sieve.giGenerate._proof_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x : CategoryTheory.Sieve X) (x_1 : C)
(x_2 : x_1 ⟶ X), x.arrows x_2 → ∃ Y h g, x.arrows g ∧ CategoryTheory.CategoryStruct.comp h g = x_2 | false |
GromovHausdorff.auxGluing._proof_5 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ (X : ℕ → Type) [inst : (n : ℕ) → MetricSpace (X n)] [inst_1 : ∀ (n : ℕ), CompactSpace (X n)]
[inst_2 : ∀ (n : ℕ), Nonempty (X n)] (n : ℕ) (Y : GromovHausdorff.AuxGluingStruct (X n)),
Isometry (Metric.toGlueR ⋯ ⋯ ∘ GromovHausdorff.optimalGHInjr (X n) (X (n + 1))) | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.maxView._proof_8 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced →
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').s... | false |
Circle.exp_eq_exp | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {x y : ℝ}, Circle.exp x = Circle.exp y ↔ ∃ m, x = y + ↑m * (2 * Real.pi) | true |
NumberField.mixedEmbedding.fundamentalCone.idealSetEquiv._proof_4 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(J : ↥(nonZeroDivisors (Ideal (NumberField.RingOfIntegers K))))
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.idealSet K J)),
(fun a => ⟨NumberField.mixedEmbedding.fundamentalCone.idealSetMap K J a, ⋯⟩) x =
(fun a => ⟨NumberField.mixedEmbedd... | false |
CategoryTheory.isProjective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.ObjectProperty C | true |
_private.Mathlib.Algebra.Group.Fin.Basic.0.Fin.le_sub_one_iff._simp_1_1 | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, (a ≤ b) = (↑a ≤ ↑b) | false |
Valuation.ideal_isPrincipal | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {K : Type u_2} [inst_1 : Field K] (v : Valuation K Γ)
[IsCyclic ↥(MonoidWithZeroHom.valueGroup v)] [Nontrivial ↥(MonoidWithZeroHom.valueGroup v)]
(I : Ideal ↥v.valuationSubring), Submodule.IsPrincipal I | true |
Prod.instOrderTop | Mathlib.Order.BoundedOrder.Basic | (α : Type u) → (β : Type v) → [inst : LE α] → [inst_1 : LE β] → [OrderTop α] → [OrderTop β] → OrderTop (α × β) | true |
_private.Mathlib.Algebra.Category.Grp.EpiMono.0.GrpCat.SurjectiveOfEpiAuxs._aux_Mathlib_Algebra_Category_Grp_EpiMono___macroRules__private_Mathlib_Algebra_Category_Grp_EpiMono_0_GrpCat_SurjectiveOfEpiAuxs_termSX'_1 | Mathlib.Algebra.Category.Grp.EpiMono | Lean.Macro | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Convolution.0.MeasureTheory.hasFDerivAt_convolution_right_with_param._simp_1_9 | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
Equiv.swap_eq_refl_iff | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y : α}, Equiv.swap x y = Equiv.refl α ↔ x = y | true |
MulAction.block_stabilizerOrderIso.match_3 | Mathlib.GroupTheory.GroupAction.Blocks | (G : Type u_1) →
[inst : Group G] →
{X : Type u_2} →
[inst_1 : MulAction G X] →
(a : X) →
(motive : ↑(Set.Ici (MulAction.stabilizer G a)) → Sort u_3) →
(x : ↑(Set.Ici (MulAction.stabilizer G a))) →
((H : Subgroup G) → (hH : H ∈ Set.Ici (MulAction.stabilizer G a)) ... | false |
CategoryTheory.Functor.PushoutObjObj.ofHasPushout_ι | 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₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₂ Y₂ : C₂} {f₂ : X₂ ⟶ Y₂}
[inst_3 :... | true |
Units.le_of_inv_mul_le_one | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ) {a : M}, ↑u⁻¹ * a ≤ 1 → a ≤ ↑u | true |
_private.Batteries.Data.MLList.Basic.0.MLList.MLListImpl.nil | Batteries.Data.MLList.Basic | {m : Type u → Type u} → {α : Type u} → MLList.MLListImpl✝ m α | true |
Mathlib.Tactic.Order.ToInt.toInt_sup_toInt_eq_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j k : Fin n),
max (Mathlib.Tactic.Order.ToInt.toInt val i) (Mathlib.Tactic.Order.ToInt.toInt val j) =
Mathlib.Tactic.Order.ToInt.toInt val k ↔
max (val i) (val j) = val k | true |
Lean.Compiler.LCNF.FindUsed.State.mk.sizeOf_spec | Lean.Compiler.LCNF.ReduceArity | ∀ (used : Lean.FVarIdHashSet), sizeOf { used := used } = 1 + sizeOf used | true |
Tropical.untrop_injective | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u}, Function.Injective Tropical.untrop | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.action_exchange | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {w x : D} {y z : C} (f : w ⟶ x) (g : y ⟶ z),
CategoryTheory.CategoryStruct.c... | true |
PartOrdEmb.Hom.noConfusion | Mathlib.Order.Category.PartOrdEmb | {P : Sort u_1} →
{X Y : PartOrdEmb} →
{t : X.Hom Y} →
{X' Y' : PartOrdEmb} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → PartOrdEmb.Hom.noConfusionType P t t' | false |
LinearMap.eq_adjoint_iff_basis_left | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace 𝕜 E] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : FiniteDimensional 𝕜 E] [inst_6 : FiniteDimensional 𝕜 F] {ι : Type u_5} (b : Module.Basis ι 𝕜 E)
(A : E... | true |
AlgebraicGeometry.Scheme.IdealSheafData.instIsPreimmersionSubschemeι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData), AlgebraicGeometry.IsPreimmersion I.subschemeι | true |
Unitization.instCStarAlgebra | Mathlib.Analysis.CStarAlgebra.Unitization | {A : Type u_3} → [NonUnitalCStarAlgebra A] → CStarAlgebra (Unitization ℂ A) | true |
CategoryTheory.Pretriangulated.id_hom₂ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(A : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id A).hom₂ = CategoryTheory.CategoryStruct.id A.obj₂ | true |
_private.Init.Data.Range.Polymorphic.UInt.0.USize.instLawfulHasSize._simp_2 | Init.Data.Range.Polymorphic.UInt | ∀ {a b : USize}, (a = b) = (a.toBitVec = b.toBitVec) | false |
PrimeSpectrum.BasicConstructibleSetData.map.eq_1 | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (φ : R →+* S)
(C : PrimeSpectrum.BasicConstructibleSetData R),
PrimeSpectrum.BasicConstructibleSetData.map φ C = { f := φ C.f, n := C.n, g := ⇑φ ∘ C.g } | true |
Lean.Meta.Match.Example.var.injEq | Lean.Meta.Match.Basic | ∀ (a a_1 : Lean.FVarId), (Lean.Meta.Match.Example.var a = Lean.Meta.Match.Example.var a_1) = (a = a_1) | true |
CategoryTheory.TransfiniteCompositionOfShape.iic._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : OrderBot J] (j : J), ⊥ ≤ j | false |
Std.Internal.UV.TCP.Socket.cancelAccept | Std.Internal.UV.TCP | Std.Internal.UV.TCP.Socket → IO Unit | true |
SimpleGraph.not_reachable_of_neighborSet_right_eq_empty | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, u ≠ v → G.neighborSet v = ∅ → ¬G.Reachable u v | true |
Matroid.IsRkFinite.indep_of_encard_le_eRk | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.IsRkFinite I → I.encard ≤ M.eRk I → M.Indep I | true |
LieAlgebra.rootSpaceWeightSpaceProductAux._proof_4 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_2) (L : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] (M : Type u_1) [inst_4 : AddCommGroup M]
[inst_5 : Module R M] [inst_6 : LieRingModule L M] [inst_7 : LieModule R L M] {χ₁ χ₂ χ₃ : ↥H → R} (hχ : χ₁ + χ₂ = χ₃)
... | false |
Ideal.instMulActionElemPrimesOver._proof_3 | Mathlib.NumberTheory.RamificationInertia.Galois | ∀ {A : Type u_2} {B : Type u_1} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {p : Ideal A}
{G : Type u_3} [inst_3 : Group G] [inst_4 : MulSemiringAction G B] [inst_5 : SMulCommClass G A B] (σ τ : G)
(Q : ↑(p.primesOver B)), (σ * τ) • Q = σ • τ • Q | false |
Lean.IR.EmitC.emitCtorScalarSize | Lean.Compiler.IR.EmitC | ℕ → ℕ → Lean.IR.EmitC.M Unit | true |
Mathlib.Meta.NormNum.isNat_lt_false | Mathlib.Tactic.NormNum.Ineq | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] {a b : α} {a' b' : ℕ},
Mathlib.Meta.NormNum.IsNat a a' → Mathlib.Meta.NormNum.IsNat b b' → b'.ble a' = true → ¬a < b | true |
WithZero.coe_zpow | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : One α] [inst_1 : Pow α ℤ] (a : α) (n : ℤ), ↑(a ^ n) = ↑a ^ n | true |
HasFDerivAt.tendsto_nhdsNE | Mathlib.Analysis.Calculus.FDeriv.Equiv | ∀ {𝕜 : 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 : E → F}
{f' : E →L[𝕜] F} {x : E},
HasFDerivAt f f' x → (∃ C, AntilipschitzWith C ⇑f') → Filter.Tendsto f ... | true |
Lean.Lsp.WorkspaceSymbolParams.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.WorkspaceSymbolParams} → t = t' → Lean.Lsp.WorkspaceSymbolParams.noConfusionType P t t' | false |
AlgebraicGeometry.localRingHom_comp_stalkIso | Mathlib.AlgebraicGeometry.Spec | ∀ {R S : CommRingCat} (f : R ⟶ S) (p : PrimeSpectrum ↑S),
CategoryTheory.CategoryStruct.comp
(CommRingCat.ofHom
(AlgebraicGeometry.StructureSheaf.stalkIso (↑R)
(PrimeSpectrum.comap (CommRingCat.Hom.hom f) p)).symm.toRingEquiv.toRingHom)
(CategoryTheory.CategoryStruct.comp
(... | true |
_private.Mathlib.CategoryTheory.Preadditive.CommGrp_.0.CategoryTheory.Preadditive.instGrpObj._simp_3 | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X : C),
CategoryTheory.SemiCartesianMonoidalCategory.fst X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom | false |
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | { obj := fun P => GrpCat.of ↑P.toProfinite.toTop,
map := fun {X Y} f => GrpCat.ofHom (ProfiniteGrp.Hom.hom f).toMonoidHom,
map_id :=
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteGrpCatMonoidHomCarrier._proof_1,
map_comp :=
@Prof... | false |
Lean.Elab.Term.LValResolution.const.elim | Lean.Elab.App | {motive : Lean.Elab.Term.LValResolution → Sort u} →
(t : Lean.Elab.Term.LValResolution) →
t.ctorIdx = 2 →
((baseStructName structName constName : Lean.Name) →
motive (Lean.Elab.Term.LValResolution.const baseStructName structName constName)) →
motive t | false |
Nat.log2 | Init.Data.Nat.Log2 | ℕ → ℕ | true |
MeasureTheory.OuterMeasure.instPartialOrder._proof_2 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} (x : MeasureTheory.OuterMeasure α) (x_1 : Set α), x x_1 ≤ x x_1 | false |
Set.biInter_finsetSigma' | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : Type u_3} (s : Finset ι) (t : (i : ι) → Finset (α i))
(f : (i : ι) → α i → Set β), ⋂ i ∈ s, ⋂ j ∈ t i, f i j = ⋂ ij ∈ s.sigma t, f ij.fst ij.snd | true |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic.0.MeasureTheory.charFun_prod._simp_1_3 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] [MeasureTheory.SFinite μ] {L : Type u_5} [inst_4 : RCLike L]
(f : α → L) (g : β → L), (∫ (x : α), f x ∂μ) * ∫ (y : β), g y ∂ν = ∫ (z : α × β),... | false |
MeasurableSet.inf_eq_inter | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s t : { s // MeasurableSet s }), s ⊓ t = s ∩ t | true |
essSup_eq_iSup | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : CompleteLattice β],
(∀ (a : α), μ {a} ≠ 0) → ∀ (f : α → β), essSup f μ = ⨆ i, f i | true |
_private.Mathlib.Analysis.Meromorphic.Order.0.meromorphicOrderAt_eq_top_iff._simp_1_4 | Mathlib.Analysis.Meromorphic.Order | ∀ {n : ℕ∞} {α : Type u_1} {f : ℕ → α}, (ENat.map f n = ⊤) = (n = ⊤) | false |
multiplicity_addValuation._proof_2 | Mathlib.RingTheory.Valuation.PrimeMultiplicity | ∀ {R : Type u_1} [inst : CommRing R] {p : R}, Prime p → emultiplicity p 1 = 0 | false |
HahnEmbedding.ArchimedeanStrata.isInternal_stratum' | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] (u : HahnEmbedding.ArchimedeanStrata K M),
Di... | true |
CategoryTheory.GrothendieckTopology.mem_toCoverage_iff | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {S : CategoryTheory.Presieve X}
(J : CategoryTheory.GrothendieckTopology C), S ∈ J.toCoverage.coverings X ↔ CategoryTheory.Sieve.generate S ∈ J X | true |
_private.Mathlib.Geometry.Euclidean.Triangle.0.InnerProductGeometry.sin_angle_eq_sin_angle_add_add_angle_add | Mathlib.Geometry.Euclidean.Triangle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
x ≠ 0 →
y ≠ 0 →
Real.sin (InnerProductGeometry.angle x y) =
Real.sin (InnerProductGeometry.angle x (x + y) + InnerProductGeometry.angle y (y + x)) | true |
Std.DHashMap.Internal.AssocList.getKey_eq | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : Std.DHashMap.Internal.AssocList α β} {a : α}
{h : Std.DHashMap.Internal.AssocList.contains a l = true},
Std.DHashMap.Internal.AssocList.getKey a l h = Std.Internal.List.getKey a l.toList ⋯ | true |
_private.Mathlib.Analysis.SpecificLimits.Fibonacci.0.tendsto_fib_succ_div_fib_atTop._simp_1_6 | Mathlib.Analysis.SpecificLimits.Fibonacci | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
CategoryTheory.GrothendieckTopology.liftToDiagramLimitObj._proof_1 | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{D : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
{X : C} {K : Ty... | false |
ENNReal.measurable_of_tendsto | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : ℕ → α → ENNReal} {g : α → ENNReal},
(∀ (i : ℕ), Measurable (f i)) → Filter.Tendsto f Filter.atTop (nhds g) → Measurable g | true |
SSet.stdSimplex.objEquiv_symm_comp | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n n' : SimplexCategory} {m : SimplexCategoryᵒᵖ} (f : Opposite.unop m ⟶ n) (g : n ⟶ n'),
SSet.stdSimplex.objEquiv.symm (CategoryTheory.CategoryStruct.comp f g) =
(SSet.stdSimplex.map g).app m (SSet.stdSimplex.objEquiv.symm f) | true |
Quot.map₂._proof_2 | Mathlib.Data.Quot | ∀ {α : Sort u_3} {β : Sort u_2} {γ : Sort u_1} {r : α → α → Prop} {t : γ → γ → Prop} (f : α → β → γ),
(∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → t (f a₁ b) (f a₂ b)) →
∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → Quot.mk t (f a₁ b) = Quot.mk t (f a₂ b) | false |
CategoryTheory.constant_of_preserves_morphisms' | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.IsConnected J] {α : Type u₂} (F : J → α),
(∀ (j₁ j₂ : J) (x : j₁ ⟶ j₂), F j₁ = F j₂) → ∃ a, ∀ (j : J), F j = a | true |
Std.HashSet.get?_union_of_not_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
k ∉ m₂ → (m₁ ∪ m₂).get? k = m₁.get? k | true |
Manifold._aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termMDiffAt___1 | Mathlib.Geometry.Manifold.Notation | Lean.Elab.Term.TermElab | false |
IsCyclic.card_mulAut | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ (G : Type u_2) [inst : Group G] [Finite G] [h : IsCyclic G], Nat.card (MulAut G) = (Nat.card G).totient | true |
_private.Std.Tactic.BVDecide.Normalize.BitVec.0.Std.Tactic.BVDecide.Normalize.BitVec.le_ult._simp_1_1 | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {n : ℕ} {x y : BitVec n}, (x ≤ y) = (x.toNat ≤ y.toNat) | false |
Module.Presentation.CokernelData.mk.noConfusion | Mathlib.Algebra.Module.Presentation.Cokernel | {A : Type u} →
{inst : Ring A} →
{M₁ : Type v₁} →
{M₂ : Type v₂} →
{inst_1 : AddCommGroup M₁} →
{inst_2 : Module A M₁} →
{inst_3 : AddCommGroup M₂} →
{inst_4 : Module A M₂} →
{pres₂ : Module.Presentation A M₂} →
{f : M₁ →ₗ[A] M₂} ... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.