name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CoalgEquiv.instEquivLike._proof_1 | Mathlib.RingTheory.Coalgebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid A]
[inst_2 : AddCommMonoid B] [inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : CoalgebraStruct R A]
[inst_6 : CoalgebraStruct R B] (x x_1 : A ≃ₗc[R] B), x.toFun = x_1.toFun → x.invFun = x_1.invFun → x = x_1 |
List.mapIdx_singleton | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {a : α}, List.mapIdx f [a] = [f 0 a] |
instLTOption | Init.Data.Option.Basic | {α : Type u_1} → [LT α] → LT (Option α) |
Lean.JsonRpc.RequestID.null.sizeOf_spec | Lean.Data.JsonRpc | sizeOf Lean.JsonRpc.RequestID.null = 1 |
HomogeneousPow.rec | Init.Prelude | {α : Type u} →
{motive : HomogeneousPow α → Sort u_1} →
((pow : α → α → α) → motive { pow := pow }) → (t : HomogeneousPow α) → motive t |
TensorProduct.instBialgebra._proof_18 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_4) (A : Type u_2) (B : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : Semiring A] [inst_3 : Semiring B] [inst_4 : Bialgebra S A] [inst_5 : Bialgebra R B] [inst_6 : Algebra R A]
[inst_7 : Algebra R S] [inst_8 : IsScalarTower R S A],
⇑CoalgebraStruct.comul =
⇑((↑(Algebra.TensorProduct.tensorTensorTensorComm R S R S A A B B)).comp
(Algebra.TensorProduct.map (Bialgebra.comulAlgHom S A) (Bialgebra.comulAlgHom R B))).toLinearMap →
∀ {x y : TensorProduct R A B}, CoalgebraStruct.comul (x * y) = CoalgebraStruct.comul x * CoalgebraStruct.comul y |
Std.Iterators.PostconditionT.bind | Init.Data.Iterators.PostconditionMonad | {m : Type w → Type w'} →
[Monad m] →
{α β : Type w} →
Std.Iterators.PostconditionT m α → (α → Std.Iterators.PostconditionT m β) → Std.Iterators.PostconditionT m β |
Perfection.lift._proof_12 | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (R : Type u_2) [inst : CommSemiring R] [inst_1 : CharP R p]
[inst_2 : PerfectRing R p] (S : Type u_1) [inst_3 : CommSemiring S] (f : R →+* S) (x x_1 : R) (n : ℕ),
f ((⇑↑(frobeniusEquiv R p).symm)^[n + 1] (x + x_1)) ^ p = f ((⇑↑(frobeniusEquiv R p).symm)^[n] (x + x_1)) |
Polynomial.Splits.comp_of_degree_le_one | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Field R] {f g : Polynomial R}, f.Splits → g.degree ≤ 1 → (f.comp g).Splits |
Lean.Parser.ParserContextCore.quotDepth._inherited_default | Lean.Parser.Types | ℕ |
AddSubmonoid.center.addCommMonoid | Mathlib.GroupTheory.Submonoid.Center | {M : Type u_1} → [inst : AddMonoid M] → AddCommMonoid ↥(AddSubmonoid.center M) |
_private.Init.Data.Dyadic.Basic.0.Dyadic.neg_ofIntWithPrec._simp_1_2 | Init.Data.Dyadic.Basic | ∀ {a : ℤ}, (-a = 0) = (a = 0) |
Lean.Elab.initFn._@.Lean.Elab.Util.1238572749._hygCtx._hyg.2 | Lean.Elab.Util | IO (Lean.KeyedDeclsAttribute Lean.Macro) |
Lean.Parser.simprocPatternBuiltin | Init.Simproc | Lean.ParserDescr |
MeasureTheory.VectorMeasure.restrict_le_restrict_subset | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddCommMonoid M]
[inst_2 : PartialOrder M] (v w : MeasureTheory.VectorMeasure α M) {i j : Set α},
MeasurableSet i → v.restrict i ≤ w.restrict i → j ⊆ i → v.restrict j ≤ w.restrict j |
_private.Mathlib.Algebra.Ring.Associator.0.associator_op._simp_1_2 | Mathlib.Algebra.Ring.Associator | ∀ {α : Type u_1} [inst : Sub α] (x y : αᵐᵒᵖ), MulOpposite.unop x - MulOpposite.unop y = MulOpposite.unop (x - y) |
Lean.Parser.Command.elab._regBuiltin.Lean.Parser.Command.elabTail.parenthesizer_19 | Lean.Parser.Syntax | IO Unit |
NumberField.mixedEmbedding.fundamentalCone.expMap_symm_apply | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.realSpace K)
(w : NumberField.InfinitePlace K),
↑NumberField.mixedEmbedding.fundamentalCone.expMap.symm x w = ↑w.mult * Real.log (x w) |
Topology.RelCWComplex.mkFiniteType_map | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] (C : Set X) (D : outParam (Set X)) (cell : ℕ → Type u)
(map : (n : ℕ) → cell n → PartialEquiv (Fin n → ℝ) X) (finite_cell : ∀ (n : ℕ), Finite (cell n))
(source_eq : ∀ (n : ℕ) (i : cell n), (map n i).source = Metric.ball 0 1)
(continuousOn : ∀ (n : ℕ) (i : cell n), ContinuousOn (↑(map n i)) (Metric.closedBall 0 1))
(continuousOn_symm : ∀ (n : ℕ) (i : cell n), ContinuousOn (↑(map n i).symm) (map n i).target)
(pairwiseDisjoint' : Set.univ.PairwiseDisjoint fun ni => ↑(map ni.fst ni.snd) '' Metric.ball 0 1)
(disjointBase' : ∀ (n : ℕ) (i : cell n), Disjoint (↑(map n i) '' Metric.ball 0 1) D)
(mapsTo :
∀ (n : ℕ) (i : cell n),
Set.MapsTo (↑(map n i)) (Metric.sphere 0 1) (D ∪ ⋃ m, ⋃ (_ : m < n), ⋃ j, ↑(map m j) '' Metric.closedBall 0 1))
(closed' :
∀ A ⊆ C,
(∀ (n : ℕ) (j : cell n), IsClosed (A ∩ ↑(map n j) '' Metric.closedBall 0 1)) ∧ IsClosed (A ∩ D) → IsClosed A)
(isClosedBase : IsClosed D) (union' : D ∪ ⋃ n, ⋃ j, ↑(map n j) '' Metric.closedBall 0 1 = C) (n : ℕ) (i : cell n),
Topology.RelCWComplex.map n i = map n i |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor_map_app_hom_hom | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D]
{X Y : CategoryTheory.CommMon (CategoryTheory.Functor C D)} (f : X ⟶ Y) (X_1 : C),
((CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.functor.map f).app X_1).hom.hom = f.hom.hom.app X_1 |
Function.uncurry.eq_1 | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_2} {φ : Sort u_3} (f : α → β → φ) (a : α × β), Function.uncurry f a = f a.1 a.2 |
_private.Mathlib.Order.Filter.Basic.0.Filter.iInf_neBot_of_directed'._simp_1_1 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x |
IsLocalization.Away.integralClosure | Mathlib.RingTheory.Localization.Integral | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] [inst_2 : Algebra R S] {Rf : Type u_5}
{Sf : Type u_6} [inst_3 : CommRing Rf] [inst_4 : CommRing Sf] [inst_5 : Algebra R Rf] [inst_6 : Algebra S Sf]
[inst_7 : Algebra Rf Sf] [inst_8 : Algebra R Sf] [IsScalarTower R S Sf] [inst_10 : IsScalarTower R Rf Sf] (f : R)
[IsLocalization.Away f Rf] [IsLocalization.Away ((algebraMap R S) f) Sf]
[inst_13 : Algebra ↥(integralClosure R S) ↥(integralClosure Rf Sf)]
[IsScalarTower (↥(integralClosure R S)) (↥(integralClosure Rf Sf)) Sf]
[IsScalarTower R ↥(integralClosure R S) ↥(integralClosure Rf Sf)],
IsLocalization.Away ((algebraMap R ↥(integralClosure R S)) f) ↥(integralClosure Rf Sf) |
Sat.Literal.pos.sizeOf_spec | Mathlib.Tactic.Sat.FromLRAT | ∀ (a : ℕ), sizeOf (Sat.Literal.pos a) = 1 + sizeOf a |
Std.Rxi.Iterator.instLawfulIteratorLoop | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
{n : Type u → Type w} [inst_2 : Monad n] [LawfulMonad n], Std.LawfulIteratorLoop (Std.Rxi.Iterator α) Id n |
_private.Init.Grind.Ring.Field.0.Lean.Grind.Field.natCast_div_of_dvd._proof_1_1 | Init.Grind.Ring.Field | ∀ {y : ℕ}, ¬y = 0 → ¬0 < y → False |
neg_eq_self | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : AddGroup G] [IsAddTorsionFree G] {a : G}, -a = a ↔ a = 0 |
PiTensorProduct.distribMulAction'._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {R₁ : Type u_4} {s : ι → Type u_3}
[inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] [inst_3 : Monoid R₁]
[inst_4 : DistribMulAction R₁ R] [inst_5 : SMulCommClass R₁ R R] (r r' : R₁) {r'' : R} {f : (i : ι) → s i},
(r * r') • PiTensorProduct.tprodCoeff R r'' f = r • r' • PiTensorProduct.tprodCoeff R r'' f |
List.minimum_cons | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] (a : α) (l : List α), (a :: l).minimum = min (↑a) l.minimum |
List.SortedLT | Mathlib.Data.List.Sort | {α : Type u_1} → [Preorder α] → List α → Prop |
Lean.PrettyPrinter.Delaborator.delabAttribute | Lean.PrettyPrinter.Delaborator.Basic | Lean.KeyedDeclsAttribute Lean.PrettyPrinter.Delaborator.Delab |
Lean.Elab.Term.StructInst.FieldView.mk.noConfusion | Lean.Elab.StructInst | {P : Sort u} →
{ref : Lean.Syntax} →
{lhs : List Lean.Elab.Term.StructInst.FieldLHS} →
{val : Lean.Term} →
{ref' : Lean.Syntax} →
{lhs' : List Lean.Elab.Term.StructInst.FieldLHS} →
{val' : Lean.Term} →
{ ref := ref, lhs := lhs, val := val } = { ref := ref', lhs := lhs', val := val' } →
(ref = ref' → lhs = lhs' → val = val' → P) → P |
Int.mul_tdiv_cancel_left | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} (b : ℤ), a ≠ 0 → (a * b).tdiv a = b |
TopologicalSpace.NonemptyCompacts.instOrderTopOfCompactSpaceOfNonempty._proof_2 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : Nonempty α], ↑⊤ = ↑⊤ |
Lean.Lsp.instToJsonTextDocumentIdentifier.toJson | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentIdentifier → Lean.Json |
Lean.Server.Test.Runner.Client.instToJsonHighlightedSubexprInfo.toJson | Lean.Server.Test.Runner | Lean.Server.Test.Runner.Client.HighlightedSubexprInfo → Lean.Json |
MulEquiv.instFintype._proof_2 | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] [inst_2 : DecidableEq β] [inst_3 : Fintype α]
(a a' : α ≃ β),
∀ b ∈ (fun e => if h : ∀ (a b : α), e (a * b) = e a * e b then some { toEquiv := e, map_mul' := h } else none) a,
b ∈ (fun e => if h : ∀ (a b : α), e (a * b) = e a * e b then some { toEquiv := e, map_mul' := h } else none) a' →
a = a' |
Quot.out | Mathlib.Data.Quot | {α : Sort u_1} → {r : α → α → Prop} → Quot r → α |
Lean.PArray | Lean.Data.PersistentArray | Type u → Type u |
AddSubgroup.orderIsoAddCon._proof_7 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {a b : { N // N.Normal }},
{ toFun := fun N => QuotientAddGroup.con ↑N, invFun := fun c => ⟨c.addSubgroup, ⋯⟩, left_inv := ⋯, right_inv := ⋯ }
a ≤
{ toFun := fun N => QuotientAddGroup.con ↑N, invFun := fun c => ⟨c.addSubgroup, ⋯⟩, left_inv := ⋯,
right_inv := ⋯ }
b ↔
a ≤ b |
HasDerivAt.congr_deriv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' g' : F} {x : 𝕜}, HasDerivAt f f' x → f' = g' → HasDerivAt f g' x |
AddUnits.map._proof_6 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : AddMonoid N] (f : M →+ N) (x x_1 : AddUnits M),
{ val := f ↑(x + x_1), neg := f (x + x_1).neg, val_neg := ⋯, neg_val := ⋯ } =
{ val := f ↑x, neg := f x.neg, val_neg := ⋯, neg_val := ⋯ } +
{ val := f ↑x_1, neg := f x_1.neg, val_neg := ⋯, neg_val := ⋯ } |
CategoryTheory.HasClassifier.reflectsIsomorphisms | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.HasClassifier C] (D : Type u₀)
[inst_2 : CategoryTheory.Category.{v₀, u₀} D] (F : CategoryTheory.Functor C D) [F.Faithful], F.ReflectsIsomorphisms |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.Functor.copyObj._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 : CategoryTheory.Functor C D) (obj : C → D)
(e : (X : C) → F.obj X ≅ obj X) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (e X).inv
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.comp f g)) (e Z).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (e X).inv (CategoryTheory.CategoryStruct.comp (F.map f) (e Y).hom))
(CategoryTheory.CategoryStruct.comp (e Y).inv (CategoryTheory.CategoryStruct.comp (F.map g) (e Z).hom)) |
PMF.mem_support_ofMultiset_iff | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_1} {s : Multiset α} (hs : s ≠ 0) (a : α), a ∈ (PMF.ofMultiset s hs).support ↔ a ∈ s.toFinset |
Matrix.vec2_add | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} [inst : Add α] (a₀ a₁ b₀ b₁ : α), ![a₀, a₁] + ![b₀, b₁] = ![a₀ + b₀, a₁ + b₁] |
_private.Mathlib.Data.EReal.Basic.0.Mathlib.Meta.Positivity.evalRealToEReal._proof_2 | Mathlib.Data.EReal.Basic | ∀ (α : Q(Type)) (_pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$_pα» =Q instPartialOrderEReal)),
«$_pα» =Q instPartialOrderEReal |
_private.Lean.Elab.RecAppSyntax.0.Lean.getRecAppSyntax?.match_1 | Lean.Elab.RecAppSyntax | (motive : Option Lean.DataValue → Sort u_1) →
(x : Option Lean.DataValue) →
((stx : Lean.Syntax) → motive (some (Lean.DataValue.ofSyntax stx))) →
((x : Option Lean.DataValue) → motive x) → motive x |
CategoryTheory.isCoseparator_of_isLimit_fan | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasZeroMorphisms C] {β : Type w}
{f : β → C},
(CategoryTheory.ObjectProperty.ofObj f).IsCoseparating →
∀ {c : CategoryTheory.Limits.Fan f} (hc : CategoryTheory.Limits.IsLimit c), CategoryTheory.IsCoseparator c.pt |
Lean.Compiler.LCNF.CSE.State.mk.injEq | Lean.Compiler.LCNF.CSE | ∀ (map : Lean.PHashMap Lean.Expr Lean.FVarId) (subst : Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure)
(map_1 : Lean.PHashMap Lean.Expr Lean.FVarId) (subst_1 : Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure),
({ map := map, subst := subst } = { map := map_1, subst := subst_1 }) = (map = map_1 ∧ subst = subst_1) |
Lean.Widget.HighlightMatchesParams.mk.inj | Lean.Server.FileWorker.WidgetRequests | ∀ {query : String} {msg : Lean.Widget.InteractiveMessage} {query_1 : String} {msg_1 : Lean.Widget.InteractiveMessage},
{ query := query, msg := msg } = { query := query_1, msg := msg_1 } → query = query_1 ∧ msg = msg_1 |
AddCon.addGroup._proof_4 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : AddGroup M] (c : AddCon M) (x : M) (x_1 : ℕ), Quotient.mk'' (x_1 • x) = Quotient.mk'' (x_1 • x) |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_121 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Subtype.coind.congr_simp | Mathlib.Data.Set.Operations | ∀ {α : Sort u_4} {β : Sort u_5} (f f_1 : α → β) (e_f : f = f_1) {p : β → Prop} (h : ∀ (a : α), p (f a)) (a a_1 : α),
a = a_1 → Subtype.coind f h a = Subtype.coind f_1 ⋯ a_1 |
AbstractSimplicialComplex.instCompleteSemilatticeInf._proof_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ {ι : Type u_1} (x : Set (AbstractSimplicialComplex ι)), sInf x ∈ lowerBounds x ∧ sInf x ∈ upperBounds (lowerBounds x) |
Std.TransCmp.lt_of_isLE_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
(cmp a b).isLE = true → cmp b c = Ordering.lt → cmp a c = Ordering.lt |
Modular.«_aux_Mathlib_NumberTheory_Modular___macroRules_Modular_term𝒟ᵒ_1» | Mathlib.NumberTheory.Modular | Lean.Macro |
_private.Lean.Meta.Injective.0.Lean.Meta.MkHInjTypeResult.mk._flat_ctor | Lean.Meta.Injective | Lean.Expr → List Lean.Level → ℕ → Lean.Meta.MkHInjTypeResult✝ |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_603 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Profinite.NobelingProof.C0 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | {I : Type u} →
Set (I → Bool) →
[inst : LinearOrder I] →
[inst_1 : WellFoundedLT I] → {o : Ordinal.{u}} → (o < Ordinal.type fun x1 x2 => x1 < x2) → Set (I → Bool) |
WithLp.linearEquiv_apply | Mathlib.Analysis.Normed.Lp.WithLp | ∀ (p : ENNReal) (K : Type u_1) (V : Type u_4) [inst : Semiring K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(a : WithLp p V), (WithLp.linearEquiv p K V) a = (WithLp.addEquiv p V).toFun a |
Subspace.top_mem_of_biUnion_eq_univ | Mathlib.GroupTheory.CosetCover | ∀ {k : Type u_1} {E : Type u_2} [inst : DivisionRing k] [Infinite k] [inst_2 : AddCommGroup E] [inst_3 : Module k E]
{s : Finset (Subspace k E)}, ⋃ p ∈ s, ↑p = Set.univ → ⊤ ∈ s |
Lean.Order.FlatOrder | Init.Internal.Order.Basic | {α : Sort u} → α → Sort u |
CategoryTheory.Limits.Sigma.π.hcongr_8 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ (C C' : Type u),
C = C' →
∀ (inst : CategoryTheory.Category.{v, u} C) (inst' : CategoryTheory.Category.{v, u} C'),
inst ≍ inst' →
∀ (inst_1 : CategoryTheory.Limits.HasZeroMorphisms C) (inst'_1 : CategoryTheory.Limits.HasZeroMorphisms C'),
inst_1 ≍ inst'_1 →
∀ (β β' : Type w),
β = β' →
∀ (inst_2 : DecidableEq β) (inst'_2 : DecidableEq β'),
inst_2 ≍ inst'_2 →
∀ (f : β → C) (f' : β' → C'),
f ≍ f' →
∀ (inst_3 : CategoryTheory.Limits.HasCoproduct f)
(inst'_3 : CategoryTheory.Limits.HasCoproduct f'),
inst_3 ≍ inst'_3 →
∀ (b : β) (b' : β'),
b ≍ b' → CategoryTheory.Limits.Sigma.π f b ≍ CategoryTheory.Limits.Sigma.π f' b' |
Polynomial.smeval_at_natCast | Mathlib.Algebra.Polynomial.Smeval | ∀ {S : Type u_2} [inst : NonAssocSemiring S] [inst_1 : Pow S ℕ] [NatPowAssoc S] (q : Polynomial ℕ) (n : ℕ),
q.smeval ↑n = ↑(q.smeval n) |
Ideal.quotEquivPowQuotPowSuccEquiv | Mathlib.RingTheory.Ideal.IsPrincipalPowQuotient | {R : Type u_1} →
[inst : CommRing R] →
[IsDomain R] → {I : Ideal R} → Submodule.IsPrincipal I → I ≠ ⊥ → (n : ℕ) → R ⧸ I ≃ ↥(I ^ n) ⧸ I • ⊤ |
CochainComplex.singleFunctors._proof_7 | Mathlib.Algebra.Homology.HomotopyCategory.SingleFunctors | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (a : ℤ),
CategoryTheory.NatIso.ofComponents
(fun X => HomologicalComplex.Hom.isoOfComponents (fun i => CategoryTheory.eqToIso ⋯) ⋯) ⋯ =
(HomologicalComplex.single C (ComplexShape.up ℤ) a).isoWhiskerLeft
(CategoryTheory.shiftFunctorZero (CochainComplex C ℤ) ℤ) |
_private.Mathlib.AlgebraicGeometry.Restrict.0.AlgebraicGeometry.Scheme.Opens.nonempty_iff._simp_1_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {α : Sort u_3} {p : α → Prop}, Nonempty (Subtype p) = ∃ a, p a |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.mkCtor | Lean.Elab.Structure | Lean.Elab.Command.Structure.StructView →
Lean.Elab.Command.ElabHeaderResult → Array Lean.Expr → Lean.Elab.Command.Structure.StructElabM✝ Lean.Constructor |
MonoidHom.comp_noncommCoprod | Mathlib.GroupTheory.NoncommCoprod | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass N] [inst_2 : Monoid P]
(f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) {Q : Type u_4} [inst_3 : Monoid Q]
(h : P →* Q), h.comp (f.noncommCoprod g comm) = (h.comp f).noncommCoprod (h.comp g) ⋯ |
_private.Init.PropLemmas.0.exists_and_self.match_1_3 | Init.PropLemmas | ∀ (P : Prop) (Q : P → Prop) (motive : (∃ (p : P), Q p) → Prop) (x : ∃ (p : P), Q p),
(∀ (p : P) (q : Q p), motive ⋯) → motive x |
Lean.Elab.Command.State.noConfusion | Lean.Elab.Command | {P : Sort u} → {t t' : Lean.Elab.Command.State} → t = t' → Lean.Elab.Command.State.noConfusionType P t t' |
CategoryTheory.GrpObj.eq_lift_inv_left | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj B] (f g h : A ⟶ B),
f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.comp g CategoryTheory.GrpObj.inv)
h)
CategoryTheory.MonObj.mul ↔
CategoryTheory.CategoryStruct.comp (CategoryTheory.CartesianMonoidalCategory.lift g f) CategoryTheory.MonObj.mul = h |
IndepMatroid.ofBddAugment_E | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} (E : Set α) (Indep : Set α → Prop) (indep_empty : Indep ∅)
(indep_subset : ∀ ⦃I J : Set α⦄, Indep J → I ⊆ J → Indep I)
(indep_aug : ∀ ⦃I J : Set α⦄, Indep I → Indep J → I.encard < J.encard → ∃ e ∈ J, e ∉ I ∧ Indep (insert e I))
(indep_bdd : ∃ n, ∀ (I : Set α), Indep I → I.encard ≤ ↑n) (subset_ground : ∀ (I : Set α), Indep I → I ⊆ E),
(IndepMatroid.ofBddAugment E Indep indep_empty indep_subset indep_aug indep_bdd subset_ground).E = E |
CategoryTheory.ObjectProperty.singleton_le_iff._simp_1 | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {X : C} {P : CategoryTheory.ObjectProperty C},
(CategoryTheory.ObjectProperty.singleton X ≤ P) = P X |
_private.Init.Prelude.0.Nat.le_trans.match_1_1 | Init.Prelude | ∀ {n m : ℕ} (motive : (k : ℕ) → n ≤ m → m ≤ k → Prop) (k : ℕ) (x : n ≤ m) (x_1 : m ≤ k),
(∀ (h : n ≤ m), motive m h ⋯) → (∀ (h₁ : n ≤ m) (m_1 : ℕ) (h₂ : m.le m_1), motive m_1.succ h₁ ⋯) → motive k x x_1 |
CategoryTheory.sheafify_hom_ext | Mathlib.CategoryTheory.Sites.Sheafification | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] [inst_2 : CategoryTheory.HasWeakSheafify J D]
{P Q : CategoryTheory.Functor Cᵒᵖ D} (η γ : CategoryTheory.sheafify J P ⟶ Q),
CategoryTheory.Presheaf.IsSheaf J Q →
CategoryTheory.CategoryStruct.comp (CategoryTheory.toSheafify J P) η =
CategoryTheory.CategoryStruct.comp (CategoryTheory.toSheafify J P) γ →
η = γ |
IsCyclotomicExtension.autEquivPow._proof_3 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {n : ℕ} [inst : NeZero n] {K : Type u_1} [inst_1 : Field K] (L : Type u_2) [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L],
Irreducible (Polynomial.cyclotomic n K) →
∀ (t : (ZMod n)ˣ), minpoly K (IsPrimitiveRoot.powerBasis K ⋯).gen = minpoly K (IsPrimitiveRoot.powerBasis K ⋯).gen |
Lean.Grind.LinarithConfig.locals._inherited_default | Init.Grind.Config | Bool |
PFunctor.Approx.CofixA._sizeOf_1 | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {a : ℕ} → PFunctor.Approx.CofixA F a → ℕ |
CategoryTheory.leftDistributor_ext₂_left_iff | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {X Y Z : C} {f : J → C}
{g h :
CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y (⨁ f)) ⟶ Z},
g = h ↔
∀ (j : J),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Y (CategoryTheory.Limits.biproduct.ι f j)))
g =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft Y (CategoryTheory.Limits.biproduct.ι f j)))
h |
PFunctor.MIntl.mk._flat_ctor | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → (approx : (n : ℕ) → PFunctor.Approx.CofixA F n) → PFunctor.Approx.AllAgree approx → F.MIntl |
Lean.Elab.Tactic.Location.wildcard | Lean.Elab.Tactic.Location | Lean.Elab.Tactic.Location |
Subsemiring.smul_def | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R' : Type u_1} {α : Type u_2} [inst : NonAssocSemiring R'] [inst_1 : SMul R' α] {S : Subsemiring R'} (g : ↥S)
(m : α), g • m = ↑g • m |
_private.Mathlib.NumberTheory.LucasLehmer.0.LucasLehmer.norm_num_ext.sModNat_eq_sMod._proof_1_1 | Mathlib.NumberTheory.LucasLehmer | ∀ (p : ℕ), 4 ≤ 2 ^ p → 1 ≤ 2 ^ p |
QuadraticMap.map_sum | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] {ι : Type u_8} [inst_5 : DecidableEq ι] (Q : QuadraticMap R M N)
(s : Finset ι) (f : ι → M),
Q (∑ i ∈ s, f i) = ∑ i ∈ s, Q (f i) + ∑ ij ∈ s.sym2 with ¬ij.IsDiag, QuadraticMap.polarSym2 (⇑Q) (Sym2.map f ij) |
EReal.le_mul_of_forall_lt | Mathlib.Data.EReal.Inv | ∀ {a b c : EReal}, 0 < a ∨ b ≠ ⊤ → a ≠ ⊤ ∨ 0 < b → (∀ a' > a, ∀ b' > b, c ≤ a' * b') → c ≤ a * b |
toLex_neg | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Neg α] (a : α), toLex (-a) = -toLex a |
Ring.multichoose_eq | Mathlib.RingTheory.Binomial | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : Pow R ℕ] [inst_2 : BinomialRing R] (r : R) (n : ℕ),
Ring.multichoose r n = Ring.choose (r + ↑n - 1) n |
SimpleGraph.Walk.firstDart.congr_simp | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} (p p_1 : G.Walk v w) (e_p : p = p_1) (hp : ¬p.Nil),
p.firstDart hp = p_1.firstDart ⋯ |
QuotientGroup.coe_mk' | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [nN : N.Normal], ⇑(QuotientGroup.mk' N) = QuotientGroup.mk |
CategoryTheory.GrothendieckTopology.recOn | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.GrothendieckTopology C → Sort u_1} →
(t : CategoryTheory.GrothendieckTopology C) →
((sieves : (X : C) → Set (CategoryTheory.Sieve X)) →
(top_mem' : ∀ (X : C), ⊤ ∈ sieves X) →
(pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve X⦄ (f : Y ⟶ X),
S ∈ sieves X → CategoryTheory.Sieve.pullback f S ∈ sieves Y) →
(transitive' :
∀ ⦃X : C⦄ ⦃S : CategoryTheory.Sieve X⦄,
S ∈ sieves X →
∀ (R : CategoryTheory.Sieve X),
(∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄, S.arrows f → CategoryTheory.Sieve.pullback f R ∈ sieves Y) →
R ∈ sieves X) →
motive
{ sieves := sieves, top_mem' := top_mem', pullback_stable' := pullback_stable',
transitive' := transitive' }) →
motive t |
Std.Rxc.Iterator.pairwise_toList_upwardEnumerableLt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α] [Std.Rxc.IsAlwaysFinite α]
(it : Std.Iter α), List.Pairwise (fun a b => Std.PRange.UpwardEnumerable.LT a b) it.toList |
Tactic.ComputeAsymptotics.Majorized.zero | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Majorized | ∀ {b : ℝ → ℝ} {exp : ℝ}, Tactic.ComputeAsymptotics.Majorized 0 b exp |
String.Slice.RevPosIterator.mk | Init.Data.String.Iterate | {s : String.Slice} → s.Pos → s.RevPosIterator |
AlgebraicGeometry.pullbackRestrictIsoRestrict_inv_fst_assoc | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.pullbackRestrictIsoRestrict f U).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f U.ι) h) =
CategoryTheory.CategoryStruct.comp ((TopologicalSpace.Opens.map f.base).obj U).ι h |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.succ_signVariations_le_X_sub_C_mul._proof_1_1 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] {P : Polynomial R},
P ≠ 0 → ¬0 < P.leadingCoeff → 0 < (-P).leadingCoeff |
CategoryTheory.MorphismProperty.pushout_inr_iff | Mathlib.CategoryTheory.MorphismProperty.Descent | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.MorphismProperty C} {Z X Y : C}
{f : Z ⟶ X} {g : Z ⟶ Y} [P.IsStableUnderCobaseChange] [P.CodescendsAlong Q]
[inst_3 : CategoryTheory.Limits.HasPushout f g], Q g → (P (CategoryTheory.Limits.pushout.inr f g) ↔ P f) |
CommSemiring.toBialgebra | Mathlib.RingTheory.Bialgebra.Basic | (R : Type u) → [inst : CommSemiring R] → Bialgebra R R |
Orthonormal.inner_left_finsupp | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} {v : ι → E},
Orthonormal 𝕜 v → ∀ (l : ι →₀ 𝕜) (i : ι), inner 𝕜 ((Finsupp.linearCombination 𝕜 v) l) (v i) = (starRingEnd 𝕜) (l i) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.