name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Module.Finite.instLinearMapIdSubtypeMemSubmoduleOfIsSemisimpleModule | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m : Submodule R M}
(R₀ : Type u_6) (P : Type u_7) [inst_3 : Semiring R₀] [inst_4 : AddCommMonoid P] [inst_5 : Module R P]
[inst_6 : Module R₀ P] [inst_7 : SMulCommClass R R₀ P] [Module.Finite R₀ (M →ₗ[R] P)] [IsSemisimpleModule R M],
Module.Finite R₀ (↥m →ₗ[R] P) | true |
CategoryTheory.obj_η_app_assoc | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C)) (n : M)
(X : C) [inst_3 : F.Monoidal] {Z : C}
(h : (F.obj n).obj ((CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C C)).obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((F.obj n).map ((CategoryTheory.Functor.OplaxMonoidal.η F).app X)) h =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.LaxMonoidal.μ F (CategoryTheory.MonoidalCategoryStruct.tensorUnit M) n).app X)
(CategoryTheory.CategoryStruct.comp ((F.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor n).hom).app X) h) | true |
WeierstrassCurve.Jacobian.Point.neg_point | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (P : W.Point), (-P).point = W.negMap P.point | true |
Std.ExtHashSet.size_left_le_size_union | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m₁.size ≤ (m₁ ∪ m₂).size | true |
CategoryTheory.FreeMonoidalCategory.normalizeIsoApp' | Mathlib.CategoryTheory.Monoidal.Free.Coherence | (C : Type u) →
(X : CategoryTheory.FreeMonoidalCategory C) →
(n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.FreeMonoidalCategory.inclusionObj n) X ≅
CategoryTheory.FreeMonoidalCategory.inclusionObj (X.normalizeObj n) | true |
FinEnum.Subtype.finEnum._proof_1 | Mathlib.Data.FinEnum | ∀ {α : Type u_1} [inst : FinEnum α] (p : α → Prop) [inst_1 : DecidablePred p] (x : { x // p x }),
x ∈ List.filterMap (fun x => if h : p x then some ⟨x, h⟩ else none) (FinEnum.toList α) | false |
Finset.smul_finset_neg | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : AddGroup β]
[inst_3 : DistribMulAction α β] (a : α) (t : Finset β), a • -t = -(a • t) | true |
Nat.clog_mono | Mathlib.Data.Nat.Log | ∀ {b c m n : ℕ}, 1 < c → c ≤ b → m ≤ n → Nat.clog b m ≤ Nat.clog c n | true |
CategoryTheory.Limits.IsColimit.whiskerEquivalenceEquiv._proof_2 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} J] {K : Type u_4}
[inst_1 : CategoryTheory.Category.{u_6, u_4} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_3, u_2} C]
{F : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cocone F} (e : K ≌ J),
Function.LeftInverse (CategoryTheory.Limits.IsColimit.ofWhiskerEquivalence e) fun h => h.whiskerEquivalence e | false |
LinearPMap.apply_comp_inclusion | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {T S : E →ₗ.[R] F} (h : T ≤ S) (x : ↥T.domain),
↑T x = ↑S ((Submodule.inclusion ⋯) x) | true |
AlgebraicGeometry.RingedSpace.zeroLocus_singleton | Mathlib.Geometry.RingedSpace.Basic | ∀ (X : AlgebraicGeometry.RingedSpace) {U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace}
(f : ↑(X.presheaf.obj (Opposite.op U))), X.zeroLocus {f} = (X.basicOpen f).carrierᶜ | true |
CategoryTheory.InjectiveResolution.descFSucc._proof_2 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Z : C}
(J : CategoryTheory.InjectiveResolution Z) (n : ℕ),
CategoryTheory.CategoryStruct.comp (J.cocomplex.d n (n + 1)) (J.cocomplex.d (n + 1) (n + 2)) = 0 | false |
Lean.Parser.Syntax.nonReserved.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_160 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
ValueDistribution.proximity_pow_zero | Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic | ∀ {f : ℂ → ℂ} {n : ℕ}, ValueDistribution.proximity (f ^ n) 0 = n • ValueDistribution.proximity f 0 | true |
Mathlib.Meta.Positivity.nonneg_of_isNat' | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n : ℕ} [inst : AddMonoidWithOne A] [inst_1 : PartialOrder A] [AddLeftMono A]
[ZeroLEOneClass A], Mathlib.Meta.NormNum.IsNat e n → 0 ≤ e | true |
Lean.Meta.ExprParamInfo.mk.noConfusion | Lean.Meta.Basic | {P : Sort u} →
{name : Lean.Name} →
{type : Lean.Expr} →
{binderInfo : Lean.BinderInfo} →
{name' : Lean.Name} →
{type' : Lean.Expr} →
{binderInfo' : Lean.BinderInfo} →
{ name := name, type := type, binderInfo := binderInfo } =
{ name := name', type := type', binderInfo := binderInfo' } →
(name = name' → type = type' → binderInfo = binderInfo' → P) → P | false |
Lean.Linter.MissingDocs.Handler | Lean.Linter.MissingDocs | Type | true |
_private.Mathlib.Order.KrullDimension.0.Order.krullDim_lt_coe_iff._simp_1_2 | Mathlib.Order.KrullDimension | ∀ {n : WithBot ℕ∞} {m : ℕ}, (n < ↑m + 1) = (n ≤ ↑m) | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.cmdCodeActionProvider._sparseCasesOn_2 | Lean.Server.CodeActions.Provider | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.CommandInfo) → motive (Lean.Elab.Info.ofCommandInfo i)) →
(Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | false |
Lean.Meta.Simp.ConfigCtx.arith._inherited_default | Init.MetaTypes | Bool | false |
IsLocalDiffeomorphAt.localInverse_eqOn_left | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : 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] {H : Type u_4}
[inst_5 : TopologicalSpace H] {G : Type u_5} [inst_6 : TopologicalSpace G] {I : ModelWithCorners 𝕜 E H}
{J : ModelWithCorners 𝕜 F G} {M : Type u_6} [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace H M] {N : Type u_7}
[inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace G N] {n : WithTop ℕ∞} {f : M → N} {x : M}
(hf : IsLocalDiffeomorphAt I J n f x), Set.EqOn (↑hf.localInverse.toPartialEquiv ∘ f) id hf.localInverse.target | true |
PseudoMetricSpace.replaceUniformity_eq | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_3} [U : UniformSpace α] (m : PseudoMetricSpace α) (H : uniformity α = uniformity α),
m.replaceUniformity H = m | true |
Lean.Elab.Term.GeneralizeResult.altViews | Lean.Elab.Match | Lean.Elab.Term.GeneralizeResult → Array Lean.Elab.Term.TermMatchAltView | true |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.IsSelfAdjoint.sub._simp_1_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x = (star x = x) | false |
instCompactSpaceMultiplicative | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactSpace X], CompactSpace (Multiplicative X) | true |
CategoryTheory.EnrichedCat.comp_whiskerRight | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₁} [inst_3 : CategoryTheory.EnrichedCategory V D]
{E : Type u₂} [inst_4 : CategoryTheory.EnrichedCategory V E] {F G H : CategoryTheory.EnrichedFunctor V C D}
(α : F ⟶ G) (β : G ⟶ H) (I : CategoryTheory.EnrichedFunctor V D E),
CategoryTheory.EnrichedCat.whiskerRight { out := CategoryTheory.CategoryStruct.comp α.out β.out } I =
CategoryTheory.CategoryStruct.comp (CategoryTheory.EnrichedCat.whiskerRight α I)
(CategoryTheory.EnrichedCat.whiskerRight β I) | true |
AddMonoidHom.eqLocusM | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_1} →
{N : Type u_2} → [inst : AddZeroClass M] → [inst_1 : AddZeroClass N] → (M →+ N) → (M →+ N) → AddSubmonoid M | true |
Set.inter_sub_union_subset_union | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ∩ s₂ - (t₁ ∪ t₂) ⊆ s₁ - t₁ ∪ (s₂ - t₂) | true |
Path.Homotopic.Quotient.trans_assoc | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ x₂ x₃ : X} (γ₀ : Path.Homotopic.Quotient x₀ x₁)
(γ₁ : Path.Homotopic.Quotient x₁ x₂) (γ₂ : Path.Homotopic.Quotient x₂ x₃),
(γ₀.trans γ₁).trans γ₂ = γ₀.trans (γ₁.trans γ₂) | true |
RelIso.toRelEmbedding | Mathlib.Order.RelIso.Basic | {α : Type u_1} → {β : Type u_2} → {r : α → α → Prop} → {s : β → β → Prop} → r ≃r s → r ↪r s | true |
LawfulBitraversable.bitraverse_eq_bimap_id' | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} {inst : Bitraversable t} [self : LawfulBitraversable t] {α α' β β' : Type u}
(f : α → β) (f' : α' → β'), bitraverse (pure ∘ f) (pure ∘ f') = pure ∘ bimap f f' | true |
Array.size_filterMap_lt_size_iff_exists | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β},
(Array.filterMap f xs).size < xs.size ↔ ∃ x, ∃ (_ : x ∈ xs), f x = none | true |
Equiv.prodPEmpty | Mathlib.Logic.Equiv.Prod | (α : Type u_9) → α × PEmpty.{u_10 + 1} ≃ PEmpty.{u_11} | true |
Array.lt_size_left_of_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β → γ} {i : ℕ} {as : Array α} {bs : Array β},
i < (Array.zipWith f as bs).size → i < as.size | true |
_private.Init.Data.Vector.OfFn.0.Vector.map_ofFn._simp_1_1 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} {n : ℕ} {xs ys : Vector α n}, (xs = ys) = (xs.toArray = ys.toArray) | false |
Std.DTreeMap.Internal.Impl.get?_erase_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k : α}, (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.get? k = none | true |
IsPicardLindelof.exists_forall_mem_closedBall_eq_hasDerivWithinAt_lipschitzOnWith | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E → E}
{tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {a r L K : NNReal},
IsPicardLindelof f t₀ x₀ a r L K →
∃ α,
(∀ x ∈ Metric.closedBall x₀ ↑r,
α x ↑t₀ = x ∧ ∀ t ∈ Set.Icc tmin tmax, HasDerivWithinAt (α x) (f t (α x t)) (Set.Icc tmin tmax) t) ∧
∃ L', ∀ t ∈ Set.Icc tmin tmax, LipschitzOnWith L' (fun x => α x t) (Metric.closedBall x₀ ↑r) | true |
Ordnode.rec.eq._@.Mathlib.Data.Ordmap.Ordnode.1389437611._hygCtx._hyg.4 | Mathlib.Data.Ordmap.Ordnode | @Ordnode.rec = @Ordnode.rec✝ | false |
_private.Mathlib.LinearAlgebra.Complex.Module.0.mem_unitary_iff_isStarNormal_and_realPart_sq_add_imaginaryPart_sq_eq_one._simp_1_5 | Mathlib.LinearAlgebra.Complex.Module | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | false |
Array.reverse_pmap | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} {f : (a : α) → P a → β} {xs : Array α} (H : ∀ a ∈ xs, P a),
(Array.pmap f xs H).reverse = Array.pmap f xs.reverse ⋯ | true |
_private.Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv.0.coe_auxContinuousLinearEquiv | Mathlib.Analysis.Normed.Operator.ContinuousAlgEquiv | ∀ {𝕜 : Type u_1} {V : Type u_2} {W : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] [inst_4 : NormedAddCommGroup W]
[inst_5 : InnerProductSpace 𝕜 W] [inst_6 : CompleteSpace W] (e : V ≃L[𝕜] W) {α α' : 𝕜} (hα : α ≠ 0)
(hα2 : α' * α' = α⁻¹) (he : (ContinuousLinearMap.adjoint ↑e).comp ↑e = α • ContinuousLinearMap.id 𝕜 V)
(he' : (↑e).comp (ContinuousLinearMap.adjoint ↑e) = α • ContinuousLinearMap.id 𝕜 W),
↑(auxContinuousLinearEquiv✝ e hα hα2 he he') = α' • ↑e | true |
CategoryTheory.CartesianMonoidalCategory.prodComparisonNatTrans | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{D : Type u₁} →
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
(A : C) →
((CategoryTheory.MonoidalCategory.curriedTensor C).obj A).comp F ⟶
F.comp ((CategoryTheory.MonoidalCategory.curriedTensor D).obj (F.obj A)) | true |
AddCommGroup.toAddGroup | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : AddCommGroup G] → AddGroup G | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.Bicone.IsBilimit.ext.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_1} {C : Type u_3} {inst : CategoryTheory.Category.{u_2, u_3} C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {F : J → C} {B : CategoryTheory.Limits.Bicone F}
(motive : B.IsBilimit → Prop) (h : B.IsBilimit),
(∀ (isLimit : CategoryTheory.Limits.IsLimit B.toCone) (isColimit : CategoryTheory.Limits.IsColimit B.toCocone),
motive { isLimit := isLimit, isColimit := isColimit }) →
motive h | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.MutualClosure.mkInitialUsedFVarsMap.match_5 | Lean.Elab.MutualDef | (motive : MProd Lean.FVarIdSet Lean.CollectFVars.State → Sort u_1) →
(r : MProd Lean.FVarIdSet Lean.CollectFVars.State) →
((set : Lean.FVarIdSet) → (state : Lean.CollectFVars.State) → motive ⟨set, state⟩) → motive r | false |
Lean.JsonRpc.MessageKind._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.MessageKind → ℕ | false |
FiberBundle.extChartAt_target | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_4 : (x : B) → TopologicalSpace (E x)] {EB : Type u_7} [inst_5 : NormedAddCommGroup EB]
[inst_6 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_7 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB}
[inst_8 : TopologicalSpace B] [inst_9 : ChartedSpace HB B] [inst_10 : FiberBundle F E] (x : Bundle.TotalSpace F E),
(extChartAt (IB.prod (modelWithCornersSelf 𝕜 F)) x).target =
((extChartAt IB x.proj).target ∩ ↑(extChartAt IB x.proj).symm ⁻¹' (trivializationAt F E x.proj).baseSet) ×ˢ Set.univ | true |
Lean.Lsp.WaitForILeans | Lean.Data.Lsp.Extra | Type | true |
Real.commRing._proof_11 | Mathlib.Data.Real.Basic | ∀ (a b c : ℝ), a * b * c = a * (b * c) | false |
Filter.Eventually.prodMk_nhds | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {px : X → Prop} {x : X},
(∀ᶠ (x : X) in nhds x, px x) →
∀ {py : Y → Prop} {y : Y}, (∀ᶠ (y : Y) in nhds y, py y) → ∀ᶠ (p : X × Y) in nhds (x, y), px p.1 ∧ py p.2 | true |
Vector3.eq_nil | Mathlib.Data.Vector3 | ∀ {α : Type u_1} (v : Vector3 α 0), v = [] | true |
CategoryTheory.Limits.CreatesFiniteLimits.noConfusion | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{F : CategoryTheory.Functor C D} →
{t : CategoryTheory.Limits.CreatesFiniteLimits F} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{D' : Type u₂} →
{inst'_1 : CategoryTheory.Category.{v₂, u₂} D'} →
{F' : CategoryTheory.Functor C' D'} →
{t' : CategoryTheory.Limits.CreatesFiniteLimits F'} →
C = C' →
inst ≍ inst' →
D = D' →
inst_1 ≍ inst'_1 →
F ≍ F' → t ≍ t' → CategoryTheory.Limits.CreatesFiniteLimits.noConfusionType P t t' | false |
AlgebraicGeometry.Scheme.Cover.gluedCover_V | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (x : 𝒰.I₀ × 𝒰.I₀),
(AlgebraicGeometry.Scheme.Cover.gluedCover 𝒰).V x =
match x with
| (x, y) => CategoryTheory.Limits.pullback (𝒰.f x) (𝒰.f y) | true |
Std.ExtDTreeMap.contains_alter | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k k' : α} {f : Option (β k) → Option (β k)},
(t.alter k f).contains k' = if cmp k k' = Ordering.eq then (f (t.get? k)).isSome else t.contains k' | true |
IsPrimitiveRoot.disjoint | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] [inst_1 : IsDomain R] {k l : ℕ},
k ≠ l → Disjoint (primitiveRoots k R) (primitiveRoots l R) | true |
Subring.comap_iInf | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {ι : Sort u_1} (f : R →+* S)
(s : ι → Subring S), Subring.comap f (iInf s) = ⨅ i, Subring.comap f (s i) | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray._proof_1_25 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (acc : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (i : Std.Tactic.BVDecide.LRAT.Internal.PosFin n),
acc.size = n → ↑i < acc.size | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateContImp.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Code pu → Sort u_1) →
(c : Lean.Compiler.LCNF.Code pu) →
((decl : Lean.Compiler.LCNF.LetDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.Code.let decl k)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.Code.fun decl k h)) →
((decl : Lean.Compiler.LCNF.FunDecl pu) →
(k : Lean.Compiler.LCNF.Code pu) → motive (Lean.Compiler.LCNF.Code.jp decl k)) →
((fvarId : Lean.FVarId) →
(i offset : ℕ) →
(y : Lean.FVarId) →
(ty : Lean.Expr) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.Code.sset fvarId i offset y ty k h)) →
((fvarId : Lean.FVarId) →
(offset : ℕ) →
(y : Lean.FVarId) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.Code.uset fvarId offset y k h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check persistent : Bool) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.Code.inc fvarId n check persistent k h)) →
((fvarId : Lean.FVarId) →
(n : ℕ) →
(check persistent : Bool) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.Code.dec fvarId n check persistent k h)) →
((x : Lean.Compiler.LCNF.Code pu) → motive x) → motive c | false |
ContDiffMapSupportedIn.bounded_iteratedFDeriv | 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 : ContDiffMapSupportedIn E F n K) {i : ℕ},
↑i ≤ n → ∃ C, ∀ (x : E), ‖iteratedFDeriv ℝ i (⇑f) x‖ ≤ C | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_572 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
selfZPow_mul_neg | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (x : R) (B : Type u_2) [inst_1 : CommSemiring B] [inst_2 : Algebra R B]
[inst_3 : IsLocalization.Away x B] (d : ℤ), selfZPow x B d * selfZPow x B (-d) = 1 | true |
CochainComplex.mappingConeCompTriangle_mor₁ | Mathlib.Algebra.Homology.HomotopyCategory.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {X₁ X₂ X₃ : CochainComplex C ℤ} (f : X₁ ⟶ X₂) (g : X₂ ⟶ X₃),
(CochainComplex.mappingConeCompTriangle f g).mor₁ =
CochainComplex.mappingCone.map f (CategoryTheory.CategoryStruct.comp f g) (CategoryTheory.CategoryStruct.id X₁) g ⋯ | true |
_private.Mathlib.Order.Filter.AtTopBot.CountablyGenerated.0.Filter.tendsto_iff_seq_tendsto._simp_1_2 | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ {α : Type u} {f : Filter α} {s : Set α}, (f ⊓ Filter.principal s = ⊥) = (sᶜ ∈ f) | false |
groupCohomology.linearYonedaObjResProjectiveResolutionIso._proof_9 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Shapiro | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
(P : CategoryTheory.ProjectiveResolution (Rep.trivial k G k)) (A : Rep.{u_1, u_1, u_1} k ↥S) (x x_1 : ℕ),
(ComplexShape.up ℕ).Rel x x_1 →
CategoryTheory.CategoryStruct.comp
(Rep.resCoindHomEquiv.{u_1, u_1, u_1, u_1} S.subtype (P.complex.X x) A).toModuleIso.hom
((P.complex.linearYonedaObj k (Rep.coind.{u_1, u_1, u_1, u_1} S.subtype A)).d x x_1) =
CategoryTheory.CategoryStruct.comp
((((Rep.resFunctor S.subtype).mapProjectiveResolution P).complex.linearYonedaObj k A).d x x_1)
(Rep.resCoindHomEquiv.{u_1, u_1, u_1, u_1} S.subtype (P.complex.X x_1) A).toModuleIso.hom | false |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.tuple₁._sparseCasesOn_1 | Lean.Elab.Tactic.RCases | {motive_1 : Lean.Elab.Tactic.RCases.RCasesPatt → Sort u} →
(t : Lean.Elab.Tactic.RCases.RCasesPatt) →
((ref : Lean.Syntax) → (a : Lean.Name) → motive_1 (Lean.Elab.Tactic.RCases.RCasesPatt.one ref a)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | false |
_private.Batteries.Tactic.Lint.Misc.0.Batteries.Tactic.Lint.docBlame._sparseCasesOn_7 | Batteries.Tactic.Lint.Misc | {α : Type u} →
{motive : Option α → Sort u_1} → (t : Option α) → motive none → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Array.toListLitAux.eq_2 | Init.Data.Array.GetLit | ∀ {α : Type u_1} (xs : Array α) (n : ℕ) (hsz : xs.size = n) (x : List α) (i : ℕ) (hi : i + 1 ≤ xs.size),
xs.toListLitAux n hsz i.succ hi x = xs.toListLitAux n hsz i ⋯ (xs.getLit i hsz ⋯ :: x) | true |
CategoryTheory.MorphismProperty.LeftFraction₃.hs | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W : CategoryTheory.MorphismProperty C} {X Y : C}
(self : W.LeftFraction₃ X Y), W self.s | true |
_private.Mathlib.CategoryTheory.Sites.MorphismProperty.0.CategoryTheory.MorphismProperty.instIsStableUnderCompositionPrecoverageOfIsStableUnderComposition.match_1 | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type (max u_2 u_1)} (S : C) (X : ι → C)
(f : (i : ι) → X i ⟶ S) (σ : ι → Type (max u_2 u_1)) (Y : (i : ι) → σ i → C) (g : (i : ι) → (j : σ i) → Y i j ⟶ X i)
(motive :
(Z : C) →
(p : Z ⟶ S) →
CategoryTheory.Presieve.ofArrows (fun p => Y p.fst p.snd)
(fun x => CategoryTheory.CategoryStruct.comp (g x.fst x.snd) (f x.fst)) p →
Prop)
(Z : C) (p : Z ⟶ S)
(h :
CategoryTheory.Presieve.ofArrows (fun p => Y p.fst p.snd)
(fun x => CategoryTheory.CategoryStruct.comp (g x.fst x.snd) (f x.fst)) p),
(∀ (i : (i : ι) × σ i),
motive ((fun p => Y p.fst p.snd) i) (CategoryTheory.CategoryStruct.comp (g i.fst i.snd) (f i.fst)) ⋯) →
motive Z p h | false |
ContinuousMap.noConfusionType | Mathlib.Topology.ContinuousMap.Defs | Sort u →
{X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
C(X, Y) →
{X' : Type u_1} →
{Y' : Type u_2} → [inst' : TopologicalSpace X'] → [inst'_1 : TopologicalSpace Y'] → C(X', Y') → Sort u | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.sortVars | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | Lean.Meta.Grind.GoalM (Array Int.Linear.Var) | true |
IsStarNormal.one_sub | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : StarRing R] {a : R} [ha : IsStarNormal a], IsStarNormal (1 - a) | true |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift._proof_4 | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
{S : CategoryTheory.Sieve X} {E : J.OneHypercover X},
E.sieve₀ ≤ S → ∀ (x : E.multicospanShape.R), S.arrows (E.f (E.multicospanShape.snd x)) | false |
Std.TreeMap.Raw.not_mem_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → k ∉ t₁ \ t₂ | true |
_private.Mathlib.Analysis.RCLike.Sqrt.0.RCLike.sqrt_eq_ite._proof_1_2 | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], ¬RCLike.im RCLike.I = 1 → RCLike.I = 0 | false |
nnnorm_add_eq_nnnorm_right | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {x : E} (y : E), ‖x‖₊ = 0 → ‖x + y‖₊ = ‖y‖₊ | true |
PresheafOfModules.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Presheaf | Sort u_1 →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
PresheafOfModules R →
{C' : Type u₁} →
[inst' : CategoryTheory.Category.{v₁, u₁} C'] →
{R' : CategoryTheory.Functor C'ᵒᵖ RingCat} → PresheafOfModules R' → Sort u_1 | false |
Batteries.AssocList.findEntryP?.eq_1 | Batteries.Data.AssocList | ∀ {α : Type u_1} {β : Type u_2} (p : α → β → Bool), Batteries.AssocList.findEntryP? p Batteries.AssocList.nil = none | true |
instOneNonemptyInterval | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : Preorder α] → [One α] → One (NonemptyInterval α) | true |
MeasureTheory.integral_comp_mul_right_Ioi | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (g : ℝ → E) (a : ℝ) {b : ℝ},
0 < b → ∫ (x : ℝ) in Set.Ioi a, g (x * b) = b⁻¹ • ∫ (x : ℝ) in Set.Ioi (a * b), g x | true |
Units.chartAt_source | Mathlib.Geometry.Manifold.Instances.UnitsOfNormedAlgebra | ∀ {R : Type u_1} [inst : NormedRing R] [inst_1 : CompleteSpace R] {a : Rˣ}, (chartAt R a).source = Set.univ | true |
Module.DualBases.basis | Mathlib.LinearAlgebra.Dual.Basis | {R : Type u_1} →
{M : Type u_2} →
{ι : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → {e : ι → M} → {ε : ι → Module.Dual R M} → Module.DualBases e ε → Module.Basis ι R M | true |
CategoryTheory.Limits.cokernel.mapIso | Mathlib.CategoryTheory.Limits.Shapes.Kernels | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_2 : CategoryTheory.Limits.HasCokernel f] →
{X' Y' : C} →
(f' : X' ⟶ Y') →
[inst_3 : CategoryTheory.Limits.HasCokernel f'] →
(p : X ≅ X') →
(q : Y ≅ Y') →
CategoryTheory.CategoryStruct.comp f q.hom = CategoryTheory.CategoryStruct.comp p.hom f' →
(CategoryTheory.Limits.cokernel f ≅ CategoryTheory.Limits.cokernel f') | true |
instFiniteSym | Mathlib.Data.Finite.Vector | ∀ {α : Type u_1} [Finite α] {n : ℕ}, Finite (Sym α n) | true |
AlgebraicGeometry.Scheme.Hom.asFiberHom_fiberι_assoc | Mathlib.AlgebraicGeometry.Fiber | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (x : ↥X) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.asFiberHom f x)
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.fiberι f (f x)) h) =
CategoryTheory.CategoryStruct.comp (X.fromSpecResidueField x) h | true |
CategoryTheory.Limits.Cocone.extendComp | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(s : CategoryTheory.Limits.Cocone F) →
{X Y : C} →
(g : s.pt ⟶ Y) → (f : Y ⟶ X) → s.extend (CategoryTheory.CategoryStruct.comp g f) ≅ (s.extend g).extend f | true |
Topology.CWComplex.noConfusion | Mathlib.Topology.CWComplex.Classical.Basic | {P : Sort u_1} →
{X : Type u} →
{inst : TopologicalSpace X} →
{C : Set X} →
{t : Topology.CWComplex C} →
{X' : Type u} →
{inst' : TopologicalSpace X'} →
{C' : Set X'} →
{t' : Topology.CWComplex C'} →
X = X' → inst ≍ inst' → C ≍ C' → t ≍ t' → Topology.CWComplex.noConfusionType P t t' | false |
AddCon.eq | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) {a b : M}, ↑a = ↑b ↔ c a b | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertListIfNew.eq_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l : List ((a : α) × β a)) (k : α) (v : β k)
(l_1 : List ((a : α) × β a)),
Std.Internal.List.insertListIfNew l (⟨k, v⟩ :: l_1) =
Std.Internal.List.insertListIfNew (Std.Internal.List.insertEntryIfNew k v l) l_1 | true |
HomologicalComplex.isoHomologyι_hom_inv_id_assoc | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι) (hj : c.next i = j) (h : K.d i j = 0)
[inst_2 : K.HasHomology i] {Z : C} (h_1 : K.homology i ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.homologyι i)
(CategoryTheory.CategoryStruct.comp (K.isoHomologyι i j hj h).inv h_1) =
h_1 | true |
Units.liftRight.congr_simp | Mathlib.RingTheory.Localization.Away.Basic | ∀ {M : Type u} {N : Type v} [inst : Monoid M] [inst_1 : Monoid N] (f f_1 : M →* N) (e_f : f = f_1) (g g_1 : M → Nˣ)
(e_g : g = g_1) (h : ∀ (x : M), ↑(g x) = f x), Units.liftRight f g h = Units.liftRight f_1 g_1 ⋯ | true |
Lean.Elab.IncrementalState.initialSnap | Lean.Elab.Frontend | Lean.Elab.IncrementalState → Lean.Language.Lean.CommandParsedSnapshot | true |
AddAction.mem_orbit_symm | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {a₁ a₂ : α},
a₁ ∈ AddAction.orbit G a₂ ↔ a₂ ∈ AddAction.orbit G a₁ | true |
coe_convexAddSubmonoid | Mathlib.Analysis.Convex.Basic | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E], ↑(convexAddSubmonoid 𝕜 E) = {s | Convex 𝕜 s} | true |
_private.Mathlib.Data.Set.Restrict.0.Set.injective_codRestrict._simp_1_1 | Mathlib.Data.Set.Restrict | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
ULift.seminormedCommRing._proof_6 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (a b c : ULift.{u_1, u_2} α), a * b * c = a * (b * c) | false |
Nat.Linear.ExprCnstr.denote | Init.Data.Nat.Linear | Nat.Linear.Context → Nat.Linear.ExprCnstr → Prop | true |
CategoryTheory.Abelian.SpectralObject.Hom.casesOn | Mathlib.Algebra.Homology.SpectralObject.Basic | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{u_3, u_1} C] →
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
{X X' : CategoryTheory.Abelian.SpectralObject C ι} →
{motive : X.Hom X' → Sort u} →
(t : X.Hom X') →
((hom : (n : ℤ) → X.H n ⟶ X'.H n) →
(comm :
∀ (n₀ n₁ : ℤ) (hn₁ : n₀ + 1 = n₁) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k),
CategoryTheory.CategoryStruct.comp (X.δ f g n₀ n₁ hn₁)
((hom n₁).app (CategoryTheory.ComposableArrows.mk₁ f)) =
CategoryTheory.CategoryStruct.comp ((hom n₀).app (CategoryTheory.ComposableArrows.mk₁ g))
(X'.δ f g n₀ n₁ hn₁)) →
motive { hom := hom, comm := comm }) →
motive t | false |
Int.clog_zero_left | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] (r : R), Int.clog 0 r = 0 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.