name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.CosimplicialObject.Augmented.const_obj_hom | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.CosimplicialObject.Augmented.const.obj X).hom =
CategoryTheory.CategoryStruct.id ((CategoryTheory.CosimplicialObject.const C).obj X) | null | true |
_private.Init.Control.State.0.ForM.forIn.match_3 | Init.Control.State | {β : Type u_1} →
(motive : Except β (PUnit.{u_1 + 1} × β) → Sort u_2) →
(__do_lift : Except β (PUnit.{u_1 + 1} × β)) →
((a : PUnit.{u_1 + 1} × β) → motive (Except.ok a)) → ((a : β) → motive (Except.error a)) → motive __do_lift | null | false |
sSetTopAdj_unit_app_app_down | Mathlib.AlgebraicTopology.SingularSet | ∀ (S : SSet) (m : SimplexCategoryᵒᵖ) (a : S.obj m),
((CategoryTheory.ConcreteCategory.hom ((sSetTopAdj.unit.app S).app m)) a).down =
CategoryTheory.CategoryStruct.comp (SSet.toTopSimplex.inv.app (Opposite.unop m))
(SSet.toTop.map (SSet.yonedaEquiv.symm a)) | null | true |
instAddCommGroupTangentSpace._proof_11 | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [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] (_x : M),
autoParam (∀ (n : ℕ) (x : T... | null | false |
IsHomeomorph.toEquiv_homeomorph | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y)
(hf : IsHomeomorph f), (IsHomeomorph.homeomorph f hf).toEquiv = Equiv.ofBijective f ⋯ | null | true |
Num.decidablePrime | Mathlib.Data.Num.Prime | DecidablePred Num.Prime | null | true |
Prod.toSigma_inj._simp_1 | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_7} {β : Type u_8} {x y : α × β}, (x.toSigma = y.toSigma) = (x = y) | null | false |
StandardSubspace.toClosedSubmodule_inj._simp_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] {S T : StandardSubspace H},
(S.toClosedSubmodule = T.toClosedSubmodule) = (S = T) | null | false |
SeminormedRing.mk._flat_ctor | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
(norm : α → ℝ) →
(zero : α) →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), 0 • x = 0) AddMonoid.nsmul_zero._autoParam →... | null | false |
CategoryTheory.Over.iteratedSliceBackward | Mathlib.CategoryTheory.Comma.Over.Basic | {T : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} T] →
{X : T} → (f : CategoryTheory.Over X) → CategoryTheory.Functor (CategoryTheory.Over f.left) (CategoryTheory.Over f) | Given f : Y ⟶ X, this is the obvious functor from T/Y to (T/X)/f | true |
CategoryTheory.Functor.IsLocallyFull.recOn | Mathlib.CategoryTheory.Sites.LocallyFullyFaithful | {C : Type uC} →
[inst : CategoryTheory.Category.{vC, uC} C] →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{vD, uD} D] →
{G : CategoryTheory.Functor C D} →
{K : CategoryTheory.GrothendieckTopology D} →
{motive : G.IsLocallyFull K → Sort u} →
(t : G.IsLocallyF... | null | false |
HomologicalComplex.IsStrictlySupportedOutside.mk._flat_ctor | Mathlib.Algebra.Homology.Embedding.IsSupported | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : HomologicalComplex C c'} {e : c.Embedding c'},
(∀ (i : ι), CategoryTheory.Limits.IsZero (K.X (e.f i))) → K.IsStrictlySu... | null | false |
Std.DTreeMap.Internal.Impl.getKeyD_minKey | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {he : t.isEmpty = false} {fallback : α}, t.getKeyD (t.minKey he) fallback = t.minKey he | null | true |
Codisjoint.sup_right | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a b : α} (c : α),
Codisjoint a b → Codisjoint a (b ⊔ c) | null | true |
_private.Mathlib.Combinatorics.Enumerative.Schroder.0.Nat.smallSchroder.match_1.eq_1 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ => h_3 n) =
h_1 () | null | true |
Std.IsPartialOrder.of_le | Init.Data.Order.Factories | ∀ {α : Type u} [inst : LE α],
autoParam (Std.Refl fun x1 x2 => x1 ≤ x2) Std.IsPartialOrder.of_le._auto_1 →
autoParam (Std.Antisymm fun x1 x2 => x1 ≤ x2) Std.IsPartialOrder.of_le._auto_3 →
∀
(le_trans :
autoParam (Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2)
... | If an `LE α` is reflexive, antisymmetric and transitive, then it represents a partial order.
| true |
Lean.SubExpr.Pos | Lean.SubExpr | Type | A position of a subexpression in an expression.
We use a simple encoding scheme for expression positions `Pos`:
every `Expr` constructor has at most 3 direct expression children. Considering an expression's type
to be one extra child as well, we can injectively map a path of `childIdxs` to a natural number
by computin... | true |
padicNorm_two_harmonic | Mathlib.NumberTheory.Harmonic.Int | ∀ {n : ℕ}, n ≠ 0 → ‖↑(harmonic n)‖ = 2 ^ Nat.log 2 n | The 2-adic norm of the n-th harmonic number is 2 raised to the logarithm of n in base 2. | true |
List.length_take_le' | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} (i : ℕ) (l : List α), (List.take i l).length ≤ l.length | null | true |
WithZero.coe_expEquiv_apply | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {G : Type u_5} [inst : AddGroup G] (a : G), ↑(WithZero.expEquiv a) = WithZero.exp a | null | true |
Function.Embedding.trans_arrowCongrLeft | Mathlib.Logic.Embedding.Basic | ∀ {α₁ : Sort u} {α₂ : Sort v} {α₃ : Sort x} {γ : Sort w} [inst : Inhabited γ] (e₁₂ : α₁ ↪ α₂) (e₂₃ : α₂ ↪ α₃),
e₁₂.arrowCongrLeft.trans e₂₃.arrowCongrLeft = (e₁₂.trans e₂₃).arrowCongrLeft | null | true |
leansearchclient.backend | LeanSearchClient.Basic | Lean.Option String | null | true |
ModelWithCorners._sizeOf_1 | 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} → [SizeOf 𝕜] → [SizeOf E] → [SizeOf H] → ModelWithCorners 𝕜 E H → ℕ | null | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.equivMapDomain._simp_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_8} {M : Type u_9} [inst : Zero M] (self : α →₀ M) (a : α), (a ∈ self.support) = (self.toFun a ≠ 0) | null | false |
_private.Init.Data.String.Slice.0.String.Slice.lines.lineMap.match_1 | Init.Data.String.Slice | (motive : Option String.Slice → Sort u_1) →
(x : Option String.Slice) → ((s : String.Slice) → motive (some s)) → ((x : Option String.Slice) → motive x) → motive x | null | false |
Complex.tan_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.tan ↑x).im = 0 | null | true |
Aesop.Frontend.Priority.ctorIdx | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority → ℕ | null | false |
SimpleGraph.isAcyclic_starGraph | Mathlib.Combinatorics.SimpleGraph.Star | ∀ {V : Type u_1} (r : V), (SimpleGraph.starGraph r).IsAcyclic | null | true |
Std.DTreeMap.Internal.Impl.containsThenInsertIfNew!.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (v : β k) (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.containsThenInsertIfNew! k v t =
if Std.DTreeMap.Internal.Impl.contains k t = true then (true, t)
else (false, Std.DTreeMap.Internal.Impl.insert! k v t) | null | true |
Nat.b_eq_digitChar | Init.Data.Nat.ToString | ∀ {n : ℕ}, 'b' = n.digitChar ↔ n = 11 | null | true |
Module.preReflection | Mathlib.LinearAlgebra.Reflection | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → M → Module.Dual R M → Module.End R M | Given an element `x` in a module `M` and a linear form `f` on `M`, we define the endomorphism
of `M` for which `y ↦ y - (f y) • x`.
One is typically interested in this endomorphism when `f x = 2`; this definition exists to allow the
user defer discharging this proof obligation. See also `Module.reflection`. | true |
Lean.Compiler.LCNF.InferType.Pure.inferAppType._unsafe_rec | Lean.Compiler.LCNF.InferType | Lean.Expr → Lean.Compiler.LCNF.InferType.Pure.InferTypeM Lean.Expr | null | false |
instLawfulCommIdentityUInt16HXorOfNat | Init.Data.UInt.Bitwise | Std.LawfulCommIdentity (fun x1 x2 => x1 ^^^ x2) 0 | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.H2π_eq_zero_iff._simp_1_5 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.ShortComplex.leftHomologyMap' e.inv h₂ h₁ =
(CategoryTheory.ShortComplex.... | null | false |
FirstOrder.Language.ClosedUnder.sInf | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {n : ℕ} {f : L.Functions n} {S : Set (Set M)},
(∀ s ∈ S, FirstOrder.Language.ClosedUnder f s) → FirstOrder.Language.ClosedUnder f (sInf S) | null | true |
Infinite.of_not_fintype | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1}, (∀ (a : Fintype α), False) → Infinite α | null | true |
Lean.Meta.ApplyNewGoals.recOn | Init.Meta.Defs | {motive : Lean.Meta.ApplyNewGoals → Sort u} →
(t : Lean.Meta.ApplyNewGoals) →
motive Lean.Meta.ApplyNewGoals.nonDependentFirst →
motive Lean.Meta.ApplyNewGoals.nonDependentOnly → motive Lean.Meta.ApplyNewGoals.all → motive t | null | false |
TwoSidedIdeal.finsetProd_mem | Mathlib.RingTheory.TwoSidedIdeal.BigOperators | ∀ {R : Type u_1} [inst : CommRing R] (I : TwoSidedIdeal R) {ι : Type u_2} (s : Finset ι) (f : ι → R),
(∃ x ∈ s, f x ∈ I) → s.prod f ∈ I | null | true |
TrivSqZeroExt.inl_neg | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u} (M : Type v) [inst : Neg R] [inst_1 : NegZeroClass M] (r : R),
TrivSqZeroExt.inl (-r) = -TrivSqZeroExt.inl r | null | true |
CategoryTheory.Limits.IsLimit.binaryFanSwap._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {s : CategoryTheory.Limits.BinaryFan X Y}
(I : CategoryTheory.Limits.IsLimit s) (t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair Y X))
(j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.... | null | false |
NumberField.mixedEmbedding.polarSpaceCoord.eq_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.polarSpaceCoord K =
(NumberField.mixedEmbedding.polarCoord K).transHomeomorph
(NumberField.mixedEmbedding.homeoRealMixedSpacePolarSpace K) | null | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.ker_eval₂Hom_universalFactorizationMap._simp_1_4 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * c - b * c = (a - b) * c | null | false |
Std.DTreeMap.maxKeyD_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β k}
{fallback : α}, (t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | null | true |
CategoryTheory.instInhabitedMkId | Mathlib.CategoryTheory.Category.KleisliCat | {α : Type u} → [Inhabited α] → Inhabited (CategoryTheory.KleisliCat.mk id α) | null | true |
CategoryTheory.ProjectiveResolution.homotopyEquiv_inv_π_assoc | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X : C}
(P Q : CategoryTheory.ProjectiveResolution X) {Z : HomologicalComplex C (ComplexShape.down ℕ)}
(h : (ChainComplex.single₀ C).obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp (P.homotopyEquiv Q).inv (CategoryTheory.C... | null | true |
ContinuousLinearEquiv.isAddHaarMeasure_map | Mathlib.MeasureTheory.Group.Measure | ∀ {E : Type u_3} {F : Type u_4} {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommGroup E] [inst_3 : Module R E] [inst_4 : AddCommGroup F] [inst_5 : Module S F]
[inst_6 : TopologicalSpace E] [IsTopologicalAddGroup E] [inst_8 : TopologicalSpace F] [IsTopologicalAddGroup F]
{σ... | A convenience wrapper for `MeasureTheory.Measure.isAddHaarMeasure_map`. | true |
SemiRingCat.hom_ext | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : SemiRingCat} {f g : R ⟶ S}, SemiRingCat.Hom.hom f = SemiRingCat.Hom.hom g → f = g | null | true |
CategoryTheory.Limits.ker._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] {f g : CategoryTheory.Arrow C} (u : f ⟶ g),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f.... | null | false |
Array.mem_mapFinIdx | Init.Data.Array.MapIdx | ∀ {β : Type u_1} {α : Type u_2} {b : β} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β},
b ∈ xs.mapFinIdx f ↔ ∃ i, ∃ (h : i < xs.size), f i xs[i] h = b | null | true |
SignType.castHom._proof_3 | Mathlib.Basic.Sign.Basic | ∀ {α : Type u_1} [inst : MulZeroOneClass α] [inst_1 : HasDistribNeg α], ↑1 = ↑1 | null | false |
HomotopyCategory.instIsCompatibleWithShiftHomologicalComplexIntUpHomotopic | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C],
(homotopic C (ComplexShape.up ℤ)).IsCompatibleWithShift ℤ | null | true |
CoheytingAlgebra.noConfusionType | Mathlib.Order.Heyting.Basic | Sort u → {α : Type u_4} → CoheytingAlgebra α → {α' : Type u_4} → CoheytingAlgebra α' → Sort u | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0._regBuiltin.Int8.reduceToNatClampNeg.declare_92._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2990342300._hygCtx._hyg.435 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
Equiv.subtypePiEquivPi._proof_2 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : α → Sort u_2} {p : (a : α) → β a → Prop},
Function.RightInverse (fun f => ⟨fun a => ↑(f a), ⋯⟩) fun f a => ⟨↑f a, ⋯⟩ | null | false |
_private.Lean.Meta.Sym.AlphaShareCommon.0.Lean.Meta.Sym.alphaEq._sparseCasesOn_4 | Lean.Meta.Sym.AlphaShareCommon | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Linter.Util.0.Lean.Linter.collectMacroExpansions?.go.match_4 | Lean.Linter.Util | (motive : List (List Lean.Elab.MacroExpansionInfo) → Sort u_1) →
(results : List (List Lean.Elab.MacroExpansionInfo)) →
((results : List Lean.Elab.MacroExpansionInfo) →
(tail : List (List Lean.Elab.MacroExpansionInfo)) → motive (results :: tail)) →
((x : List (List Lean.Elab.MacroExpansionInfo)) → m... | null | false |
AddSubsemigroup.equivOp_apply_coe | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (H : AddSubsemigroup M) (a : ↥H), ↑(H.equivOp a) = AddOpposite.op ↑a | null | true |
MeasureTheory.Measure.measure_univ_pos._simp_1 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (0 < μ Set.univ) = (μ ≠ 0) | null | false |
AddCircle.measurableEquivIoc.congr_simp | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | ∀ (T : ℝ) [hT : Fact (0 < T)] (a : ℝ), AddCircle.measurableEquivIoc T a = AddCircle.measurableEquivIoc T a | null | true |
MonotoneOn.map_sSup_of_continuousWithinAt | Mathlib.Topology.Order.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : CompleteLinearOrder β] [inst_4 : TopologicalSpace β] [OrderClosedTopology β] {f : α → β} {s : Set α},
ContinuousWithinAt f s (sSup s) → MonotoneOn f s → f ⊥ = ⊥ → f (sSup s) = sSup (f '' s) | A monotone function `f` sending `bot` to `bot` and continuous at the supremum of a set sends
this supremum to the supremum of the image of this set. | true |
Lean.Elab.Do.MutVar.rec | Lean.Elab.Do.Basic | {motive : Lean.Elab.Do.MutVar → Sort u} →
((ident : Lean.Ident) →
(baseId : Lean.FVarId) → (erased : Bool) → motive { ident := ident, baseId := baseId, erased := erased }) →
(t : Lean.Elab.Do.MutVar) → motive t | null | false |
_private.LeanSearchClient.LoogleSyntax.0.LeanSearchClient.getLoogleQueryJson.match_4 | LeanSearchClient.LoogleSyntax | (motive : Except String (Array Lean.Json) → Sort u_1) →
(x : Except String (Array Lean.Json)) →
((arr : Array Lean.Json) → motive (Except.ok arr)) → ((e : String) → motive (Except.error e)) → motive x | null | false |
CoalgHomClass | Mathlib.RingTheory.Coalgebra.Hom | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] →
[inst_3 : AddCommMonoid B] →
[inst_4 : Module R B] → [CoalgebraStruc... | `CoalgHomClass F R A B` asserts `F` is a type of bundled coalgebra homomorphisms
from `A` to `B`. | true |
_private.Lean.Environment.0.Lean.Environment.asyncConstsMap._default | Lean.Environment | Lean.VisibilityMap✝ Lean.AsyncConsts✝ | null | false |
Polynomial.IsMonicOfDegree.of_mul_left | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Semiring R] {p q : Polynomial R} {m n : ℕ},
p.IsMonicOfDegree m → (p * q).IsMonicOfDegree (m + n) → q.IsMonicOfDegree n | null | true |
NonUnitalSubalgebra.toNonUnitalSemiring | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] → [inst_2 : Module R A] → (S : NonUnitalSubalgebra R A) → NonUnitalSemiring ↥S | null | true |
OrderHom.uliftLeftMap | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → (α →o β) → ULift.{u_8, u_2} α →o β | Lift an order homomorphism `f : α →o β` to an order homomorphism `ULift α →o β` in a
higher universe. | true |
Std.not_lt_of_ge | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] {a b : α}, a ≤ b → ¬b < a | null | true |
CategoryTheory.MonoidalCategory.associator_naturality_assoc | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} {𝒞 : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.MonoidalCategory C] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : C}
(f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃) {Z : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj Y₁ (CategoryTheory.MonoidalCategoryStruct.tensorObj Y₂ Y₃) ⟶ Z),
CategoryTheory.Catego... | Naturality of the associator isomorphism: `(f₁ ⊗ₘ f₂) ⊗ₘ f₃ ≃ f₁ ⊗ₘ (f₂ ⊗ₘ f₃)` | true |
ContinuousLinearMap.uniformContinuous | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {E₁ : Type u_9}
{E₂ : Type u_10} [inst_2 : UniformSpace E₁] [inst_3 : UniformSpace E₂] [inst_4 : AddCommGroup E₁]
[inst_5 : AddCommGroup E₂] [inst_6 : Module R₁ E₁] [inst_7 : Module R₂ E₂] [IsUniformAddGroup E₁]
[IsUni... | null | true |
_private.Init.Data.Array.Lemmas.0.Array.append_eq_singleton_iff._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a b : List α} {x : α}, (a ++ b = [x]) = (a = [] ∧ b = [x] ∨ a = [x] ∧ b = []) | null | false |
CategoryTheory.Limits.LimitBicone.mk.inj | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type uC} {inst : CategoryTheory.Category.{uC', uC} C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {F : J → C} {bicone : CategoryTheory.Limits.Bicone F}
{isBilimit : bicone.IsBilimit} {bicone_1 : CategoryTheory.Limits.Bicone F} {isBilimit_1 : bicone_1.IsBilimit},
{ bicone := bicone, isB... | null | true |
DFinsupp.small | Mathlib.Data.DFinsupp.Small | ∀ {ι : Type u} {π : ι → Type v} [inst : (i : ι) → Zero (π i)] [Small.{w, u} ι] [∀ (i : ι), Small.{w, v} (π i)],
Small.{w, max v u} (DFinsupp π) | null | true |
SSet.N.cast | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | {X : SSet} → (s : X.N) → {d : ℕ} → s.dim = d → X.N | When `s : X.N` is such that `s.dim = d`, this is a term
that is equal to `s`, but whose dimension if definitionally equal to `d`. | true |
Prod.instSemiring._proof_11 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
Std.Internal.List.isEmpty_filter_containsKey_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)},
l₁.isEmpty = true → (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁).isEmpty = true | null | true |
CategoryTheory.PreZeroHypercover.sectionsSaturateEquiv_apply_coe | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {S : C} (E : CategoryTheory.PreZeroHypercover S)
(F : CategoryTheory.Functor Cᵒᵖ (Type u_3)) (s : (E.saturate.multicospanIndex F).sections)
(i : E.saturate.multicospanShape.L), ↑((E.sectionsSaturateEquiv F) s) i = s.val i | null | true |
NonUnitalNonAssocCommRing.mul_comm | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonUnitalNonAssocCommRing α] (a b : α), a * b = b * a | Multiplication is commutative in a commutative multiplicative magma. | true |
_private.Mathlib.Algebra.Homology.ExactSequence.0.CategoryTheory.ComposableArrows.sc._proof_3 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i : ℕ), ¬i + 1 + 1 = i + 2 → False | null | false |
CategoryTheory.PreGaloisCategory.endEquivAutGalois | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
(F : CategoryTheory.Functor C FintypeCat) →
[CategoryTheory.PreGaloisCategory.FiberFunctor F] →
CategoryTheory.End F ≃ CategoryTheory.PreGaloisCategory.AutGalois F | The equivalence between endomorphisms of `F` and the limit over the automorphism groups
of all Galois objects. | true |
SSet.Truncated.StrictSegal.spineToSimplex_interval | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} {X : SSet.Truncated (n + 1)} (sx : X.StrictSegal) (m : ℕ) (h : m ≤ n + 1) (f : X.Path m) (j l : ℕ)
(hjl : j + l ≤ m),
(CategoryTheory.ConcreteCategory.hom
(X.map (SimplexCategory.Truncated.Hom.tr (SimplexCategory.subinterval j l hjl) ⋯ h).op))
(sx.spineToSimplex m h f) =
sx.spineToSimple... | null | true |
NonUnitalAlgHom.mk.inj | Mathlib.Algebra.Algebra.NonUnitalHom | ∀ {R : Type u} {S : Type u₁} {inst : Monoid R} {inst_1 : Monoid S} {φ : R →* S} {A : Type v} {B : Type w}
{inst_2 : NonUnitalNonAssocSemiring A} {inst_3 : DistribMulAction R A} {inst_4 : NonUnitalNonAssocSemiring B}
{inst_5 : DistribMulAction S B} {toDistribMulActionHom : A →ₑ+[φ] B}
{map_mul' :
∀ (x y : A), ... | null | true |
LowerSemicontinuousWithinAt | Mathlib.Topology.Semicontinuity.Defs | {α : Type u_1} → {β : Type u_2} → [TopologicalSpace α] → [Preorder β] → (α → β) → Set α → α → Prop | A real function `f` is lower semicontinuous at `x` within a set `s` if, for any `ε > 0`, for all
`x'` close enough to `x` in `s`, then `f x'` is at least `f x - ε`. We formulate this in a general
preordered space, using an arbitrary `y < f x` instead of `f x - ε`. | true |
List.mem_foldr_permutationsAux2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {t : α} {ts : List α} {r L : List (List α)} {l' : List α},
l' ∈ List.foldr (fun y r => (List.permutationsAux2 t ts r y id).2) r L ↔
l' ∈ r ∨ ∃ l₁ l₂, l₁ ++ l₂ ∈ L ∧ l₂ ≠ [] ∧ l' = l₁ ++ t :: l₂ ++ ts | null | true |
Lean.Parser.ParserCacheEntry.mk._flat_ctor | Lean.Parser.Types | Lean.Syntax → ℕ → String.Pos.Raw → Option Lean.Parser.Error → Lean.Parser.ParserCacheEntry | null | false |
Matrix.isRepresentation._proof_4 | Mathlib.LinearAlgebra.Matrix.Charpoly.LinearMap | ∀ {ι : Type u_3} [inst : Fintype ι] {M : Type u_1} [inst_1 : AddCommGroup M] (R : Type u_2) [inst_2 : CommRing R]
[inst_3 : Module R M] (b : ι → M) [inst_4 : DecidableEq ι], ∃ f, Matrix.Represents b 0 f | null | false |
StandardEtalePair.Ring | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} → [inst : CommRing R] → StandardEtalePair R → Type u_1 | The standard etale algebra `R[X][Y]/⟨f, Yg-1⟩` associated to a `StandardEtalePair R`.
Also see
`equivPolynomialQuotient : P.Ring ≃ R[X][Y]/⟨f, Yg-1⟩`
`equivAwayAdjoinRoot : P.Ring ≃ (R[X]/f)[1/g]`
`equivAwayQuotient : P.Ring ≃ R[X][1/g]/f`
`equivMvPolynomialQuotient : P.Ring ≃ R[X, Y]/⟨f, Yg-1⟩` | true |
Std.DHashMap.Raw.instMembershipOfBEqOfHashable | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → Membership α (Std.DHashMap.Raw α β) | null | true |
_private.Lean.Util.CollectLevelParams.0.Lean.CollectLevelParams.State.getUnusedLevelParam.loop | Lean.Util.CollectLevelParams | Lean.CollectLevelParams.State → Lean.Name → ℕ → Lean.Level | null | true |
_private.Init.Data.Array.Range.0.Array.range'_concat._simp_1_1 | Init.Data.Array.Range | ∀ {s m n step : ℕ}, Array.range' s (m + n) step = Array.range' s m step ++ Array.range' (s + step * m) n step | null | false |
Module.Finite.instLinearMapIdSubtypeMemSubmoduleOfIsSemisimpleModule | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m : Submodule R M}
(R₀ : Type u_6) (P : Type u_7) [inst_3 : Semiring R₀] [inst_4 : AddCommMonoid P] [inst_5 : Module R P]
[inst_6 : Module R₀ P] [inst_7 : SMulCommClass R R₀ P] [Module.Finite R₀ (M →ₗ[R] P)] [IsSemisimp... | null | true |
CategoryTheory.obj_η_app_assoc | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C)) (n : M)
(X : C) [inst_3 : F.Monoidal] {Z : C}
(h : (F.obj n).obj ((CategoryTheory.Monoida... | null | true |
WeierstrassCurve.Jacobian.Point.neg_point | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (P : W.Point), (-P).point = W.negMap P.point | null | true |
Std.ExtHashSet.size_left_le_size_union | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m₁.size ≤ (m₁ ∪ m₂).size | null | true |
UInt64.decLe._proof_1 | Init.Data.UInt.Basic | ∀ (a b : UInt64), (a.toBitVec.toNat.ble b.toBitVec.toNat).Reflects (a ≤ b) | null | false |
CategoryTheory.FreeMonoidalCategory.normalizeIsoApp' | Mathlib.CategoryTheory.Monoidal.Free.Coherence | (C : Type u) →
(X : CategoryTheory.FreeMonoidalCategory C) →
(n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.FreeMonoidalCategory.inclusionObj n) X ≅
CategoryTheory.FreeMonoidalCategory.inclusionObj (X.normalizeObj n) | Almost non-definitionally equal to `normalizeIsoApp`, but has a better definitional property
in the proof of `normalize_naturality`. | true |
FinEnum.Subtype.finEnum._proof_1 | Mathlib.Data.FinEnum | ∀ {α : Type u_1} [inst : FinEnum α] (p : α → Prop) [inst_1 : DecidablePred p] (x : { x // p x }),
x ∈ List.filterMap (fun x => if h : p x then some ⟨x, h⟩ else none) (FinEnum.toList α) | null | false |
Finset.smul_finset_neg | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : AddGroup β]
[inst_3 : DistribMulAction α β] (a : α) (t : Finset β), a • -t = -(a • t) | null | true |
Nat.clog_mono | Mathlib.Data.Nat.Log | ∀ {b c m n : ℕ}, 1 < c → c ≤ b → m ≤ n → Nat.clog b m ≤ Nat.clog c n | null | true |
Std.Http.Request.options | Std.Http.Data.Request | Std.Http.RequestTarget → Std.Http.Request.Builder | Creates a new HTTP OPTIONS Request builder with the specified URI.
Use `Request.options (RequestTarget.asteriskForm)` for server-wide OPTIONS.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.