name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Unitary.mulLeft._proof_1 | Mathlib.Analysis.CStarAlgebra.Unitary.Maps | ∀ (R : Type u_1) [inst : Ring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
RingQuot.definition._@.Mathlib.Algebra.RingQuot.1093876312._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | {R : Type uR} →
[inst : Semiring R] →
{T : Type uT} →
[inst_1 : Semiring T] → {r : R → R → Prop} → {f : R →+* T} → (∀ ⦃x y : R⦄, r x y → f x = f y) → RingQuot r →+* T | null | false |
_private.Mathlib.Topology.Algebra.Valued.ValuedField.0.Valued.valuation_isClosedMap._simp_1_3 | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.isComplex₂_iff._proof_1_5 | Mathlib.Algebra.Homology.ExactSequence | ⟨0, CategoryTheory.ComposableArrows.isComplex₂_iff._proof_1_3✝⟩ ≤
⟨1, CategoryTheory.ComposableArrows.isComplex₂_iff._proof_1_4✝⟩ | null | false |
BEq.rec | Init.Prelude | {α : Type u} → {motive : BEq α → Sort u_1} → ((beq : α → α → Bool) → motive { beq := beq }) → (t : BEq α) → motive t | null | false |
ModularForm.Λ | Mathlib.NumberTheory.ModularForms.LFunction | {Γ : Subgroup (GL (Fin 2) ℝ)} →
[Γ.IsArithmetic] →
{k : ℤ} → 0 < k → {F : Type u_1} → [inst : FunLike F UpperHalfPlane ℂ] → F → [ModularFormClass F Γ k] → ℂ → ℂ | The `L`-series of a modular form (including its Archimedean `Γ`-factor). | true |
Turing.PartrecToTM2.splitAtPred | Mathlib.Computability.TuringMachine.ToPartrec | {α : Type u_1} → (α → Bool) → List α → List α × Option α × List α | This could be a general list definition, but it is also somewhat specialized to this
application. `splitAtPred p L` will search `L` for the first element satisfying `p`.
If it is found, say `L = l₁ ++ a :: l₂` where `a` satisfies `p` but `l₁` does not, then it returns
`(l₁, some a, l₂)`. Otherwise, if there is no such ... | true |
CategoryTheory.Functor.RightExtension.isUniversalEquivOfIso₂._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_3} {H : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_6, u_3} C]
[inst_1 : CategoryTheory.Category.{u_2, u_4} H] [inst_2 : CategoryTheory.Category.{u_5, u_1} D]
{L : CategoryTheory.Functor C D} {F₁ F₂ : CategoryTheory.Functor C H} (e : F₁ ≅ F₂),
CategoryTheory.Limits.PreservesLimit (Ca... | null | false |
groupHomology.functor._proof_5 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G] (n : ℕ) {X Y Z : Rep.{u_1, u_1, u_1} k G} (f : X ⟶ Y)
(g : Y ⟶ Z),
groupHomology.map (MonoidHom.id G) (CategoryTheory.CategoryStruct.comp f g) n =
CategoryTheory.CategoryStruct.comp (groupHomology.map (MonoidHom.id G) f n) (groupHomology.map (MonoidHom.i... | null | false |
Std.DHashMap.Internal.Raw₀.contains_of_contains_union_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, (m₁.union m₂).contains k = true → m₁.contains k = false → m₂.contains k = true | null | true |
Ordnode.diff.match_1 | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} →
(motive : Ordnode α → Ordnode α → Sort u_2) →
(x x_1 : Ordnode α) →
((t₁ : Ordnode α) → motive t₁ Ordnode.nil) →
((t₁ t₂ : Ordnode α) →
(size : ℕ) →
(l₂ : Ordnode α) →
(x : α) →
(r₂ : Ordnode α) →
(h : t... | null | false |
Set.SurjOn.surjective | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, Set.SurjOn f s Set.univ → Function.Surjective f | null | true |
AddSubsemigroup.centerToAddOpposite_symm_apply_coe | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_2} [inst : Add M] (r : ↥(AddSubsemigroup.center Mᵃᵒᵖ)),
↑(AddSubsemigroup.centerToAddOpposite.symm r) = AddOpposite.unop ↑r | null | true |
SimpleGraph.walkLengthTwoEquivCommonNeighbors._proof_7 | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | ∀ {V : Type u_1} (G : SimpleGraph V) (u v : V) (x : { p // p.length = 2 }), ↑⟨(↑x).snd, ⋯⟩ ∈ G.neighborSet u | null | false |
IsTopologicalSemiring.casesOn | Mathlib.Topology.Algebra.Ring.Basic | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalNonAssocSemiring R] →
{motive : IsTopologicalSemiring R → Sort u} →
(t : IsTopologicalSemiring R) →
([toContinuousAdd : ContinuousAdd R] → [toContinuousMul : ContinuousMul R] → motive ⋯) → motive t | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMkSucc._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ}, ¬0 ≤ n + 1 → False | null | false |
Multiset.dedup_nsmul | Mathlib.Algebra.Order.Group.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Multiset α} {n : ℕ}, n ≠ 0 → (n • s).dedup = s.dedup | null | true |
CategoryTheory.Lax.LaxTrans.id_naturality | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.LaxFunctor B C) {x x_1 : B} (f : x ⟶ x_1),
(CategoryTheory.CategoryStruct.id F).naturality f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (F.map f)).hom
... | null | true |
Std.DTreeMap.mk.congr_simp | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (inner inner_1 : Std.DTreeMap.Internal.Impl α β)
(e_inner : inner = inner_1) (wf : inner.WF), { inner := inner, wf := wf } = { inner := inner_1, wf := ⋯ } | null | true |
ContinuousCohomology.resolutionMap_comp | Mathlib.RepresentationTheory.Homological.ContCohomology.Functoriality | ∀ {k : Type u} {G H K : Type v} [inst : Ring k] [inst_1 : TopologicalSpace k] [inst_2 : Group G]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] [inst_5 : Group H] [inst_6 : TopologicalSpace H]
[inst_7 : IsTopologicalGroup H] [inst_8 : Group K] [inst_9 : TopologicalSpace K] [inst_10 : IsTopologicalGro... | null | true |
CategoryTheory.Adjunction.commShift_of_leftAdjoint | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {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] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (A : Type u_3) [inst_2 : AddGroup A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShif... | null | true |
Multiset.toEnumFinset_subset_iff | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {m₁ m₂ : Multiset α}, m₁.toEnumFinset ⊆ m₂.toEnumFinset ↔ m₁ ≤ m₂ | null | true |
_private.Lean.Meta.Sym.AbstractS.0.Lean.Meta.Sym.abstractFVarsRange.go._unsafe_rec | Lean.Meta.Sym.AbstractS | ℕ → (xs : Array Lean.Expr) → Lean.FVarId → ℕ → (i : ℕ) → i < xs.size → Option ℕ | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.isPatternVar.match_7 | Lean.Elab.Match | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) → (Unit → motive none) → ((f : Lean.Expr) → motive (some f)) → motive __do_lift | null | false |
Std.instLawfulIteratorLoopDefaultImplementation | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {β : Type w} (α : Type w) (m : Type w → Type w') (n : Type x → Type x') [inst : Monad m] [inst_1 : Monad n]
[inst_2 : Std.Iterator α m β] [Std.Iterators.Finite α m], Std.LawfulIteratorLoop α m n | null | true |
Height.logHeight₁_zpow | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] (x : K) (n : ℤ),
Height.logHeight₁ (x ^ n) = ↑n.natAbs * Height.logHeight₁ x | The logarithmic height of the `n`th power of a field element `x` (with `n : ℤ`)
is `|n|` times the logarithmic height of `x`. | true |
Std.DTreeMap.Raw.Const.ofList | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : Type v} →
List (α × β) →
(cmp : autoParam (α → α → Ordering) Std.DTreeMap.Raw.Const.ofList._auto_1) → Std.DTreeMap.Raw α (fun x => β) cmp | Transforms a list of mappings into a tree map. | true |
LieAlgebra.LieEquiv.ofCoboundary | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{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... | An equivalence of extended Lie algebras induced by translation by a coboundary. | true |
CommAlgCat.FiniteEtale.fiber._proof_3 | Mathlib.RingTheory.Etale.Finite | ∀ (R : Type u_3) [inst : CommRing R] (Ω : Type u_1) [inst_1 : Field Ω] [inst_2 : Algebra R Ω]
(S : (CommAlgCat.FiniteEtale R)ᵒᵖ), Finite (↑(Opposite.unop S).obj →ₐ[R] Ω) | null | false |
SSet.relativeCellComplexOfMono | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | {X Y : SSet} →
(i : X ⟶ Y) → [CategoryTheory.Mono i] → HomotopicalAlgebra.RelativeCellComplex (fun n x => (SSet.boundary n).ι) i | If `i : X ⟶ Y` is a monomorphism of simplicial sets, then it is a relative cell
complex with basic cells given by boundary inclusions `∂Δ[d] ⟶ Δ[d]`, one for each
nondegenerate `d`-simplex of `Y` not in the range of `X`. | true |
CategoryTheory.Pseudofunctor.IsPrestack.casesOn | Mathlib.CategoryTheory.Sites.Descent.IsPrestack | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{J : CategoryTheory.GrothendieckTopology C} →
{motive : F.IsPrestack J → Sort u_1} →
(t : F.IsPrestack J) →
((isSheaf :
... | null | false |
Subrepresentation.mem_ofSubmodule'_iff | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : CommSemiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} {N : Submodule (MonoidAlgebra A G) ρ.asModule} {w : W},
w ∈ Subrepresentation.ofSubmodule' N ↔ w ∈ N | null | true |
ProbabilityTheory.avgRisk_const_right' | Mathlib.Probability.Decision.Risk.Basic | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_4} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} (ℓ : Θ → 𝓨 → ENNReal) (P : ProbabilityTheory.Kernel Θ 𝓧) (ν : MeasureTheory.Measure 𝓨)
(π : MeasureTheory.Measure Θ),
ProbabilityTheory.avgRisk ℓ P (ProbabilityTheory.Kernel.const 𝓧 ... | See `avgRisk_const_right` for a simpler result when `P` is a Markov kernel. | true |
TypeVec._aux_Mathlib_Data_TypeVec___unexpand_TypeVec_appendFun_1 | Mathlib.Data.TypeVec | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'₁₃_eq_pullHom_of_chosenPullback₃._proof_5 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃)) (i₁ i₂ i₃ : ι),
CategoryTheo... | null | false |
WithBotTop.coe_strictMono._simp_1 | Mathlib.Order.WithBotTop | ∀ {ι : Type u_1} [inst : Preorder ι], StrictMono WithBotTop.coe = True | null | false |
coplanar_singleton | Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (p : P), Coplanar k {p} | A single point is coplanar. | true |
_private.Init.Data.UInt.Lemmas.0.USize.right_eq_add._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Std.Roo.forIn'_eq_forIn'_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roo α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_4 : Std.Rxo.IsAlwaysFinite α]
[inst_5 : Std.PRange.LawfulUpwardEnumerable α] {γ : Type u} {init : γ} {m : Type u → Type w} [inst_6 : Monad m]
[Lawfu... | null | true |
_private.Lean.Util.CollectAxioms.0.Lean.CollectAxioms.State.seen | Lean.Util.CollectAxioms | Lean.CollectAxioms.State✝ → Lean.NameMap (Array Lean.Name) | Cache mapping constants to their (sorted) axiom dependencies. | true |
CategoryTheory.Idempotents.FunctorExtension₁.obj_obj_X | Mathlib.CategoryTheory.Idempotents.FunctorExtension | ∀ {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] (F : CategoryTheory.Functor C (CategoryTheory.Idempotents.Karoubi D))
(P : CategoryTheory.Idempotents.Karoubi C),
((CategoryTheory.Idempotents.FunctorExtension₁.obj F).obj P).X = (F.obj P.... | null | true |
Odd.zpow_neg | Mathlib.Algebra.Order.Field.Power | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a : α} {n : ℤ},
Odd n → a < 0 → a ^ n < 0 | **Alias** of the reverse direction of `Odd.zpow_neg_iff`. | true |
AlgebraicGeometry.Scheme.IdealSheafData.inclusion._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J) (x y : J.subschemeCover.openCover.I₀),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.pullback.fst (J.subschemeCover.openCover.f x) (J.subschemeCover.openCover.f y))
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Sche... | null | false |
_private.Init.Data.String.Basic.0.String.Pos.Raw.substrEq.loop.eq_def | Init.Data.String.Basic | ∀ (s1 s2 : String) (off1 off2 stop1 : String.Pos.Raw),
String.Pos.Raw.substrEq.loop✝ s1 s2 off1 off2 stop1 =
if _h : off1.byteIdx < stop1.byteIdx then
have c₁ := String.Pos.Raw.get s1 off1;
have c₂ := String.Pos.Raw.get s2 off2;
c₁ == c₂ && String.Pos.Raw.substrEq.loop✝ s1 s2 (off1 + c₁) (off2 +... | null | true |
_private.Std.Sat.CNF.Basic.0.Std.Sat.CNF.Clause.empty._proof_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1}, ByteArray.empty.size = #[].size | null | false |
CommCStarAlgebra.nnnorm_sub_eq_max | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A] {a b : A}, a * b = 0 → ‖a - b‖₊ = max ‖a‖₊ ‖b‖₊ | null | true |
ModuleCat.limitπLinearMap._proof_1 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_4} [inst : Ring R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_1, max u_3 u_1} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] (j : J)
(x x_1 : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryT... | null | false |
Lean.Syntax.setAtomVal | Lean.Syntax | Lean.Syntax → String → Lean.Syntax | null | true |
SimpleGraph.instMeasurableSpace | Mathlib.MeasureTheory.Constructions.SimpleGraph | {V : Type u_1} → MeasurableSpace (SimpleGraph V) | null | true |
_private.Mathlib.Order.Filter.Ultrafilter.Cardinality.0.interPairsFilter_neBot._simp_2 | Mathlib.Order.Filter.Ultrafilter.Cardinality | ∀ {γ : Type u_3} {ι : Sort u_4} {κ : ι → Sort u_7} {x : γ} {s : (i : ι) → κ i → Set γ},
(x ∈ ⋃ i, ⋃ j, s i j) = ∃ i j, x ∈ s i j | null | false |
TopCat.LocalPredicate.cocone._proof_2 | Mathlib.Topology.Sheaves.LocalPredicate | ∀ {X : TopCat} (x : ↑X) (U : (TopologicalSpace.OpenNhds x)ᵒᵖ), x ∈ ↑(Opposite.unop U) | null | false |
Std.Async.BaseAsync.ofExcept | Std.Async.Basic | {α : Type} → Except Empty α → Std.Async.BaseAsync α | Converts `Except` to `BaseAsync`.
| true |
CategoryTheory.Limits.evaluationJointlyReflectsColimits | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} J] →
{K : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} K] →
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} →
(c : CategoryTh... | The evaluation functors jointly reflect colimits: that is, to show a cocone is a colimit of `F`
it suffices to show that each evaluation cocone is a colimit. In other words, to prove a cocone is
colimiting you can show it's pointwise colimiting.
| true |
Field.powerBasisOfFiniteOfSeparable._proof_4 | Mathlib.FieldTheory.PrimitiveElement | ∀ (F : Type u_2) (E : Type u_1) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
SubsemiringClass (IntermediateField F E) E | null | false |
Lean.Parser.registerAliasCore | Lean.Parser.Extension | {α : Type} → IO.Ref (Lean.Parser.AliasTable α) → Lean.Name → Lean.Parser.AliasValue α → IO Unit | null | true |
Rat.num_ne_zero | Mathlib.Data.Rat.Defs | ∀ {q : ℚ}, q.num ≠ 0 ↔ q ≠ 0 | null | true |
_private.Mathlib.Analysis.Calculus.AbsolutelyMonotone.0.AbsolutelyMonotoneOn._proof_2 | Mathlib.Analysis.Calculus.AbsolutelyMonotone | ContinuousConstSMul ℝ ℝ | null | false |
Lean.Grind.CommRing.instBEqPoly.beq | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Bool | null | true |
CategoryTheory.MonoidalCategory.inv_tensor._simp_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y Z : C}
(f : W ⟶ X) [inst_2 : CategoryTheory.IsIso f] (g : Y ⟶ Z) [inst_3 : CategoryTheory.IsIso g],
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.inv f) (CategoryTheory.inv g) =
Categor... | null | false |
NonemptyInterval.ext_iff | Mathlib.Order.Interval.Basic | ∀ {α : Type u_6} {inst : LE α} {x y : NonemptyInterval α}, x = y ↔ x.toProd = y.toProd | null | true |
Lean.Kernel.Exception.alreadyDeclared | Lean.Environment | Lean.Kernel.Environment → Lean.Name → Lean.Kernel.Exception | null | true |
Std.Packages.PreorderOfLEArgs.le._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | null | false |
Filter.nonpos_iff | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Zero α] {f : Filter α}, f ≤ 0 ↔ 0 ∈ f | null | true |
Std.Http.Status.ctorIdx | Std.Http.Data.Status | Std.Http.Status → ℕ | null | false |
CategoryTheory.ObjectProperty.isClosedUnderColimitsOfShape_op_iff_unop | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] (Q : CategoryTheory.ObjectProperty Cᵒᵖ),
Q.IsClosedUnderColimitsOfShape Jᵒᵖ ↔ Q.unop.IsClosedUnderLimitsOfShape J | null | true |
Convex.isPreconnected | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [ContinuousAdd E]
[ContinuousSMul ℝ E] {s : Set E}, Convex ℝ s → IsPreconnected s | A convex set is preconnected. | true |
AddMonoidAlgebra.le_inf_support_add | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : SemilatticeInf T] [inst_1 : OrderTop T] [inst_2 : Semiring R]
(degt : A → T) (f g : AddMonoidAlgebra R A),
f.coeff.support.inf degt ⊓ g.coeff.support.inf degt ≤ (f + g).coeff.support.inf degt | **Alias** of `AddMonoidAlgebra.le_inf_support_coeff_add`. | true |
Vector.map_uncurry_zip_eq_zipWith | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {n : ℕ} {f : α → β → γ} {as : Vector α n} {bs : Vector β n},
Vector.map (Function.uncurry f) (as.zip bs) = Vector.zipWith f as bs | null | true |
Ring.instLieAdmissibleRing._proof_1 | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | ∀ {L : Type u_1} [inst : Ring L] (x y z : L),
associator x y z + associator z x y + associator y z x = associator y x z + associator z y x + associator x z y | null | false |
_private.Mathlib.Topology.Sequences.0.FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto._simp_1_7 | Mathlib.Topology.Sequences | ∀ {a : Prop}, (¬¬a) = a | null | false |
_private.Batteries.Data.List.Basic.0.List.swapTR.go.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (a a_1 : ℕ) (a_2 : Array α), List.swapTR.go✝ l [] a a_1 a_2 = l | null | true |
IsArtinianRing.quotNilradicalPowEquivPi._proof_7 | Mathlib.RingTheory.Artinian.Module | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsArtinianRing R] (n : ℕ) (x : R),
(Ideal.quotientInfRingEquivPiQuotient (fun I => I.asIdeal ^ n) ⋯).toFun ((algebraMap R (R ⧸ ⨅ I, I.asIdeal ^ n)) x) =
(Ideal.quotientInfRingEquivPiQuotient (fun I => I.asIdeal ^ n) ⋯).toFun ((algebraMap R (R ⧸ ⨅ I, I.asIdeal ^ n)) x... | null | false |
Complex.tan_inv_eq_cot | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℂ), (Complex.tan x)⁻¹ = Complex.cot x | null | true |
ChainComplex.augment._proof_1 | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : ChainComplex V ℕ) {X : V} (f : C.X 0 ⟶ X) (x x_1 : ℕ),
¬(ComplexShape.down ℕ).Rel x x_1 →
(match x, x_1 with
| 1, 0 => f
| i.succ, j.succ => C.d i j
| x, x_3 => 0) =
0 | null | false |
CliffordAlgebra.contractLeft._proof_8 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (c : R) (d : Module.Dual R M),
CliffordAlgebra.foldr' Q (CliffordAlgebra.contractLeftAux Q (c • d)) ⋯ 0 =
(RingHom.id R) c • CliffordAlgebra.foldr' Q (CliffordAlgebra.contractLeftAux Q d) ... | null | false |
AlgHom.fromOpposite | Mathlib.Algebra.Algebra.Opposite | {R : Type u_1} →
{A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] → (f : A →ₐ[R] B) → (∀ (x y : A), Commute (f x) (f y)) → Aᵐᵒᵖ →ₐ[R] B | An algebra homomorphism `f : A →ₐ[R] B` such that `f x` commutes with `f y` for all `x, y` defines
an algebra homomorphism from `Aᵐᵒᵖ`. | true |
CategoryTheory.ComposableArrows.threeδ₂Toδ₁_app_two | Mathlib.CategoryTheory.ComposableArrows.Three | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l)
(f₁₂ : i ⟶ k) (f₂₃ : j ⟶ l) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂)
(h₂₃ : CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃),
(CategoryTheory.ComposableArrows.threeδ₂Toδ₁ f₁ f₂ f₃ f₁₂ f₂₃ h₁₂... | null | true |
ST.pure | Init.System.ST | {α σ : Type} → α → ST σ α | null | true |
Prefunctor.pathStar_injective | Mathlib.Combinatorics.Quiver.Covering | ∀ {U : Type u_1} [inst : Quiver U] {V : Type u_2} [inst_1 : Quiver V] (φ : U ⥤q V),
(∀ (u : U), Function.Injective (φ.star u)) → ∀ (u : U), Function.Injective (φ.pathStar u) | null | true |
QuadraticForm.tensorLId_symm_apply | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | ∀ {R : Type uR} {M₂ : Type uM₂} [inst : CommRing R] [inst_1 : AddCommGroup M₂] [inst_2 : Module R M₂]
[inst_3 : Invertible 2] (Q₂ : QuadraticForm R M₂) (x : M₂), Q₂.tensorLId.symm x = (TensorProduct.lid R M₂).symm x | null | true |
CategoryTheory.Limits.equalizer.condition_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g] {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.equalizer.ι f g) (CategoryTheory.CategoryStruct.comp f h) =
CategoryTheory.CategoryStruct.comp (Catego... | null | true |
BoxIntegral.IntegrationParams.McShane | Mathlib.Analysis.BoxIntegral.Partition.Filter | BoxIntegral.IntegrationParams | The `BoxIntegral.IntegrationParams` corresponding to the McShane integral. In the
corresponding filter, we require that the tagged partition is subordinate to a (possibly,
discontinuous) positive function `r`; the tags may be outside of the corresponding closed box
(but still inside the ambient closed box `I.Icc`). | true |
Aesop.instEmptyCollectionGlobalRuleSet | Aesop.RuleSet | EmptyCollection Aesop.GlobalRuleSet | null | true |
Std.DTreeMap.Internal.Impl.self_le_maxKey!_insert | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α] (h : t.WF) {k : α} {v : β k},
(compare k (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.maxKey!).isLE = true | null | true |
_private.Mathlib.Probability.Process.LocalProperty.0.ProbabilityTheory.mkStrictMonoAux._sunfold | Mathlib.Probability.Process.LocalProperty | (ℕ → ℕ) → ℕ → ℕ | null | false |
_private.Mathlib.FieldTheory.Finite.Basic.0.FiniteField.card_image_polynomial_eval._simp_1_1 | Mathlib.FieldTheory.Finite.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = ∀ (a : α), a ∈ s₁ ↔ a ∈ s₂ | null | false |
Algebra.weaklyQuasiFiniteAt_iff | Mathlib.RingTheory.QuasiFinite.Weakly | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (q : Ideal S)
[inst_3 : q.IsPrime],
Algebra.WeaklyQuasiFiniteAt R q ↔
Algebra.QuasiFinite R (Localization.AtPrime q ⧸ Ideal.map (algebraMap R (Localization.AtPrime q)) (Ideal.under R q)) | null | true |
_private.Mathlib.Util.AtomM.Recurse.0.Mathlib.Tactic.AtomM.RecurseM.run.evalAtom._unsafe_rec | Mathlib.Util.AtomM.Recurse | IO.Ref Mathlib.Tactic.AtomM.State →
Mathlib.Tactic.AtomM.Recurse.Config →
Bool →
(Lean.Expr → Mathlib.Tactic.AtomM Lean.Meta.Simp.Result) →
Mathlib.Tactic.AtomM.Recurse.Context → Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result | null | false |
Int.exists_prime_and_dvd | Mathlib.RingTheory.Int.Basic | ∀ {n : ℤ}, n.natAbs ≠ 1 → ∃ p, Prime p ∧ p ∣ n | null | true |
Lean.Parser.Term.optIdent.formatter | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Formatter | null | true |
Meromorphic.id | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], Meromorphic id | null | true |
TopologicalSpace.instOrderTopologyWithBot | Mathlib.Topology.Order.WithTop | ∀ {ι : Type u_1} [inst : Preorder ι] [inst_1 : TopologicalSpace ι] [inst_2 : OrderTopology ι], OrderTopology (WithBot ι) | null | true |
orderIsoSpecializationWithUpperSetTopology._proof_1 | Mathlib.Topology.Specialization | ∀ (α : Type u_1) [inst : Preorder α] {a b : α},
(Topology.WithUpperSet.toUpperSet.trans Specialization.toEquiv) a ≤
(Topology.WithUpperSet.toUpperSet.trans Specialization.toEquiv) b ↔
a ≤ b | null | false |
Sym.exists_cons_of_mem | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n : ℕ} {s : Sym α (n + 1)} {a : α}, a ∈ s → ∃ t, s = a ::ₛ t | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Basic.0.Equiv.Perm.sameCycle_subtypePerm._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric.0.Complex.regularizedHGFunCoeff_add_one_div_self._simp_1_6 | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.GrothendieckTopology.Point.Hom.noConfusionType | Mathlib.CategoryTheory.Sites.Point.Category | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{Φ₁ Φ₂ : J.Point} →
Φ₁.Hom Φ₂ →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{J' : CategoryTheory.GrothendieckTopol... | null | false |
AddMemClass.toAddSemigroup.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_4} [inst : AddSemigroup M] {A : Type u_5} [inst_1 : SetLike A M] [inst_2 : AddMemClass A M] (S : A),
AddMemClass.toAddSemigroup S = { toAdd := AddMemClass.add S, add_assoc := ⋯ } | null | true |
_private.Mathlib.Basic.PEquiv.0.PEquiv.trans_eq_none._simp_1_2 | Mathlib.Basic.PEquiv | ∀ {α : Type u} {β : Type v} {γ : Type w} (f : α ≃. β) (g : β ≃. γ) (a : α) (c : γ),
(c ∈ (f.trans g) a) = ∃ b ∈ f a, c ∈ g b | null | false |
_private.Mathlib.Algebra.Category.Grp.EpiMono.0.GrpCat.SurjectiveOfEpiAuxs.termH | Mathlib.Algebra.Category.Grp.EpiMono | Lean.ParserDescr | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.