name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.PartialFixpointType._sizeOf_1 | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType → ℕ | null | false |
AlgebraicGeometry.Scheme.Hom.range_fiberι | Mathlib.AlgebraicGeometry.Fiber | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (y : ↥Y),
Set.range ⇑(AlgebraicGeometry.Scheme.Hom.fiberι f y) = ⇑f ⁻¹' {y} | null | true |
CategoryTheory.PreZeroHypercoverFamily.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Hypercover.ZeroFamily | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(property : ⦃X : C⦄ → CategoryTheory.ObjectProperty (CategoryTheory.PreZeroHypercover X)) →
(∀ {X : C} {E : CategoryTheory.PreZeroHypercover X}, property E ↔ property E.shrink) →
CategoryTheory.PreZeroHypercoverFamily C | null | false |
Std.TreeSet.Raw.getD_max? | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {km fallback : α}, t.max? = some km → t.getD km fallback = km | null | true |
Equiv.normedField | Mathlib.Analysis.Normed.Field.TransferInstance | {α : Type u_1} → {β : Type u_2} → [NormedField β] → α ≃ β → NormedField α | Transfer a `NormedField` across an `Equiv` | true |
Lean.Meta.Grind.Arith.Linear.getOrderedAddInst | Lean.Meta.Tactic.Grind.Arith.Linear.Util | Lean.Meta.Grind.Arith.Linear.LinearM Lean.Expr | null | true |
_private.Lean.Data.Json.Printer.0.Lean.Json.escapeAux | Lean.Data.Json.Printer | String → Char → String | null | true |
_private.Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots.0.instFieldAdjoinPthRoots._aux_36 | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | (k : Type u_1) → [Field k] → ZSMul (AdjoinPthRoots k) | null | false |
TopCat.GlueData.isOpen_iff | Mathlib.Topology.Gluing | ∀ (D : TopCat.GlueData) (U : Set ↑D.glued),
IsOpen U ↔ ∀ (i : D.J), IsOpen (⇑(CategoryTheory.ConcreteCategory.hom (D.ι i)) ⁻¹' U) | null | true |
List.dedup_eq_cons | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α) (a : α) (l' : List α),
l.dedup = a :: l' ↔ a ∈ l ∧ a ∉ l' ∧ l.dedup.tail = l' | null | true |
_private.Mathlib.Data.Rat.Lemmas.0.Rat.isSquare_iff._simp_1_1 | Mathlib.Data.Rat.Lemmas | ∀ {α : Type u_2} [inst : Mul α] (r : α), IsSquare (r * r) = True | null | false |
Relation.cutExpand_zero | Mathlib.Logic.Hydra | ∀ {α : Type u_1} {r : α → α → Prop} {x : α}, Relation.CutExpand r 0 {x} | null | true |
Sum.nonemptyLeft | Init.Core | ∀ {α : Type u} {β : Type v} [h : Nonempty α], Nonempty (α ⊕ β) | null | true |
UniqueMDiffOn.uniqueMDiffOn_target_inter | Mathlib.Geometry.Manifold.MFDeriv.UniqueDifferential | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} [IsManifold I 1 M],
Uniqu... | If a set in a manifold has the unique derivative property, then its pullback by any extended
chart, in the vector space, also has the unique derivative property. | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insertMin.match_3._arg_pusher | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Sort u_3)
(α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → α_1 → Prop) (t : Std.DTreeMap.Internal.Impl α β)
(hr : t.Balanced)
(h_1 :
(hr :... | null | false |
TopCat.GlueData.MkCore.t'._proof_1 | Mathlib.Topology.Gluing | ∀ (h : TopCat.GlueData.MkCore) (i j k : h.J),
CategoryTheory.Limits.HasLimit (CategoryTheory.Limits.cospan (h.V i j).inclusion' (h.V i k).inclusion') | null | false |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.α_inv_hom | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{X Y Z : CategoryTheory.FreeMonoidalCategory C}, CategoryTheory.FreeMonoidalCategory.HomEquiv.below ⋯ | null | true |
Lean.Expr.ProdTree.prod.sizeOf_spec | Mathlib.Tactic.ProdAssoc | ∀ (fst snd : Lean.Expr.ProdTree) (lfst lsnd : Lean.Level),
sizeOf (fst.prod snd lfst lsnd) = 1 + sizeOf fst + sizeOf snd + sizeOf lfst + sizeOf lsnd | null | true |
Mathlib.Meta.FunProp.FunctionData.getFnConstName? | Mathlib.Tactic.FunProp.FunctionData | Mathlib.Meta.FunProp.FunctionData → Lean.MetaM (Option Lean.Name) | Is head function of `f` a constant?
If the head of `f` is a projection return the name of corresponding projection function. | true |
CategoryTheory.Comma.inv_right._simp_1 | Mathlib.CategoryTheory.Comma.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} B] {A : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {R : CategoryTheory.Functor B T}
{L : CategoryTheory.Functor A T} {X Y : CategoryTheory.Comma L R} (e : Y ⟶ X) [inst_3 : CategoryTheory.... | null | false |
CategoryTheory.Under.postCongr_hom_app_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : T} {F G : CategoryTheory.Functor T D} (e : F ≅ G) (X_1 : CategoryTheory.Under X),
((CategoryTheory.Under.postCongr e).hom.app X_1).right = e.hom.app X_1.right | null | true |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Markov.0.MeasureTheory.ae_eq_of_ae_le_of_lintegral_le._simp_1_2 | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
CategoryTheory.Endofunctor.Algebra.Hom.rec | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C C} →
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} →
{motive : A₀.Hom A₁ → Sort u_1} →
((f : A₀.a ⟶ A₁.a) →
(h : CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.Cate... | null | false |
Lean.Compiler.LCNF.Decl.ctorIdx | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → ℕ | null | false |
ProbabilityTheory.IndepFun.add_hasPDF | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {G : Type u_2} {mΩ : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω} [inst : AddGroup G]
{mG : MeasurableSpace G} [MeasurableAdd₂ G] [MeasurableNeg G] {μ : MeasureTheory.Measure G} [μ.IsAddLeftInvariant]
{X Y : Ω → G} [MeasureTheory.SFinite μ] [MeasureTheory.HasPDF X ℙ μ] [MeasureTheory.HasPDF Y ℙ... | null | true |
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_2 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1)) {X : C}
(x : F.obj X) {X_1 Y : (CategoryTheory.FunctorToTypes.fromOverFunctor F x).Elements} (f : X_1 ⟶ Y),
↑((CategoryTheory.ConcreteCategory.hom ((CategoryTheory.FunctorToTypes.fromOverFunctor F x).map f.hom))... | null | false |
Lean.Meta.DefEqContext.noConfusionType | Lean.Meta.Basic | Sort u → Lean.Meta.DefEqContext → Lean.Meta.DefEqContext → Sort u | null | false |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isEmbedding_singleton._simp_1_3 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
CochainComplex.mappingCone.desc._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | -1 + 1 = 0 | null | false |
MeasureTheory.eLpNorm_indicator_const' | Mathlib.MeasureTheory.Function.LpSeminorm.Indicator | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} {ε : Type u_6}
[inst : TopologicalSpace ε] [inst_1 : ESeminormedAddMonoid ε] {c : ε} {s : Set α},
MeasureTheory.NullMeasurableSet s μ →
μ s ≠ 0 → p ≠ 0 → MeasureTheory.eLpNorm (s.indicator fun x => c) p μ = ‖c‖ₑ * μ s ^ (1 / p... | null | true |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.Iso.app._proof_3 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F G : CategoryTheory.Functor C D} (α : F ≅ G) (X : C),
CategoryTheory.CategoryStruct.comp (α.inv.app X) (α.hom.app X) = CategoryTheory.CategoryStruct.id (G.obj X) | null | false |
Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof.cancelDen.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_2 : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstrProof) →
t.ctorIdx = 1 →
((c : Lean.Meta.Grind.Arith.Linear.RingDiseqCnstr) →
(val : ℤ) →
(x n : Lean.Grind.Linarith.Var) →
motive_2 (Lean.Meta.Grind.A... | null | false |
CategoryTheory.Sheaf.H.map_apply | Mathlib.CategoryTheory.Sites.SheafCohomology.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : CategoryTheory.HasExt (CategoryTheory.Sheaf J AddCommGrpCat)] {F G : CategoryTheory.Sheaf J AddCommGrpCat}
(f : F ⟶ G) {n : ℕ} (x : F.H n),
(Catego... | null | true |
_private.Mathlib.RingTheory.Polynomial.IsIntegral.0.MvPolynomial.isIntegral_iff_isIntegral_coeff._proof_1_1 | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {S : Type u_2} [inst : CommRing S] {σ : Type u_1} {f : MvPolynomial σ S} (n : σ →₀ ℕ) (g : MvPolynomial (↥f.vars) S),
n ∉ Set.range (Finsupp.mapDomain Subtype.val) →
∀ (u : ↥f.vars →₀ ℕ), Finsupp.mapDomain Subtype.val u = n → g.coeff u = 0 | null | false |
_private.ImportGraph.Shake.EnvExtension.0.ImportGraph.Shake.List.prependWithoutDuplicating._sunfold | ImportGraph.Shake.EnvExtension | {α : Type u_1} → [BEq α] → List α → List α → List α | null | false |
CategoryTheory.Limits.hasPushout_ofHasPushoutsAgainst | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P P' : CategoryTheory.MorphismProperty C} {c c' c'' : C}
{f : c ⟶ c'} {g : c ⟶ c''} [P.HasPushoutsAgainst P'], P f → P' g → CategoryTheory.Limits.HasPushout f g | null | true |
Lean.Grind.AC.Seq.insert_k | Init.Grind.AC | Lean.Grind.AC.Var → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | null | true |
SingularManifold.instIsEmptyMEmpty | Mathlib.Geometry.Manifold.Bordism | ∀ {X : Type u_1} [inst : TopologicalSpace X] {k : WithTop ℕ∞} {E : Type u_4} {H : Type u_5} {M : Type u_6}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : FiniteDimensional ℝ E]
[inst_4 : TopologicalSpace H] {I : ModelWithCorners ℝ E H} [inst_5 : TopologicalSpace M] [inst_6 : ChartedSpace H M]
... | null | true |
Finsupp.llift._proof_3 | Mathlib.LinearAlgebra.Finsupp.LSum | ∀ (M : Type u_1) (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (X : Type u_2),
Function.LeftInverse (Finsupp.lift M R X).invFun (Finsupp.lift M R X).toFun | null | false |
LinearMap.IsNonneg.mk._flat_ctor | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{I₁ I₂ : R →+* R} [inst_3 : LE R] {B : M →ₛₗ[I₁] M →ₛₗ[I₂] R}, (∀ (x : M), 0 ≤ (B x) x) → B.IsNonneg | null | false |
Monoid.CoprodI.of_apply | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] {i : ι} (m : M i),
Monoid.CoprodI.of m = (conGen (Monoid.CoprodI.Rel M)).mk' (FreeMonoid.of ⟨i, m⟩) | null | true |
List.isChain_pair | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {R : α → α → Prop} {x y : α}, List.IsChain R [x, y] ↔ R x y | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.toCode | Lean.Compiler.LCNF.ToLCNF | Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.ToLCNF.M✝ (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) | Create `Code` that executes the current `seq` and then returns `result` | true |
Cardinal.add_lt_aleph0_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}}, a + b < Cardinal.aleph0 ↔ a < Cardinal.aleph0 ∧ b < Cardinal.aleph0 | null | true |
CategoryTheory.MonoidalCategory.IsPushout.inr_desc_whiskerRight | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {Z X Y P : C}
{f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P} (hP : CategoryTheory.IsPushout f g inl inr) {W : C} (h : X ⟶ W)
(k : Y ⟶ W) (w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStr... | null | true |
Prod.instAsymmLex_mathlib | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [Std.Asymm r] [Std.Asymm s],
Std.Asymm (Prod.Lex r s) | null | true |
EuclideanQuadrant.ext | Mathlib.Geometry.Manifold.Instances.Real | ∀ {n : ℕ} (x y : EuclideanQuadrant n), ↑x = ↑y → x = y | null | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasProd_fintype_support._simp_1_2 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
USize.toUInt16_div | Init.Data.UInt.Lemmas | ∀ (a b : USize), a < 65536 → b < 65536 → (a / b).toUInt16 = a.toUInt16 / b.toUInt16 | null | true |
CategoryTheory.Precoverage.toPretopology | Mathlib.CategoryTheory.Sites.Pretopology | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
(J : CategoryTheory.Precoverage C) →
[J.HasIsos] → [J.IsStableUnderBaseChange] → [J.IsStableUnderComposition] → CategoryTheory.Pretopology C | If `J` is a precoverage that has isomorphisms and is stable under composition and
base change, it defines a pretopology. | true |
finFunctionFinEquiv | Mathlib.Algebra.BigOperators.Fin | {m n : ℕ} → (Fin n → Fin m) ≃ Fin (m ^ n) | Equivalence between `Fin n → Fin m` and `Fin (m ^ n)`. | true |
Function.update_one | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : (i : I) → One (f i)] [inst_1 : DecidableEq I] (i : I), Function.update 1 i 1 = 1 | null | true |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.mk.injEq | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | ∀ {α : Type} (root : Std.HashMap Lean.Meta.RefinedDiscrTree.Key ℕ)
(tries : Array (Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α)))
(root_1 : Std.HashMap Lean.Meta.RefinedDiscrTree.Key ℕ)
(tries_1 : Array (Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α))),
({ root := root, tries := tries } = { root := root_1... | null | true |
continuousAddSubmonoid.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddZeroClass β]
[inst_3 : ContinuousAdd β],
continuousAddSubmonoid α β = { carrier := {f | Continuous f}, add_mem' := ⋯, zero_mem' := ⋯ } | null | true |
CategoryTheory.Functor.mapComposableArrowsObjMk₁Iso_hom_app | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (G : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
(i : Fin (1 + 1)),
(G.mapComposableArrowsObjMk₁Iso f).hom.app i =
match i with
| ⟨0, isLt⟩ => CategoryTheory.CategoryStruct.i... | null | true |
SFinKer.braiding_hom_hom | Mathlib.Probability.Kernel.Category.SFinKer | ∀ (X Y : SFinKer), (β_ X Y).hom.hom = ProbabilityTheory.Kernel.swap X.carrier Y.carrier | null | true |
Archimedean.mkRat_mem_ratLt | Mathlib.Basic.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [IsOrderedAddMonoid M] [inst_3 : One M] {num : ℤ}
{den : ℕ}, den ≠ 0 → ∀ {x : M}, mkRat num den ∈ Archimedean.ratLt x ↔ num • 1 < den • x | null | true |
LucasLehmer.order_ineq | Mathlib.NumberTheory.LucasLehmer | ∀ (p' : ℕ), lucasLehmerResidue (p' + 2) = 0 → 2 ^ (p' + 2) < ↑(LucasLehmer.q (p' + 2)) ^ 2 | null | true |
RootPairing.coroot'_reflection | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) {i j : ι} (y : M),
(P.coroot' j) ((P.reflection i) y) = (P.coroot' ((P.reflectionPerm i) j)) y | null | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.processFixedBufferedBody._unsafe_rec | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Machine dir → ℕ → Std.Http.Protocol.H1.Machine dir | null | false |
Ideal.inertiaDeg'_pos' | Mathlib.NumberTheory.RamificationInertia.Inertia | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R) (P : Ideal S)
[P.IsPrime] [Module.Finite R S] [P.LiesOver p], 0 < p.inertiaDeg' P | Variant with a weaker constraint, but on the prime upstairs instead. | true |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.QuickResult.ctorIdx | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | Lean.Meta.Grind.QuickResult✝ → ℕ | null | false |
IsAdicComplete.StrictMono.extend_eq | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_5} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {a : ℕ → ℕ} (ha : StrictMono a)
(f : (n : ℕ) → M →ₗ[R] N ⧸ I ^ a n • ⊤),
(∀ {m : ℕ}, Submodule.factorPow I N ⋯ ∘ₗ f (m + 1) = f m) →
... | null | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Basic.0.IsPrimitiveRoot.finite_quotient_toInteger_sub_one._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.instBicategory._proof_64 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
TopologicalSpace.Clopens.exists_prod_subset | Mathlib.Topology.ClopenBox | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [CompactSpace Y]
(W : TopologicalSpace.Clopens (X × Y)) {a : X × Y}, a ∈ W → ∃ U, a.1 ∈ U ∧ ∃ V, a.2 ∈ V ∧ U ×ˢ V ≤ W | null | true |
Num._sizeOf_inst | Mathlib.Data.Num.Basic | SizeOf Num | null | false |
CategoryTheory.Limits.pushoutIsoUnopPullback_inl_hom | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f g],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g)
(CategoryTheory.Limits.pushoutIsoUnopPullback f g).hom =
(CategoryTheory.Limits.pullba... | null | true |
NormedAddGroup.ofAddDist.eq_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_2} [inst : Norm E] [inst_1 : AddGroup E] [inst_2 : MetricSpace E] (h₁ : ∀ (x : E), ‖x‖ = dist 0 x)
(h₂ : ∀ (x y z : E), dist x y ≤ dist (z + x) (z + y)),
NormedAddGroup.ofAddDist h₁ h₂ =
{ toNorm := (SeminormedAddGroup.ofAddDist h₁ h₂).toNorm,
toAddGroup := (SeminormedAddGroup.ofAddDist h₁ h... | null | true |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_6 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
RootPairingCat.category._proof_3 | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | ∀ {R : Type u_2} [inst : CommRing R] {W X Y Z : RootPairingCat R} (f : W.pairing.Hom X.pairing)
(g : X.pairing.Hom Y.pairing) (h : Y.pairing.Hom Z.pairing), h.comp (g.comp f) = (h.comp g).comp f | null | false |
DenselyNormedField.sub._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_3} →
(zero : α) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
(∀ (x : α), 0 • x = 0) → (∀ (n : ℕ) (x : α), (n + 1) • x = n • x + x) → (α → α) → α → α → α | null | false |
Module.FaithfullyFlat.iff_zero_iff_rTensor_zero | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Module.FaithfullyFlat R M ↔
Module.Flat R M ∧
∀ {N : Type (max u v)} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {N' : Type (max u v)}
[inst_5 : AddCommGroup N'] [inst_6 : Module R N'] (f : N →ₗ[R] N... | An `R`-module `M` is faithfully flat iff it is flat and for all linear maps `f`, the map
`id ⊗ f = 0`, if and only if `f = 0`. | true |
Std.Async.System.instDecidableEqCPUTimes | Std.Async.System | DecidableEq Std.Async.System.CPUTimes | null | true |
Order.Ico_succ_right_eq_insert_of_not_isMax | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α},
a ≤ b → ¬IsMax b → Set.Ico a (Order.succ b) = insert b (Set.Ico a b) | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop.0.Std.IterM.step_drop.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop | ∀ (motive : ℕ → Sort u_1) (k : ℕ) (h_1 : k.succ = 0 → motive 0) (h_2 : (k_1 : ℕ) → k.succ = k_1.succ → motive k_1.succ),
(match h' : k.succ with
| 0 => h_1 h'
| k_1.succ => h_2 k_1 h') =
h_2 k ⋯ | null | true |
_private.Mathlib.Data.Nat.Totient.0.Nat.totient_eq_zero._simp_1_4 | Mathlib.Data.Nat.Totient | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {s : Finset α},
(Finset.filter p s = ∅) = ∀ ⦃x : α⦄, x ∈ s → ¬p x | null | false |
Asymptotics.IsLittleOTVS.trans_isBigOTVS | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} {G : Type u_6} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] [inst_7 : AddCommGroup G] [inst_8 : Topologi... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_396 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
CategoryTheory.IsPushout.zero_top | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.BicartesianSq | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.IsPushout 0 0 0 (CategoryTheory.CategoryStruct.id X) | The square with `0 : 0 ⟶ 0` on the top and `𝟙 X` on the bottom is a pushout square. | true |
_private.Mathlib.Data.List.Iterate.0.List.mem_iterate._simp_1_1 | Mathlib.Data.List.Iterate | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ l) = ∃ n, l.get n = a | null | false |
Lean.Grind.Order.le_eq_false_of_le_k | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [inst_3 : Std.IsPreorder α]
[inst_4 : Lean.Grind.Ring α] [Lean.Grind.OrderedRing α] {a b : α} {k₁ k₂ : ℤ},
(k₂ + k₁).blt' 0 = true → a ≤ b + ↑k₁ → (b ≤ a + ↑k₂) = False | null | true |
_private.Init.Data.List.Pairwise.0.List.nodup_iff_count._simp_1_3 | Init.Data.List.Pairwise | ∀ {n : ℕ}, (n < 1) = (n = 0) | null | false |
LowerSet.coe_ssubset_coe._simp_1 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s t : LowerSet α}, (↑s ⊂ ↑t) = (s < t) | null | false |
stdOrthonormalBasis_def | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ (𝕜 : Type u_7) [inst : RCLike 𝕜] (E : Type u_8) [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E],
stdOrthonormalBasis 𝕜 E =
have b := Classical.choose ⋯;
⋯.mpr (b.reindex (Fintype.equivFinOfCardEq ⋯)) | null | true |
AddMonoidHom.comap_ker | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] {P : Type u_7} [inst_2 : AddZeroClass P]
(g : N →+ P) (f : G →+ N), AddSubgroup.comap f g.ker = (g.comp f).ker | null | true |
_private.Mathlib.GroupTheory.SchurZassenhaus.0.Subgroup.SchurZassenhausInduction.step0 | Mathlib.GroupTheory.SchurZassenhaus | ∀ {G : Type u} [inst : Group G] {N : Subgroup G} [N.Normal],
(Nat.card ↥N).Coprime N.index → (∀ (H : Subgroup G), ¬N.IsComplement' H) → N ≠ ⊥ | Do not use this lemma: It is made obsolete by `exists_right_complement'_of_coprime` | true |
Std.DTreeMap.Internal.Impl.Const.get_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
[inst_1 : BEq α] [inst_2 : Std.LawfulBEqOrd α] (h : t.WF) {l : List (α × β)} {k : α}
(h₁ : (List.map Prod.fst l).contains k = false)
{h' : Std.DTreeMap.Internal.Impl.contains k ↑(Std.DTreeMap.Intern... | null | true |
BoundedContinuousFunction.measurable_coe_ennreal_comp | Mathlib.MeasureTheory.Integral.BoundedContinuousFunction | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] [OpensMeasurableSpace X]
(f : BoundedContinuousFunction X NNReal), Measurable fun x => ↑(f x) | null | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.emphLike.noSpaceBefore | Lean.DocString.Parser | Char → Lean.Parser.ParserContext → Lean.Parser.ParserState → Lean.Parser.ParserState | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal.0.SSet.Truncated.StrictSegal.spineToSimplex_vertex._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ}, 0 ≤ n + 1 | null | false |
MeasurableSpace.invariants | Mathlib.MeasureTheory.MeasurableSpace.Invariants | {α : Type u_1} → [m : MeasurableSpace α] → (α → α) → MeasurableSpace α | Given a self-map `f : α → α`,
`invariants f` is the σ-algebra of measurable sets that are invariant under `f`.
A set `s` is `(invariants f)`-measurable
iff it is measurable w.r.t. the canonical σ-algebra on `α` and `f ⁻¹' s = s`. | true |
HasQuotient.mk.noConfusion | Mathlib.Algebra.Quotient | {A : outParam (Type u)} →
{B : Type v} →
{P : Sort u_1} →
{Quotient Quotient' : B → Type (max u v)} →
{ Quotient := Quotient } = { Quotient := Quotient' } → (Quotient ≍ Quotient' → P) → P | null | false |
CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_20 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₀ n₁ n₂ : ℤ), 1 < 3 + 1 | null | false |
instDecidableEqZNum.decEq | Mathlib.Data.Num.Basic | (x x_1 : ZNum) → Decidable (x = x_1) | null | true |
_private.Mathlib.Analysis.InnerProductSpace.PiL2.0.DirectSum.IsInternal.subordinateOrthonormalBasisIndexFiberEquiv | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_1} →
{𝕜 : Type u_3} →
[inst : RCLike 𝕜] →
{E : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : Fintype ι] →
[inst_4 : FiniteDimensional 𝕜 E] →
{n : ℕ} →
(hn : Module.finra... | null | true |
Pi.instFrame._proof_2 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → Order.Frame (π i)] (a b : (i : ι) → π i), Lattice.inf a b ≤ b | null | false |
IsometryEquiv.subLeft.eq_1 | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd G G]
[inst_3 : IsIsometricVAdd Gᵃᵒᵖ G] (c : G),
IsometryEquiv.subLeft c = { toEquiv := Equiv.subLeft c, isometry_toFun := ⋯ } | null | true |
Order.Ici_succ | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] [NoMaxOrder α] (a : α), Set.Ici (Order.succ a) = Set.Ioi a | null | true |
Submodule.instIdemCommSemiring | Mathlib.Algebra.Algebra.Operations | {R : Type u} →
[inst : CommSemiring R] →
{A : Type v} → [inst_1 : CommSemiring A] → [inst_2 : Algebra R A] → IdemCommSemiring (Submodule R A) | Sub-R-modules of an R-algebra A form a semiring. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.