name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
skyscraperPresheafCocone | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
(A : C) →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
(y : ↑X) →
CategoryTheory.Limits.Cocone ((TopologicalSpace.OpenNhds.inclusion y).op.comp (skyscraperPresheaf p₀ A)) |
GradedTensorProduct.instRing._proof_18 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_3} {ι : Type u_4} {A : Type u_2} {B : Type u_1} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ℬ] (n : ℕ),
IntCast.intCast ↑n = ↑n |
Fin.addNat_inj | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (m : ℕ) {i j : Fin n}, i.addNat m = j.addNat m ↔ i = j |
Lean.Elab.Term.ElabElim.State.noConfusion | Lean.Elab.App | {P : Sort u} → {t t' : Lean.Elab.Term.ElabElim.State} → t = t' → Lean.Elab.Term.ElabElim.State.noConfusionType P t t' |
Lean.Elab.Command.CoinductiveElabData.declId | Lean.Elab.Coinductive | Lean.Elab.Command.CoinductiveElabData → Lean.Syntax |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (x : Lean.Grind.AC.Var) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (x_1 : Lean.Grind.AC.Var)
(c₁_1 : Lean.Meta.Grind.AC.EqCnstr),
(Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent x c₁ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent x_1 c₁_1) =
(x = x_1 ∧ c₁ = c₁_1) |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne_preserves_ratUnits | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (id : ℕ), (f.deleteOne id).ratUnits = f.ratUnits |
IsUltrametricDist.nonarchimedeanAddGroup | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] [IsUltrametricDist M], NonarchimedeanAddGroup M |
Polynomial.natDegree_map_eq_of_isUnit_leadingCoeff | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] [Nontrivial S] (f : R →+* S),
IsUnit p.leadingCoeff → (Polynomial.map f p).natDegree = p.natDegree |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorLoop.loopWf_eq._unary | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α] {n : Type u → Type w}
[inst_5 : Monad n] [LawfulMonad n] (γ : Type u) {lift : (γ δ : Type u) → (γ → n δ) → Id γ → n δ}
[instLawfulMonadLiftFunction : Std.Internal.LawfulMonadLiftBindFunction lift] (Pl : α → γ → ForInStep γ → Prop)
(wf : Std.IteratorLoop.WellFounded (Std.Rxc.Iterator α) Id Pl) (LargeEnough : α → Prop)
(hl : ∀ (a b : α), a ≤ b → LargeEnough a → LargeEnough b) (upperBound : α)
(f : (out : α) → LargeEnough out → out ≤ upperBound → (c : γ) → n { s // Pl out c s })
(_x : (_ : γ) ×' (next : α) ×' LargeEnough next),
Std.Rxc.Iterator.instIteratorLoop.loop.wf✝ γ Pl wf LargeEnough hl upperBound _x.1 _x.2.1 ⋯ f =
if hu : _x.2.1 ≤ upperBound then do
let __do_lift ← f _x.2.1 ⋯ hu _x.1
match __do_lift with
| ⟨ForInStep.yield acc', property⟩ =>
Std.IterM.DefaultConsumers.forIn' lift γ Pl
{ internalState := { next := Std.PRange.succ? _x.2.1, upperBound := upperBound } } acc'
{ internalState := { next := Std.PRange.succ? _x.2.1, upperBound := upperBound } }.IsPlausibleIndirectOutput
⋯ fun next' h acc' => f next' ⋯ ⋯ acc'
| ⟨ForInStep.done acc', property⟩ => pure acc'
else pure _x.1 |
SSet.RelativeMorphism.precomp_homotopyClass | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y Z : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet} {C : Z.Subcomplex}
{ψ : B.toSSet ⟶ C.toSSet} (f : SSet.RelativeMorphism A B φ) (f' : SSet.RelativeMorphism B C ψ)
{φψ : A.toSSet ⟶ C.toSSet} (fac : CategoryTheory.CategoryStruct.comp φ ψ = φψ),
f'.homotopyClass.precomp f fac = (f.comp f' fac).homotopyClass |
Topology.IsInducing.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
[inst_2 : TopologicalSpace Y] [inst_3 : VAdd M X] [ContinuousVAdd M X] {g : Y → X} {N : Type u_5} [inst_5 : VAdd N Y]
[inst_6 : TopologicalSpace N] {f : N → M},
Topology.IsInducing g → Continuous f → (∀ {c : N} {x : Y}, g (c +ᵥ x) = f c +ᵥ g x) → ContinuousVAdd N Y |
_private.Lean.Language.Basic.0.Lean.Language.Snapshot.Diagnostics.mk.noConfusion | Lean.Language.Basic | {P : Sort u} →
{msgLog : Lean.MessageLog} →
{interactiveDiagsRef? : Option (IO.Ref (Option Dynamic))} →
{msgLog' : Lean.MessageLog} →
{interactiveDiagsRef?' : Option (IO.Ref (Option Dynamic))} →
{ msgLog := msgLog, interactiveDiagsRef? := interactiveDiagsRef? } =
{ msgLog := msgLog', interactiveDiagsRef? := interactiveDiagsRef?' } →
(msgLog = msgLog' → interactiveDiagsRef? = interactiveDiagsRef?' → P) → P |
Array.iter_equiv_iter_toList | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {α : Type w} {array : Array α}, array.iter.Equiv array.toList.iter |
IsRetrocompact.univ | Mathlib.Topology.Constructible | ∀ {X : Type u_2} [inst : TopologicalSpace X], IsRetrocompact Set.univ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.keys_filter._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel |
Std.Internal.IO.Async.Selectable.case._flat_ctor | Std.Internal.Async.Select | {α β : Type} →
Std.Internal.IO.Async.Selector β → (β → Std.Internal.IO.Async.Async α) → Std.Internal.IO.Async.Selectable α |
Std.DHashMap.Internal.Raw₀.getD_eq_getDₘ | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] [inst_2 : Hashable α]
(m : Std.DHashMap.Internal.Raw₀ α β) (a : α) (fallback : β a), m.getD a fallback = m.getDₘ a fallback |
Lean.Server.Watchdog.instInhabitedLogMsg.default | Lean.Server.Watchdog | Lean.Server.Watchdog.LogMsg |
ArithmeticFunction.arith_mult? | Mathlib.Tactic.ArithMult | Lean.ParserDescr |
Int.Linear.Expr.var | Init.Data.Int.Linear | Int.Linear.Var → Int.Linear.Expr |
PresheafOfModules.instAddCommGroupHom._proof_7 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (a : M₁ ⟶ M₂), zsmulRec nsmulRec 0 a = 0 |
Set.Ici.lattice._proof_5 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : Lattice α] {a : α} (a_1 b : ↑(Set.Ici a)), SemilatticeInf.inf a_1 b ≤ b |
MeasurableSet.Subtype.instCompl | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | {α : Type u_1} → [inst : MeasurableSpace α] → Compl (Subtype MeasurableSet) |
MeasureTheory.SimpleFunc.instAddMonoid | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [AddMonoid β] → AddMonoid (MeasureTheory.SimpleFunc α β) |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_map_τ₁ | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (φ : X ⟶ Y),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).map φ).τ₁ =
CategoryTheory.Functor.whiskerRight φ CategoryTheory.ShortComplex.π₁ |
Std.ExtDHashMap.isEmpty_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ ∪ m₂).isEmpty = (m₁.isEmpty && m₂.isEmpty) |
_private.Init.Data.Array.Nat.0.Array.sum_pos_iff_exists_pos_nat._simp_1_2 | Init.Data.Array.Nat | ∀ {l : List ℕ}, (0 < l.sum) = ∃ x ∈ l, 0 < x |
Sym2.gameAdd_mk'_iff | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {rα : α → α → Prop} {a₁ a₂ b₁ b₂ : α},
Sym2.GameAdd rα s(a₁, b₁) s(a₂, b₂) ↔ Prod.GameAdd rα rα (a₁, b₁) (a₂, b₂) ∨ Prod.GameAdd rα rα (b₁, a₁) (a₂, b₂) |
Simps.findProjection | Mathlib.Tactic.Simps.Basic | Lean.Name → Simps.ParsedProjectionData → List Lean.Level → Lean.CoreM Simps.ParsedProjectionData |
CategoryTheory.Equivalence.pow_neg_one | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (e : C ≌ C), e ^ (-1) = e.symm |
Sym2.attachWith | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → {P : α → Prop} → (s : Sym2 α) → (∀ a ∈ s, P a) → Sym2 { a // P a } |
HomotopicalAlgebra.Precylinder.LeftHomotopy.trans._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {P : HomotopicalAlgebra.Precylinder X} {Y : C}
{f₀ f₁ f₂ : X ⟶ Y} (h : P.LeftHomotopy f₀ f₁) {P' : HomotopicalAlgebra.Precylinder X} (h' : P'.LeftHomotopy f₁ f₂),
CategoryTheory.CategoryStruct.comp P.i₁ h.h = CategoryTheory.CategoryStruct.comp P'.i₀ h'.h |
_private.Mathlib.Topology.Algebra.Module.LinearMapPiProd.0.ContinuousLinearMap.pi_eq_zero._simp_1_2 | Mathlib.Topology.Algebra.Module.LinearMapPiProd | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
Lean.Server.GoToKind.toCtorIdx | Lean.Server.GoTo | Lean.Server.GoToKind → ℕ |
CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber_comp | Mathlib.CategoryTheory.Sites.Point.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A]
{Φ₁ Φ₂ Φ₃ : J.Point} (f : Φ₁ ⟶ Φ₂) (g : Φ₂ ⟶ Φ₃),
CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber g)
(CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber f) |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.casesOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_8 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
((p : Int.Linear.Poly) → (h : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) → motive_8 { p := p, h := h }) → motive_8 t |
OrderDual.instGroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : Group α] → Group αᵒᵈ |
AList.mem_lookup_union_middle | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {b : β a} {s₁ s₂ s₃ : AList β},
b ∈ AList.lookup a (s₁ ∪ s₃) → a ∉ s₂ → b ∈ AList.lookup a (s₁ ∪ s₂ ∪ s₃) |
CategoryTheory.Limits.ChosenPullback.hp₁._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | Lean.Syntax |
PFun.fixInduction'._proof_1 | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {b : β} (a' : α) (h : b ∈ f.fix a') (b' : β),
(f a').get ⋯ = Sum.inl b' → ∃ (h : (f a').Dom), (f a').get h = Sum.inl b' |
Int.gcd_mul_right | Init.Data.Int.Gcd | ∀ (m n k : ℤ), (m * n).gcd (k * n) = m.gcd k * n.natAbs |
_private.Lean.Environment.0.Lean.importModules.match_4 | Lean.Environment | (motive : Unit × Lean.ImportState → Sort u_1) →
(__discr : Unit × Lean.ImportState) → ((fst : Unit) → (s : Lean.ImportState) → motive (fst, s)) → motive __discr |
CoxeterSystem.isReflection_simple | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (i : B),
cs.IsReflection (cs.simple i) |
IsRealClosed.exists_eq_pow_of_nonneg | Mathlib.FieldTheory.IsRealClosed.Basic | ∀ {R : Type u} [inst : Field R] [IsRealClosed R] [inst_2 : LinearOrder R] [IsStrictOrderedRing R] {x : R},
0 ≤ x → ∀ {n : ℕ}, n ≠ 0 → ∃ r, x = r ^ n |
CategoryTheory.BasedNatIso.id_hom | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴),
(CategoryTheory.BasedNatIso.id F).hom = CategoryTheory.CategoryStruct.id F |
Primrec.of_eq | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {f g : α → σ},
Primrec f → (∀ (n : α), f n = g n) → Primrec g |
FirstOrder.Language.Symbols | Mathlib.ModelTheory.Basic | FirstOrder.Language → Type (max u v) |
ProbabilityTheory.Kernel.comap_map_comm | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4} {δ : Type u_5}
{mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} (κ : ProbabilityTheory.Kernel β γ) {f : α → β} {g : γ → δ}
(hf : Measurable f), Measurable g → (κ.map g).comap f hf = (κ.comap f hf).map g |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.iso_hom_naturality_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} (X : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} X] (S : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X)
{x x' : X} (f : x ⟶ x') {Z : B} (h : G.obj (S.snd.obj x') ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map (S.fst.map f)) (CategoryTheory.CategoryStruct.comp (S.iso.hom.app x') h) =
CategoryTheory.CategoryStruct.comp (S.iso.hom.app x) (CategoryTheory.CategoryStruct.comp (G.map (S.snd.map f)) h) |
Convex.combo_interior_closure_subset_interior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] {s : Set E},
Convex 𝕜 s → ∀ {a b : 𝕜}, 0 < a → 0 ≤ b → a + b = 1 → a • interior s + b • closure s ⊆ interior s |
Group.ofRightAxioms._proof_4 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : Inv G] [inst_2 : One G],
(∀ (a b c : G), a * b * c = a * (b * c)) →
(∀ (a : G), a * 1 = a) → (∀ (a : G), a * a⁻¹ = 1) → (∀ (a : G), a⁻¹ * a = 1) → ∀ (a : G), 1 * a = a |
_private.Mathlib.Algebra.Group.Semiconj.Basic.0.SemiconjBy.inv_inv_symm_iff._simp_1_2 | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_3} [inst : InvolutiveInv G] {a b : G}, (a⁻¹ = b⁻¹) = (a = b) |
Lean.AssocList.brecOn.go | Lean.Data.AssocList | {α : Type u} →
{β : Type v} →
{motive : Lean.AssocList α β → Sort u_1} →
(t : Lean.AssocList α β) →
((t : Lean.AssocList α β) → Lean.AssocList.below t → motive t) → motive t ×' Lean.AssocList.below t |
disjoint_nhds_atBot_iff._simp_1 | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Preorder α] [ClosedIicTopology α] {a : α},
Disjoint (nhds a) Filter.atBot = ¬IsBot a |
RingPreordering.instHasIdealSupport | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {F : Type u_2} [inst : Field F] (P : RingPreordering F), P.HasIdealSupport |
CategoryTheory.FintypeCat.isoQuotientStabilizerOfIsConnected._proof_3 | Mathlib.CategoryTheory.Galois.Examples | ∀ {G : Type u_1} [inst : Group G] (X : Action FintypeCat G) (x : X.V.carrier),
MulAction.QuotientAction G (MulAction.stabilizer G x) |
Lean.CollectLevelMVars.State.visitedLevel | Lean.Util.CollectLevelMVars | Lean.CollectLevelMVars.State → Lean.LevelSet |
StarSubalgebra.range_le | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A),
Set.range ⇑(algebraMap R A) ≤ ↑S |
CategoryTheory.ShortComplex.SnakeInput.h₃τ₁._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair S.v₁₂ 0) CategoryTheory.ShortComplex.π₁ |
IsAddTorsionFree.nsmul_eq_zero_iff' | Mathlib.Algebra.Group.Torsion | ∀ {M : Type u_1} [inst : AddMonoid M] [IsAddTorsionFree M] {n : ℕ} {a : M}, a ≠ 0 → (n • a = 0 ↔ n = 0) |
BitVec.add_right_eq_self | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x + y = x ↔ y = 0#w |
Lean.Compiler.LCNF.ImpureType.object | Lean.Compiler.LCNF.Types | Lean.Expr |
_private.Mathlib.Order.TypeTags.0.WithTop.instRepr.match_1.splitter | Mathlib.Order.TypeTags | {α : Type u_1} →
(motive : WithTop α → Sort u_2) → (o : WithTop α) → (Unit → motive none) → ((a : α) → motive (some a)) → motive o |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.Const.insertMany.match_1 | Std.Data.DHashMap.Internal.Defs | {α : Type u_1} →
{β : Type u_2} → (motive : α × β → Sort u_3) → (x : α × β) → ((a : α) → (b : β) → motive (a, b)) → motive x |
_private.Lean.Meta.AbstractMVars.0.Lean.Meta.AbstractMVars.abstractLevelMVars.match_1 | Lean.Meta.AbstractMVars | (motive : Option Lean.Level → Sort u_1) →
(x : Option Lean.Level) → ((u : Lean.Level) → motive (some u)) → (Unit → motive none) → motive x |
Submonoid.map_comap_eq | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid N), Submonoid.map f (Submonoid.comap f S) = S ⊓ MonoidHom.mrange f |
AlgEquiv.piMulOpposite | Mathlib.Algebra.Algebra.Pi | (R : Type u_3) →
{ι : Type u_4} →
(A₁ : ι → Type u_5) →
[inst : CommSemiring R] →
[inst_1 : (i : ι) → Semiring (A₁ i)] →
[inst_2 : (i : ι) → Algebra R (A₁ i)] → ((i : ι) → A₁ i)ᵐᵒᵖ ≃ₐ[R] (i : ι) → (A₁ i)ᵐᵒᵖ |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State.annotations | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.State → Lean.PrettyPrinter.Delaborator.OptionsPerPos |
groupCohomology.mapShortComplexH2_id_comp_assoc | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B C : Rep k G} (φ : A ⟶ B) (ψ : B ⟶ C)
{Z : CategoryTheory.ShortComplex (ModuleCat k)} (h : groupCohomology.shortComplexH2 C ⟶ Z),
CategoryTheory.CategoryStruct.comp
(groupCohomology.mapShortComplexH2 (MonoidHom.id G) (CategoryTheory.CategoryStruct.comp φ ψ)) h =
CategoryTheory.CategoryStruct.comp (groupCohomology.mapShortComplexH2 (MonoidHom.id G) φ)
(CategoryTheory.CategoryStruct.comp (groupCohomology.mapShortComplexH2 (MonoidHom.id G) ψ) h) |
Finsupp.lcomapDomain._proof_1 | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] {β : Type u_3} (f : α → β) (hf : Function.Injective f)
(x y : β →₀ M), Finsupp.comapDomain f (x + y) ⋯ = Finsupp.comapDomain f x ⋯ + Finsupp.comapDomain f y ⋯ |
_private.Mathlib.Algebra.Exact.0.LinearEquiv.conj_exact_iff_exact._simp_1_1 | Mathlib.Algebra.Exact | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {P : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] {f : M →ₗ[R] N} {g : N →ₗ[R] P}, Function.Exact ⇑f ⇑g = (g.ker = f.range) |
Polynomial.lt_rootMultiplicity_of_isRoot_iterate_derivative_of_mem_nonZeroDivisors' | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} {t : R} {n : ℕ},
p ≠ 0 →
(∀ m ≤ n, ((⇑Polynomial.derivative)^[m] p).IsRoot t) →
(∀ m ≤ n, m ≠ 0 → ↑m ∈ nonZeroDivisors R) → n < Polynomial.rootMultiplicity t p |
Std.LawfulOrderLeftLeaningMin.of_eq | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Min α] [inst_2 : DecidableLE α],
(∀ (a b : α), a ⊓ b = if a ≤ b then a else b) → Std.LawfulOrderLeftLeaningMin α |
ByteSlice.contains | Std.Data.ByteSlice | ByteSlice → UInt8 → Bool |
Stream'.Seq1.ret.eq_1 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (a : α), Stream'.Seq1.ret a = (a, Stream'.Seq.nil) |
SSet.Edge.edge | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | {X : SSet} →
{x₀ x₁ : X.obj (Opposite.op (SimplexCategory.mk 0))} → SSet.Edge x₀ x₁ → X.obj (Opposite.op (SimplexCategory.mk 1)) |
CategoryTheory.Adjunction.fullyFaithfulROfCompIsoId | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{L : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} → (L ⊣ R) → (R.comp L ≅ CategoryTheory.Functor.id D) → R.FullyFaithful |
Lean.Meta.RefinedDiscrTree.Trie.pending | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} → Lean.Meta.RefinedDiscrTree.Trie α → Array (Lean.Meta.RefinedDiscrTree.LazyEntry × α) |
AlgebraicGeometry.QuasiCompact.of_comp | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.QuasiCompact (CategoryTheory.CategoryStruct.comp f g)] [AlgebraicGeometry.QuasiSeparated g],
AlgebraicGeometry.QuasiCompact f |
CategoryTheory.Monad.beckAlgebraCoequalizer._proof_2 | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} (X : T.Algebra)
(s :
CategoryTheory.Limits.Cofork (CategoryTheory.Monad.FreeCoequalizer.topMap X)
(CategoryTheory.Monad.FreeCoequalizer.bottomMap X)),
CategoryTheory.CategoryStruct.comp (T.map s.π.f)
(((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj s.pt).obj
CategoryTheory.Limits.WalkingParallelPair.one).a =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair (CategoryTheory.Monad.FreeCoequalizer.topMap X)
(CategoryTheory.Monad.FreeCoequalizer.bottomMap X)).obj
CategoryTheory.Limits.WalkingParallelPair.one).a
s.π.f |
CategoryTheory.Iso.isoCongr | Mathlib.CategoryTheory.HomCongr | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {X₁ Y₁ X₂ Y₂ : C} → (X₁ ≅ X₂) → (Y₁ ≅ Y₂) → (X₁ ≅ Y₁) ≃ (X₂ ≅ Y₂) |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.sum_div_nat_floor_pow_sq_le_div_sq._simp_1_9 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Trivial.0.ValuativeRel.eq_trivialRel_of_compatible_one._simp_1_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Trivial | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] [inst_2 : Nontrivial R]
[inst_3 : NoZeroDivisors R] [inst_4 : DecidablePred fun x => x = 0] (x : R), (1 x ≤ 1) = True |
Lean.JsonNumber.mk.sizeOf_spec | Lean.Data.Json.Basic | ∀ (mantissa : ℤ) (exponent : ℕ),
sizeOf { mantissa := mantissa, exponent := exponent } = 1 + sizeOf mantissa + sizeOf exponent |
_private.Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory.0.CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.inverse._proof_7 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.Functor C (CategoryTheory.Comon D)} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.IsComonHom
{ app := fun X_1 => ((CategoryTheory.CategoryStruct.comp f g).app X_1).hom, naturality := ⋯ } |
_private.Mathlib.Algebra.Module.ZLattice.Basic.0.ZSpan.fundamentalDomain_measurableSet._simp_1_5 | Mathlib.Algebra.Module.ZLattice.Basic | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
MeasureTheory.Measure.conv_zero | Mathlib.MeasureTheory.Group.Convolution | ∀ {M : Type u_1} [inst : AddMonoid M] [inst_1 : MeasurableSpace M] (μ : MeasureTheory.Measure M), μ.conv 0 = 0 |
spectrum.subset_circle_of_unitary | Mathlib.Analysis.CStarAlgebra.Spectrum | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] {E : Type u_2} [inst_1 : NormedRing E] [inst_2 : StarRing E] [CStarRing E]
[inst_4 : NormedAlgebra 𝕜 E] [CompleteSpace E] {u : E}, u ∈ unitary E → spectrum 𝕜 u ⊆ Metric.sphere 0 1 |
IsGaloisGroup.of_mulEquiv | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ {G : Type u_1} {A : Type u_2} {B : Type u_4} [inst : Group G] [inst_1 : CommSemiring A] [inst_2 : Semiring B]
[inst_3 : Algebra A B] [inst_4 : MulSemiringAction G B] [hG : IsGaloisGroup G A B] {H : Type u_5} [inst_5 : Group H]
[inst_6 : MulSemiringAction H B] (e : H ≃* G), (∀ (h : H) (x : B), e h • x = h • x) → IsGaloisGroup H A B |
Lean.Server.RequestContext.rec | Lean.Server.Requests | {motive : Lean.Server.RequestContext → Sort u} →
((rpcSessions : Std.TreeMap UInt64 (IO.Ref Lean.Server.FileWorker.RpcSession) compare) →
(doc : Lean.Server.FileWorker.EditableDocument) →
(hLog : IO.FS.Stream) →
(initParams : Lean.Lsp.InitializeParams) →
(cancelTk : Lean.Server.RequestCancellationToken) →
(serverRequestEmitter : Lean.Server.ServerRequestEmitter) →
motive
{ rpcSessions := rpcSessions, doc := doc, hLog := hLog, initParams := initParams,
cancelTk := cancelTk, serverRequestEmitter := serverRequestEmitter }) →
(t : Lean.Server.RequestContext) → motive t |
Classical.exists_or_forall_not | Init.Classical | ∀ {α : Sort u_1} (P : α → Prop), (∃ a, P a) ∨ ∀ (a : α), ¬P a |
Polynomial.UniversalFactorizationRing.factor₁_mul_factor₂ | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
↑(Polynomial.UniversalFactorizationRing.factor₁ m k hn p) *
↑(Polynomial.UniversalFactorizationRing.factor₂ m k hn p) =
↑(Polynomial.UniversalFactorizationRing.monicDegreeEq m k hn p) |
LinearMap.BilinForm.toMatrixAux_apply | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} (B : LinearMap.BilinForm R₁ M₁) (b : n → M₁) (i j : n),
(LinearMap.BilinForm.toMatrixAux b) B i j = (B (b i)) (b j) |
affineSpan_eq_top_of_nonempty_interior | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] {s : Set V},
(interior ((convexHull ℝ) s)).Nonempty → affineSpan ℝ s = ⊤ |
_private.Std.Data.HashMap.Lemmas.0.Std.HashMap.mem_toArray_iff_getKey?_eq_some_and_getElem?_eq_some._simp_1_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β}, m.toArray = m.toList.toArray |
SimpleGraph.deleteEdges_of_subset_diagSet | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} {s : Set (Sym2 V)} (G : SimpleGraph V), s ⊆ Sym2.diagSet → G.deleteEdges s = G |
hasDerivAt_tsum | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} {𝕜 : Type u_3} {F : Type u_5} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [CompleteSpace F] {u : α → ℝ} [inst_4 : NormedSpace 𝕜 F] {g g' : α → 𝕜 → F} {y₀ : 𝕜},
Summable u →
(∀ (n : α) (y : 𝕜), HasDerivAt (g n) (g' n y) y) →
(∀ (n : α) (y : 𝕜), ‖g' n y‖ ≤ u n) →
(Summable fun n => g n y₀) → ∀ (y : 𝕜), HasDerivAt (fun z => ∑' (n : α), g n z) (∑' (n : α), g' n y) y |
Lean.Grind.CommRing.Poly.mul_nc.go.eq_def | Init.Grind.Ring.CommSolver | ∀ (p₂ p₁ acc : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.mul_nc.go p₂ p₁ acc =
match p₁ with
| Lean.Grind.CommRing.Poly.num k => acc.combine (Lean.Grind.CommRing.Poly.mulConst k p₂)
| Lean.Grind.CommRing.Poly.add k m p₁ =>
Lean.Grind.CommRing.Poly.mul_nc.go p₂ p₁ (acc.combine (Lean.Grind.CommRing.Poly.mulMon_nc k m p₂)) |
Finset.instGeneralizedBooleanAlgebra._proof_7 | Mathlib.Data.Finset.SDiff | ∀ {α : Type u_1} [inst : DecidableEq α] (a b : Finset α), a ⊓ b ⊓ a \ b = ⊥ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.