name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MonoidAlgebra.ringHom_ext'_iff | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : MulOneClass M] [inst_2 : Semiring S]
{f g : MonoidAlgebra R M →+* S},
f = g ↔
f.comp MonoidAlgebra.singleOneRingHom = g.comp MonoidAlgebra.singleOneRingHom ∧
(↑f).comp (MonoidAlgebra.of R M) = (↑g).comp (MonoidAlgebra.of R M) | null | true |
smoothSheafCommRing.forgetStalk_hom_comp_evalHom | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : Topo... | null | true |
NonUnitalSubsemiring.mem_sInf | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] {S : Set (NonUnitalSubsemiring R)} {x : R},
x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p | null | true |
List.partition.loop.eq_1 | Init.Data.List.Lemmas | ∀ {α : Type u} (p : α → Bool) (bs cs : List α), List.partition.loop p [] (bs, cs) = (bs.reverse, cs.reverse) | null | true |
_private.Mathlib.MeasureTheory.Measure.Prokhorov.0.MeasureTheory.isTightMeasureSet_of_isCompact_closure._proof_1_5 | Mathlib.MeasureTheory.Measure.Prokhorov | (1 + 1).AtLeastTwo | null | false |
_private.Mathlib.RingTheory.Ideal.Norm.AbsNorm.0.Ideal.mul_add_mem_pow_succ_inj._simp_1_1 | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * b - a * c = a * (b - c) | null | false |
CategoryTheory.MonoidalCategory.DayConvolutionUnit.leftUnitor_inv_app_assoc | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
(U : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolutionUnit U]
(F : Ca... | null | true |
TensorAlgebra.ofDirectSum_toDirectSum | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : TensorAlgebra R M), TensorAlgebra.ofDirectSum (TensorAlgebra.toDirectSum x) = x | null | true |
SubringClass.toSeminormedRing | Mathlib.Analysis.Normed.Ring.Basic | {S : Type u_5} →
{R : Type u_6} → [inst : SetLike S R] → [inst_1 : SeminormedRing R] → [SubringClass S R] → (s : S) → SeminormedRing ↥s | null | true |
_private.Lean.MonadEnv.0.Lean.matchConstCtor._sparseCasesOn_1 | Lean.MonadEnv | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t | null | false |
ValuativeRel.vle_of_veq_of_vle | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] {x y z : R}, x =ᵥ y → y ≤ᵥ z → x ≤ᵥ z | null | true |
IsCompact.isLUB_sSup | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [ClosedIciTopology α]
{s : Set α}, IsCompact s → s.Nonempty → IsLUB s (sSup s) | null | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.rotateR.match_1.eq_2 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : Ordnode α → α → Ordnode α → Sort u_2) (y : α) (r : Ordnode α)
(h_1 :
(size : ℕ) →
(l : Ordnode α) → (x : α) → (m : Ordnode α) → (y : α) → (r : Ordnode α) → motive (Ordnode.node size l x m) y r)
(h_2 : (y : α) → (r : Ordnode α) → motive Ordnode.nil y r),
(match Ordnode.nil, y, ... | null | true |
LinearMap.normDet_sq | Mathlib.Analysis.InnerProductSpace.NormDet | ∀ {𝕜 : Type u_1} {U : Type u_2} {V : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup U]
[inst_2 : InnerProductSpace 𝕜 U] [inst_3 : FiniteDimensional 𝕜 U] [inst_4 : NormedAddCommGroup V]
[inst_5 : InnerProductSpace 𝕜 V] [inst_6 : FiniteDimensional 𝕜 V] (f : U →ₗ[𝕜] V),
↑(f.normDet ^ 2) = LinearMap.... | The square of `f.normDet` equals the determinant of `f.adjoint ∘ₗ f` when the codomain is finite
dimensional.
| true |
MulOneClass.isUnital | Mathlib.Algebra.Group.Monoid | ∀ {A : Type u_2} [inst : MulOneClass A], IsUnital A | null | true |
Function.LeftInverse.isClosed_range | Mathlib.Topology.Separation.Hausdorff | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space X] {f : X → Y}
{g : Y → X}, Function.LeftInverse f g → Continuous f → Continuous g → IsClosed (Set.range g) | Retract subspaces of Hausdorff spaces are closed. | true |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiForkOfIsLimit._proof_7 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left}
(hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d)
... | null | false |
Polynomial.support_C_mul_X_pow_subset | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (n : ℕ) (c : R), (Polynomial.C c * Polynomial.X ^ n).support ⊆ {n} | null | true |
Fin.find | Mathlib.Data.Fin.Tuple.Basic | {n : ℕ} → (p : Fin n → Prop) → [DecidablePred p] → (∃ k, p k) → Fin n | `Fin.find p h` returns the smallest index `k : Fin n` where `p k` is satisfied,
given that it is satisfied for some `k`. | true |
Lean.Order.fix_eq | Init.Internal.Order.Basic | ∀ {α : Sort u} [inst : Lean.Order.CCPO α] {f : α → α} (hf : Lean.Order.monotone f),
Lean.Order.fix f hf = f (Lean.Order.fix f hf) | The main fixpoint theorem for fixed points of monotone functions in chain-complete partial orders.
This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
| true |
Rat.isNat_intFract_of_isNat | Mathlib.Data.Rat.Floor | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] (r : R) (m : ℕ),
Mathlib.Meta.NormNum.IsNat r m → Mathlib.Meta.NormNum.IsNat (Int.fract r) 0 | null | true |
ContinuousCohomology.zeroIso._proof_3 | Mathlib.RepresentationTheory.Homological.ContCohomology.LowDegree | ∀ {k : Type u_1} {G : Type u_2} [inst : Ring k] [inst_1 : Group G] [inst_2 : TopologicalSpace k] (A : TopRep k G),
ContinuousSMul k ↥A.ρ.invariants | null | false |
Std.DTreeMap.Internal.Impl.Const.minEntry._unary.eq_def | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : Type v} (_x : (x : Std.DTreeMap.Internal.Impl α fun x => β) ×' x.isEmpty = false),
Std.DTreeMap.Internal.Impl.Const.minEntry._unary _x =
PSigma.casesOn _x fun t h =>
match t, h with
| Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r, x => (k, v)
| S... | null | false |
RBTree.RBSet.ModifyWF | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → RBTree.RBSet α cmp → (α → Ordering) → (α → α) → Prop | The predicate asserting that the result of `modifyP` is safe to construct. | true |
CochainComplex.cm5b.i.eq_1 | Mathlib.Algebra.Homology.Factorizations.CM5b | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] {K L : CochainComplex C ℤ} (f : K ⟶ L),
CochainComplex.cm5b.i f =
CategoryTheory.Limits.biprod.lift
(CochainComplex.mappingCone.lift (CategoryTheory.CategoryStruc... | null | true |
Finset.«_aux_Mathlib_Data_Finset_Slice___macroRules_Finset_term_#__1» | Mathlib.Data.Finset.Slice | Lean.Macro | null | false |
Perfection.liftMonoidHom._proof_2 | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) (M : Type u_1) [inst : CommMonoid M] [PerfectRing M p] (n : ℕ), PerfectRing M (p ^ (n + 1)) | null | false |
CategoryTheory.StrongEpiCategory | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | A strong epi category is a category in which every epimorphism is strong. | true |
uzpow_zero | Mathlib.Data.ZMod.IntUnitsPower | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : Module R (Additive ℤˣ)] (s : ℤˣ), s ^ 0 = 1 | null | true |
CategoryTheory.ShortComplex.LeftHomologyData.noConfusionType | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
S.LeftHomologyData →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
... | null | false |
Lean.PrettyPrinter.OneLine.State.mk | Lean.PrettyPrinter.Formatter | Std.Format → ℕ → List (ℕ × Std.Format) → Lean.PrettyPrinter.OneLine.State | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Grothendieck.0.CategoryTheory.Pseudofunctor.Grothendieck.category._simp_2 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {C D : CategoryTheory.Cat} {F G H : C ⟶ D} (α : F ⟶ G) (β : G ⟶ H) (X : ↑C),
CategoryTheory.CategoryStruct.comp (α.toNatTrans.app X) (β.toNatTrans.app X) =
(CategoryTheory.CategoryStruct.comp α β).toNatTrans.app X | null | false |
_private.Mathlib.Logic.Equiv.Embedding.0.Equiv.sumEmbeddingEquivProdEmbeddingDisjoint.match_1.eq_2 | Mathlib.Logic.Equiv.Embedding | ∀ {α : Type u_1} {β : Type u_2} (motive : α ⊕ β → Sort u_3) (b : β) (h_1 : (a : α) → motive (Sum.inl a))
(h_2 : (b : β) → motive (Sum.inr b)),
(match Sum.inr b with
| Sum.inl a => h_1 a
| Sum.inr b => h_2 b) =
h_2 b | null | true |
MultilinearMap.coe_inj._simp_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] {f g : MultilinearMap R M₁ M₂}, (⇑f = ⇑g) = (f = g) | null | false |
ProfiniteGrp.coe_of | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ (G : Type u) [inst : Group G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalGroup G] [inst_3 : CompactSpace G]
[inst_4 : TotallyDisconnectedSpace G], ↑(↧G).toProfinite.toTop = G | null | true |
IO.FS.Mode.writeNew | Init.System.IO | IO.FS.Mode | A new file should be created for writing.
It is an error if the file already exists. A new file is created, with the read/write cursor
positioned at the start.
* `open` flags: `O_WRONLY | O_CREAT | O_TRUNC | O_EXCL`
* `fdopen` mode: `w`
| true |
Fin.rev_predAbove | Mathlib.Data.Fin.Rev | ∀ {n : ℕ} (p : Fin n) (i : Fin (n + 1)), (p.predAbove i).rev = p.rev.predAbove i.rev | `rev` commutes with `predAbove`. | true |
IsIntegral.isAlmostIntegral_of_exists_smul_mem_range | Mathlib.RingTheory.IntegralClosure.IsIntegral.AlmostIntegral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {s : S},
IsIntegral R s → (∃ t ∈ nonZeroDivisors R, t • s ∈ (algebraMap R S).range) → IsAlmostIntegral R s | null | true |
Std.DTreeMap.Internal.Impl.maxEntry | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → (t : Std.DTreeMap.Internal.Impl α β) → t.isEmpty = false → (a : α) × β a | Implementation detail of the tree map | true |
CategoryTheory.IsGrothendieckAbelian.wellPowered | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C], CategoryTheory.WellPowered.{w, v, u} C | null | true |
CochainComplex.HomComplex.Cochain.leftShiftAddEquiv_symm_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n a n' : ℤ) (hn' : n + a = n')
(γ : CochainComplex.HomComplex.Cochain ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) a).obj K) L n'),
(CochainComplex.HomComplex.Cochain.leftShiftAddEqui... | null | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT_neg_mem._simp_1_6 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
TopologicalSpace.NonemptyCompacts.instEMetricSpace._proof_3 | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : EMetricSpace α] {s t : TopologicalSpace.NonemptyCompacts α}, edist s t = 0 → s = t | null | false |
_private.Init.Data.Vector.MapIdx.0.Vector.mapFinIdx_mapFinIdx._simp_1_1 | Init.Data.Vector.MapIdx | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {xs' : Vector β n} {xs : Vector α n} {f : (i : ℕ) → α → i < n → β},
(xs.mapFinIdx f = xs') = ∀ (i : ℕ) (h : i < n), xs'[i] = f i xs[i] h | null | false |
UpperHalfPlane.I_im | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | UpperHalfPlane.I.im = 1 | null | true |
intervalIntegrable_congr | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] [TopologicalSpace.PseudoMetrizableSpace ε]
{f : ℝ → ε} {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {g : ℝ → ε},
Set.EqOn f g (Set.uIoc a b) → (IntervalIntegrable f μ a b ↔ IntervalIntegrable g μ a b) | null | true |
AddMonoid.fg_iff_addSubmonoid_fg | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : AddMonoid M] (N : AddSubmonoid M), AddMonoid.FG ↥N ↔ N.FG | null | true |
IsManifold.instOfTopWithTopENat | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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] {a : WithTop ℕ∞} [IsManifold I ⊤ M], Is... | null | true |
Lean.Grind.Ring.intCast | Init.Grind.Ring.Basic | {α : Type u} → [self : Lean.Grind.Ring α] → IntCast α | In every ring there is a canonical map from the integers to the ring. | true |
CategoryTheory.BasedCategory.bicategory._proof_6 | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} 𝒮] {a b c d : CategoryTheory.BasedCategory 𝒮}
(f : CategoryTheory.BasedFunctor a b) (g : CategoryTheory.BasedFunctor b c) {h h' : CategoryTheory.BasedFunctor c d}
(η : h ⟶ h'),
CategoryTheory.BasedCategory.whiskerLeft (f.comp g) η =
CategoryTheory... | null | false |
GaloisConnection.liftOrderBot._proof_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : OrderBot α] [inst_2 : PartialOrder β] {l : α → β}
{u : β → α}, GaloisConnection l u → ∀ (x : β), l ⊥ ≤ x | null | false |
Fin.reverseInduction.go._f | Init.Data.Fin.Lemmas | {n : ℕ} →
{motive : Fin (n + 1) → Sort u_1} →
((i : Fin n) → motive i.succ → motive i.castSucc) →
(i : Fin (n + 1)) →
(j : ℕ) →
Nat.below (motive := fun j => (h : j < n + 1) → ↑i ≤ j → motive ⟨j, h⟩ → motive i) j →
(h : j < n + 1) → ↑i ≤ j → motive ⟨j, h⟩ → motive i | null | false |
optionCoe | Init.Data.Option.Coe | {α : Type u} → Coe α (Option α) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Sum.0.SimpleGraph.sum.match_1.eq_2 | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} (motive : V ⊕ W → V ⊕ W → Sort u_3) (u v : W)
(h_1 : (u v : V) → motive (Sum.inl u) (Sum.inl v)) (h_2 : (u v : W) → motive (Sum.inr u) (Sum.inr v))
(h_3 : (x x_1 : V ⊕ W) → motive x x_1),
(match Sum.inr u, Sum.inr v with
| Sum.inl u, Sum.inl v => h_1 u v
| Sum.inr u, Sum.in... | null | true |
CategoryTheory.instCategoryCostructuredArrow._proof_1 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {S : CategoryTheory.Functor C D} {T : D}
{X Y : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.... | null | false |
List.Perm | Init.Data.List.Basic | {α : Type u} → List α → List α → Prop | Two lists are permutations of each other if they contain the same elements, each occurring the same
number of times but not necessarily in the same order.
One list can be proven to be a permutation of another by showing how to transform one into the other
by repeatedly swapping adjacent elements.
`List.isPerm` is a B... | true |
Subsemigroup.unop_eq_bot | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] {S : Subsemigroup Mᵐᵒᵖ}, S.unop = ⊥ ↔ S = ⊥ | null | true |
CategoryTheory.ShortComplex.SnakeInput.naturality_δ_assoc | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁ ⟶ S₂) {Z : C} (h : S₂.L₃.X₁ ⟶ Z),
CategoryTheory.CategoryStruct.comp S₁.δ (CategoryTheory.CategoryStruct.comp f.f₃.τ₁ h) =
CategoryTheory.CategoryStruct.c... | null | true |
CategoryTheory.StrictBicategory.category | Mathlib.CategoryTheory.Bicategory.Strict.Basic | (B : Type u) →
[inst : CategoryTheory.Bicategory B] → [CategoryTheory.Bicategory.Strict B] → CategoryTheory.Category.{v, u} B | Category structure on a strict bicategory | true |
Std.DHashMap.Internal.Raw₀.size_le_size_insert | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], (↑m).WF → ∀ {k : α} {v : β k}, (↑m).size ≤ (↑(m.insert k v)).size | null | true |
cfcTac | Mathlib.Tactic.ContinuousFunctionalCalculus | Lean.ParserDescr | A tactic used to automatically discharge goals relating to the continuous functional calculus,
specifically whether the element satisfies the predicate. | true |
CategoryTheory.Yoneda.yoneda_faithful | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], CategoryTheory.yoneda.Faithful | The Yoneda embedding is faithful. | true |
SNum.zero.elim | Mathlib.Data.Num.Bitwise | {motive : SNum → Sort u} → (t : SNum) → t.ctorIdx = 0 → ((a : Bool) → motive (SNum.zero a)) → motive t | null | false |
ZFSet.instDefinable₁Singleton | Mathlib.SetTheory.ZFC.Basic | ZFSet.Definable₁ fun x => {x} | null | true |
_private.Mathlib.Algebra.Category.Grp.Biproducts.0.AddCommGrpCat.biprodIsoProd_inv_comp_desc._simp_1_2 | Mathlib.Algebra.Category.Grp.Biproducts | ∀ (G H : AddCommGrpCat),
AddCommGrpCat.ofHom (AddMonoidHom.snd ↑G ↑H) =
CategoryTheory.CategoryStruct.comp (G.biprodIsoProd H).inv CategoryTheory.Limits.biprod.snd | null | false |
AndThen.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} → {t : AndThen α} → {α' : Type u} → {t' : AndThen α'} → α = α' → t ≍ t' → AndThen.noConfusionType P t t' | null | false |
_private.Mathlib.Order.Partition.Equipartition.0.Finpartition.IsEquipartition.exists_partPreservingEquiv._simp_1_4 | Mathlib.Order.Partition.Equipartition | ∀ {n : ℕ} (a b : Fin n), (↑a = ↑b) = (a = b) | null | false |
String.firstDiffPos.eq_1 | Batteries.Data.String.Lemmas | ∀ (a b : String), a.firstDiffPos b = String.firstDiffPos.loop a b (a.rawEndPos.min b.rawEndPos) 0 | null | true |
Lean.Meta.Grind.SolverTerms.below | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SolverTerms → Sort u} → Lean.Meta.Grind.SolverTerms → Sort (max 1 u) | null | false |
CategoryTheory.Pseudofunctor.Grothendieck.map._proof_4 | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} 𝒮]
{F G : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} (α : F ⟶ G)
{a b c : F.Grothendieck} (f : a ⟶ b) (g : b ⟶ c),
{ base := (CategoryTheory.CategoryStruct.comp f g).base,
fiber :=
CategoryTheory.... | null | false |
CategoryTheory.MorphismProperty.instCategoryLocalization._proof_9 | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (W : CategoryTheory.MorphismProperty C),
autoParam
(∀ {W_1 X Y Z : W.Localization} (f : W_1 ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp ... | null | false |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a ≤ b ∧ b ≤ a) = (a = b) | null | false |
Set.Ioi_subset_Ici | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b ≤ a → Set.Ioi a ⊆ Set.Ici b | If `a ≤ b`, then `(b, +∞) ⊆ [a, +∞)`. In preorders, this is just an implication. If you need
the equivalence in dense linear orders, use `Ioi_subset_Ici_iff`. | true |
Lean.SMap.stage₁._default | Lean.Data.SMap | {α : Type u} → {β : Type v} → {inst : BEq α} → {inst : Hashable α} → Bool | null | false |
_private.Init.Prelude.0.Nat.div_rec_lemma.match_1_1 | Init.Prelude | ∀ {x y : ℕ} (motive : 0 < y ∧ y ≤ x → Prop) (x_1 : 0 < y ∧ y ≤ x),
(∀ (ypos : 0 < y) (ylex : y ≤ x), motive ⋯) → motive x_1 | null | false |
nhdsKer_eq_iff_isOpen | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {s : Set α}, nhdsKer s = s ↔ IsOpen s | null | true |
IsCoveringMap.liftPath.congr_simp | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p p_1 : E → X}
(e_p : p = p_1) (cov : IsCoveringMap p) (γ γ_1 : C(↑unitInterval, X)) (e_γ : γ = γ_1) (e e_1 : E) (e_e : e = e_1)
(γ_0 : γ 0 = p e), cov.liftPath γ e γ_0 = ⋯.liftPath γ_1 e_1 ⋯ | null | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra.0.IntermediateField.fg_top_iff._simp_1_3 | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x : R} {y : ↥M} {z : S},
(IsLocalization.mk' S x y = z) = ((algebraMap R S) x = z * (algebraMap R S) ↑y) | null | false |
Function.IsFixedPt.eq | Mathlib.Logic.Function.Defs | ∀ {α : Type u₁} {f : α → α} {x : α}, Function.IsFixedPt f x → f x = x | If `x` is a fixed point of `f`, then `f x = x`. This is useful, e.g., for `rw` or `simp`. | true |
CategoryTheory.MonoidalClosed.compTranspose | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(x y z : C) →
[inst_2 : CategoryTheory.Closed x] →
[inst_3 : CategoryTheory.Closed y] →
CategoryTheory.MonoidalCategoryStruct.tensorObj x
(CategoryTheory.Mo... | The *uncurried* composition morphism
`x ⊗ (hom(x, y) ⊗ hom(y, z)) ⟶ (x ⊗ hom(x, y)) ⊗ hom(y, z) ⟶ y ⊗ hom(y, z) ⟶ z`.
The `C`-composition morphism will be defined as the adjoint transpose of this map. | true |
Matrix.invertibleOfDetInvertible._proof_2 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
[inst_3 : Invertible A.det], A * ⅟A.det • A.adjugate = 1 | null | false |
Lean.Omega.IntList.sdiv | Init.Omega.IntList | Lean.Omega.IntList → ℤ → Lean.Omega.IntList | Division of an `IntList` by a integer. | true |
ProfiniteAddGrp.ProfiniteCompletion.completion | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | AddGrpCat → ProfiniteAddGrp.{u} | The profinite completion of `G` as a projective limit. | true |
Std.IterM.IsPlausibleNthOutputStep.yield | Init.Data.Iterators.Consumers.Monadic.Access | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] {n : ℕ} {it it' : Std.IterM m β} {out : β}
{step : Std.IterStep (Std.IterM m β) β},
it.IsPlausibleStep (Std.IterStep.yield it' out) →
Std.IterM.IsPlausibleNthOutputStep n it' step → Std.IterM.IsPlausibleNthOutputStep (n + 1) it step | If `it` plausibly yields in its immediate next step, the successor iterator being `it'`, and
if `step` is a plausible `n`-th output step of `it'`, then `step` is a plausible `n + 1`-th
output step of `it`.
| true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.3322021038._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
Matrix.UnitaryGroup.toLinearEquiv._proof_6 | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type u_2} [inst_2 : CommRing α] [inst_3 : StarRing α]
(A : ↥(Matrix.unitaryGroup n α)) (x : n → α), (Matrix.UnitaryGroup.toLin' A⁻¹ ∘ₗ Matrix.UnitaryGroup.toLin' A) x = x | null | false |
Lean.Elab.Command.withFreshMacroScope | Lean.Elab.Command | {α : Type} → Lean.Elab.Command.CommandElabM α → Lean.Elab.Command.CommandElabM α | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.spectralSequencePageSc'Iso._proof_15 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ (n₃ n₄ : ℤ),
autoParam (n₃ + 1 = n₄) CategoryTheory.Abelian.SpectralObject.spectralSequencePageSc'Iso._auto_7 → n₃ + 1 = n₄ | null | false |
NumberField.Units.logEmbedding | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | (K : Type u_1) →
[inst : Field K] →
[inst_1 : NumberField K] →
Additive (NumberField.RingOfIntegers K)ˣ →+ NumberField.Units.dirichletUnitTheorem.logSpace K | The logarithmic embedding of the units (seen as an `Additive` group). | true |
Field.Emb.cardinal_separableClosure | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsAlgebraic F E],
Cardinal.mk (Field.Emb F ↥(separableClosure F E)) = Cardinal.mk (Field.Emb F E) | null | true |
_private.Mathlib.RingTheory.Spectrum.Maximal.Localization.0.PrimeSpectrum.iInf_localization_eq_bot.match_1_2 | Mathlib.RingTheory.Spectrum.Maximal.Localization | ∀ (R : Type u_1) [inst : CommRing R] (motive : MaximalSpectrum R → Prop) (x : MaximalSpectrum R),
(∀ (v : Ideal R) (hv : v.IsMaximal), motive { asIdeal := v, isMaximal := hv }) → motive x | null | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer._sizeOf_1 | Std.Sync.Channel | {α : Type} → [SizeOf α] → Std.CloseableChannel.Consumer✝ α → ℕ | null | false |
unitarySubgroupUnitsEquiv._proof_3 | Mathlib.Algebra.Star.Unitary | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : StarMul M] (x : ↥(unitary M)), star ↑x * ↑x = 1 | null | false |
Lean.Grind.CommRing.Stepwise.superpose_cert.eq_1 | Init.Grind.Ring.CommSolver | ∀ (k₁ : ℤ) (m₁ : Lean.Grind.CommRing.Mon) (p₁ : Lean.Grind.CommRing.Poly) (k₂ : ℤ) (m₂ : Lean.Grind.CommRing.Mon)
(p₂ p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Stepwise.superpose_cert k₁ m₁ p₁ k₂ m₂ p₂ p =
((Lean.Grind.CommRing.Poly.mulMon_k k₁ m₁ p₁).combine_k (Lean.Grind.CommRing.Poly.mulMon_k k₂ m₂ ... | null | true |
Ideal.powQuotPowSuccLinearEquivMapMkPowSuccPow._simp_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (I : Ideal R)
(N : Submodule R M) (x : ↥N), (x ∈ I • ⊤) = (↑x ∈ I • N) | null | false |
CategoryTheory.ObjectProperty.IsVerdierRightLocalizing.fullyFaithful | Mathlib.CategoryTheory.Triangulated.LocalizingSubcategory | {C : Type u_1} →
{D₁ : Type u_3} →
{D₂ : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} D₁] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} D₂] →
(A B : CategoryTheory.ObjectProperty C) →
[inst_3 : CategoryT... | If `A` is a right `B`-localizing triangulated subcategory in the sense of Verdier,
then the induced functor between the localizations with respect to `(B.inverseImage A.ι).trW`
and `B.trW` is fully faithful. | true |
CategoryTheory.LaxBraidedFunctor.homMk._proof_1 | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_4} [inst_3 : CategoryTheory.Category.{u_2, u_4} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{F G : Cat... | null | false |
_private.Mathlib.Algebra.Lie.Weights.Linear.0.LieModule.exists_nontrivial_weightSpace_of_isNilpotent._simp_1_6 | Mathlib.Algebra.Lie.Weights.Linear | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_4} [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] [inst_6 : LieModule R L M] (χ : L → R)
(m : M), (m ∈ LieModule.weightSpace M χ) = ∀ (x : L), ⁅x, m⁆ = χ x • m | null | false |
SSet.prodStdSimplex.pairingCore.IsIndex.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} (x x_1 : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N)
(e_x : x = x_1) {d : ℕ} (hd : x.dim = d) (a a_1 : Fin (d + 1)),
a = a_1 → SSet.prodStdSimplex.pairingCore.IsIndex x hd a = SSet.prodStdSimplex.pairingCore.IsIndex x_1 ⋯ a_1 | null | true |
instAddCommMonoidEReal._proof_1 | Mathlib.Data.EReal.Basic | ∀ (a b : EReal), a + b = b + a | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.