name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FreeLieAlgebra.lift_of_apply | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(x : X), ((FreeLieAlgebra.lift R) f) (FreeLieAlgebra.of R x) = f x | null | true |
CategoryTheory.SplitMono | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → (X ⟶ Y) → Type v₁ | A split monomorphism is a morphism `f : X ⟶ Y` with a given retraction `retraction f : Y ⟶ X`
such that `f ≫ retraction f = 𝟙 X`.
Every split monomorphism is a monomorphism.
| true |
Option.isSome.eq_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (val : α), (some val).isSome = true | null | true |
instAlgebraUniversalEnvelopingAlgebra._aux_1 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → R → UniversalEnvelopingAlgebra R L → UniversalEnvelopingAlgebra R L | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cons_append_append._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ w₃ : ℕ}, ∀ i < w₁ + 1 + w₂ + w₃, ¬i < w₁ + w₂ + w₃ → i - w₃ - w₂ < w₁ → False | null | false |
MDifferentiableWithinAt.prodMap' | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | The product map of two `C^n` functions within a set at a point is `C^n`
within the product set at the product point. | true |
Mathlib.Tactic.Algebra.RingCompute.cast | Mathlib.Tactic.Algebra.Basic | {u v : Lean.Level} →
{R : Q(Type u)} →
{A : Q(Type v)} →
{sR : Q(CommSemiring «$R»)} →
{sA : Q(CommSemiring «$A»)} →
(sAlg : Q(Algebra «$R» «$A»)) →
Mathlib.Tactic.Algebra.Cache sR →
(u' : Lean.Level) →
(R' : Q(Type u')) →
Q(CommS... | Take an expression `r'` in a ring `R'` such that `R` is an `R'`-algebra and cast `r'` to `R`
using `algebraMap R' R`, so that the scalar multiplication action on `A` is preserved. | true |
CategoryTheory.Localization.Construction.morphismProperty_eq_top' | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C}
(P : CategoryTheory.MorphismProperty W.Localization) [P.IsStableUnderComposition],
(∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f)) → (∀ ⦃X Y : W.Localization⦄ (e : X ≅ Y), P e.hom → P e.inv) → P = ⊤ | A `MorphismProperty` in `W.Localization` is satisfied by all
morphisms in the localized category if it contains the image of the
morphisms in the original category, if is stable under composition
and if the property is stable by passing to inverses. | true |
FreeGroup.of_ne_one._simp_2 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (a : α), (FreeGroup.of a = 1) = False | null | false |
Lean.TSyntax.ctorIdx | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → Lean.TSyntax ks → ℕ | null | false |
_private.Mathlib.Algebra.Algebra.Subalgebra.Basic.0.Subalgebra.isDomain._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommRing R] [inst_1 : Ring A] [IsDomain A] [inst_3 : Algebra R A]
(S : Subalgebra R A), IsDomain ↥S | null | false |
Lean.Lsp.instFromJsonPosition | Lean.Data.Lsp.BasicAux | Lean.FromJson Lean.Lsp.Position | null | true |
CategoryTheory.SimplicialThickening.Path.mk.inj | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} {inst : LinearOrder J} {i j : J} {I : Set J}
{left : autoParam (i ∈ I) CategoryTheory.SimplicialThickening.Path.left._autoParam}
{right : autoParam (j ∈ I) CategoryTheory.SimplicialThickening.Path.right._autoParam}
{left_le : autoParam (∀ k ∈ I, i ≤ k) CategoryTheory.SimplicialThickening.Path.lef... | null | true |
AddEquiv.toMultiplicativeLeft._proof_7 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_1} {H : Type u_2} [inst : AddZeroClass G] [inst_1 : MulOneClass H] (f : Multiplicative G ≃* H),
Function.RightInverse f.invFun f.toFun | null | false |
String.Pos.Raw.instLTCiOfNatInt | Init.Data.String.OrderInstances | Lean.Grind.ToInt.LT String.Pos.Raw (Lean.Grind.IntInterval.ci 0) | null | true |
instRingUniversalEnvelopingAlgebra._proof_39 | Mathlib.Algebra.Lie.UniversalEnveloping | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
autoParam (∀ (a : UniversalEnvelopingAlgebra R L), instRingUniversalEnvelopingAlgebra._aux_37 R L 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam | null | false |
AddSubgroup.instTop.eq_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : AddGroup G],
AddSubgroup.instTop =
{
top :=
let __src := ⊤;
{ toAddSubmonoid := __src, neg_mem' := ⋯ } } | null | true |
Lean.Parser.Attr._aux_Mathlib_Tactic_Simps_Basic___macroRules_Lean_Parser_Attr_attrSimps!?__1 | Mathlib.Tactic.Simps.Basic | Lean.Macro | null | false |
IntermediateField.copy | Mathlib.FieldTheory.IntermediateField.Basic | {K : Type u_1} →
{L : Type u_2} →
[inst : Field K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] → (S : IntermediateField K L) → (s : Set L) → s = ↑S → IntermediateField K L | Copy of an intermediate field with a new `carrier` equal to the old one. Useful to fix
definitional equalities. | true |
Sublattice.comap | Mathlib.Order.Sublattice | {α : Type u_2} →
{β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom α β → Sublattice β → Sublattice α | The preimage of a sublattice along a lattice homomorphism. | true |
Finsupp.smul_single | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α) (b : M),
(c • fun₀ | a => b) = fun₀ | a => c • b | null | true |
CategoryTheory.GrothendieckTopology.isoToPlus.congr_simp | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type w}
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(P : CategoryTheory.Functo... | null | true |
PFunctor.M.bisim' | Mathlib.Data.PFunctor.Univariate.M | ∀ {P : PFunctor.{uA, uB}} {α : Type u_3} (Q : α → Prop) (u v : α → P.M),
(∀ (x : α),
Q x →
∃ a f f', (u x).dest = ⟨a, f⟩ ∧ (v x).dest = ⟨a, f'⟩ ∧ ∀ (i : P.B a), ∃ x', Q x' ∧ f i = u x' ∧ f' i = v x') →
∀ (x : α), Q x → u x = v x | null | true |
Asymptotics.isBigO_top._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F},
f =O[⊤] g = ∃ C, ∀ (x : α), ‖f x‖ ≤ C * ‖g x‖ | null | false |
CategoryTheory.OrthogonalReflection.D₁.ιLeft_comp_t_assoc | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W... | null | true |
CategoryTheory.Dial.recOn | Mathlib.CategoryTheory.Dialectica.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
{motive : CategoryTheory.Dial C → Sort u_1} →
(t : CategoryTheory.Dial C) →
((src tgt : C) →
(rel : CategoryTheory.Subobject (src ⨯ tgt)) → motive { src := src, t... | null | false |
Std.DTreeMap.Internal.Impl.Const.get?_congr | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {a b : α},
compare a b = Ordering.eq → Std.DTreeMap.Internal.Impl.Const.get? t a = Std.DTreeMap.Internal.Impl.Const.get? t b | null | true |
List.length_destutter_le_length_destutter_cons | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} {R : α → α → Prop} [inst : DecidableRel R] {a : α} [IsEquiv α Rᶜ] {l : List α},
(List.destutter R l).length ≤ (List.destutter R (a :: l)).length | `List.destutter` on a relation like ≠, whose negation is an equivalence, has length
monotone under List.cons | true |
_private.Mathlib.Topology.Baire.LocallyCompactRegular.0.BaireSpace.of_t2Space_locallyCompactSpace._simp_2 | Mathlib.Topology.Baire.LocallyCompactRegular | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
Matrix.detp_smul_adjp | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R]
{A B : Matrix n n R},
A * B = 1 →
A + (Matrix.detp 1 A • Matrix.adjp (-1) B + Matrix.detp (-1) A • Matrix.adjp 1 B) =
Matrix.detp 1 A • Matrix.adjp 1 B + Matrix.detp (-1) A • Matrix.adjp (-1) B | null | true |
StarSubsemiring.center | Mathlib.Algebra.Star.Subsemiring | (R : Type u_1) → [inst : NonAssocSemiring R] → [inst_1 : StarRing R] → StarSubsemiring R | The center of a semiring `R` is the set of elements that commute and associate with everything
in `R` | true |
Subtype.coe_bot | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : OrderBot (Subtype p)],
p ⊥ → ↑⊥ = ⊥ | null | true |
Std.DHashMap.Internal.AssocList.foldrM | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type w'} → [Monad m] → ((a : α) → β a → δ → m δ) → δ → Std.DHashMap.Internal.AssocList α β → m δ | Internal implementation detail of the hash map | true |
Finset.map_swap_antidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | ∀ {A : Type u_1} [inst : AddCommMonoid A] [inst_1 : Finset.HasAntidiagonal A] {n : A},
Finset.map { toFun := Prod.swap, inj' := ⋯ } (Finset.antidiagonal n) = Finset.antidiagonal n | See also `Finset.map_prodComm_antidiagonal`. | true |
CategoryTheory.Limits.isCokernelEpiComp._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]
{X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.CokernelCofork f} {W : C} (g : W ⟶ X) {h : W ⟶ Y},
h = CategoryTheory.CategoryStruct.comp g f →
CategoryTheory.CategoryStruct.comp h (CategoryTheory... | null | false |
_private.Mathlib.Analysis.CStarAlgebra.Multiplier.0.DoubleCentralizer.instCStarRing._simp_2 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : DenselyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ₁₂]
(f ... | null | false |
CategoryTheory.Limits.isIsoZeroEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(X Y : C),
CategoryTheory.CategoryStruct.id X = 0 ∧ CategoryTheory.CategoryStruct.id Y = 0 →
CategoryTheory.CategoryStruct.comp 0 0 = CategoryTheory.CategoryStruct.id X ∧
CategoryTheory.Categ... | null | false |
CategoryTheory.MorphismProperty.IsStableUnderCobaseChangeAlong.mk._flat_ctor | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C} {X Y : C} {f : X ⟶ Y},
(∀ {Z W : C} {f' : Z ⟶ W} {g' : Y ⟶ W} {g : X ⟶ Z}, CategoryTheory.IsPushout f g g' f' → P g → P g') →
P.IsStableUnderCobaseChangeAlong f | null | false |
_private.Mathlib.LinearAlgebra.Matrix.FixedDetMatrices.0.FixedDetMatrices.reduce_mem_reps._simp_1_6 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddLeftMono α] [AddRightMono α] {a b : α}, (b ≤ -a) = (a ≤ -b) | null | false |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.Style.longLine.longLineLinter | Mathlib.Tactic.Linter.Style | Lean.Linter | The "longLine" linter emits a warning on lines longer than
`linter.style.longLine.maxLineLength` (which defaults to 100) characters.
We allow lines containing URLs to be longer, though. | true |
Rep.RepToAction_obj_V_carrier | Mathlib.RepresentationTheory.Rep.Basic | ∀ (k : Type u) (G : Type v) [inst : Ring k] [inst_1 : Monoid G] (X : Rep.{w, u, v} k G),
↑((Rep.RepToAction k G).obj X).V = ↑X | null | true |
SemimoduleCat.Hom._sizeOf_1 | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} → {inst : Semiring R} → {M N : SemimoduleCat R} → [SizeOf R] → M.Hom N → ℕ | null | false |
AddAction.ext | Mathlib.Algebra.Group.Action.Defs | ∀ {G : Type u_9} {P : Type u_10} {inst : AddMonoid G} {x y : AddAction G P}, VAdd.vadd = VAdd.vadd → x = y | null | true |
Lean.getPPAnalyzeExplicitHoles | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Options → Bool | null | true |
UInt16.fromExpr | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Expr → Lean.Meta.SimpM (Option UInt16) | null | true |
Std.Http.Chunk.ExtensionName.ctorIdx | Std.Http.Data.Chunk | Std.Http.Chunk.ExtensionName → ℕ | null | false |
TopologicalSpace.Closeds.iInf_def | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] {ι : Sort u_4} (s : ι → TopologicalSpace.Closeds α),
⨅ i, s i = { carrier := ⋂ i, ↑(s i), isClosed' := ⋯ } | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_left._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
SimpleGraph.nonempty_hom_of_forall_finite_subgraph_hom | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u} {W : Type v} {G : SimpleGraph V} {F : SimpleGraph W} [Finite W]
(h : (G' : G.Subgraph) → G'.verts.Finite → G'.coe →g F), Nonempty (G →g F) | If every finite subgraph of a graph `G` has a homomorphism to a finite graph `F`, then there is
a homomorphism from the whole of `G` to `F`. | true |
Ideal.Quotient.divisionRing._proof_9 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) [inst_1 : I.IsTwoSided] [inst_2 : I.IsMaximal],
autoParam (∀ (q : ℚ≥0), ↑q = ↑q.num / ↑q.den) DivisionRing.nnratCast_def._autoParam | null | false |
InfHom.id.eq_1 | Mathlib.Order.Hom.Lattice | ∀ (α : Type u_2) [inst : Min α], InfHom.id α = { toFun := id, map_inf' := ⋯ } | null | true |
WellFoundedRelation.isWellFounded | Mathlib.Order.RelClasses | ∀ {α : Type u} [h : WellFoundedRelation α], IsWellFounded α WellFoundedRelation.rel | null | true |
Action.instConcreteCategoryHomSubtypeV | Mathlib.CategoryTheory.Action.Basic | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
(G : Type u_2) →
[inst_1 : Monoid G] →
{FV : V → V → Type u_3} →
{CV : V → Type u_4} →
[inst_2 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)] →
[inst_3 : CategoryTheory.ConcreteCategory V FV] →
... | null | true |
Float32.recOn | Init.Data.Float32 | {motive : Float32 → Sort u} → (t : Float32) → ((val : float32Spec.float) → motive { val := val }) → motive t | null | false |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.upperHemicontinuousWithinAt_singleton_iff._simp_1_2 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l₁ : Filter α} {l₂ : Filter β},
Filter.Tendsto f l₁ l₂ = ∀ s ∈ l₂, ∀ᶠ (x : α) in l₁, f x ∈ s | null | false |
SemidirectProduct.inr_splitting | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{G : Type u_3} →
[inst : Group G] → [inst_1 : Group N] → (φ : G →* MulAut N) → (SemidirectProduct.toGroupExtension φ).Splitting | A canonical splitting of the group extension associated to the semidirect product | true |
Equiv.ord_def | Mathlib.Logic.Equiv.Defs | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) [inst : Ord β] (a b : α), compare a b = compare (e a) (e b) | null | true |
LinearIsometryEquiv.symm_apply_apply | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | true |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.implicitBinder._regBuiltin.Lean.Parser.Term.implicitBinder.docString_1 | Lean.Parser.Term.Basic | IO Unit | null | false |
TensorAlgebra.GradedAlgebra.ι_apply._proof_1 | Mathlib.LinearAlgebra.TensorAlgebra.Grading | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (m : M),
(TensorAlgebra.ι R) m ∈ (TensorAlgebra.ι R).range ^ 1 | null | false |
Std.Iterators.Types.Append.snd | Init.Data.Iterators.Combinators.Monadic.Append | {α₁ α₂ : Type w} → {m : Type w → Type w'} → {β : Type w} → Std.IterM m β → Std.Iterators.Types.Append α₁ α₂ m β | null | true |
Int.dvd_emod_sub_self | Init.Data.Int.DivMod.Lemmas | ∀ {x m : ℤ}, m ∣ x % m - x | null | true |
CategoryTheory.Functor.FullyFaithful.addGrpObj | Mathlib.CategoryTheory.Monoidal.Grp | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.CartesianMonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
... | Pullback an additive group object along a fully faithful monoidal functor. | true |
CartanMatrix.E₈ | Mathlib.LinearAlgebra.Matrix.Cartan | Matrix (Fin 8) (Fin 8) ℤ | The Cartan matrix of type E₈. See [bourbaki1968] plate VII, page 285. | true |
_private.Mathlib.Algebra.Homology.ShortComplex.ExactFunctor.0.CategoryTheory.Functor.preservesFiniteLimits_tfae.match_1_1 | Mathlib.Algebra.Homology.ShortComplex.ExactFunctor | ∀ {C : Type u_2} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_4 : F.Additive]
(motive :
(∀ (S : CategoryTheory.ShortComplex C), S.Short... | null | false |
Mathlib.Tactic.Translate.Config.doc._default | Mathlib.Tactic.Translate.Core | Option String | null | false |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.infs_aux | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : DecidableEq α] {s t : Finset α} {a : α},
a ∈ lowerClosure ↑(s ⊼ t) ↔ a ∈ lowerClosure ↑s ∧ a ∈ lowerClosure ↑t | null | true |
isAddCyclic_of_card_nsmul_eq_zero_le | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : DecidableEq α] [inst_2 : Fintype α],
(∀ (n : ℕ), 0 < n → {a | n • a = 0}.card ≤ n) → IsAddCyclic α | null | true |
NonAssocRing.toAddCommGroupWithOne | Mathlib.Algebra.Ring.Defs | {α : Type u_1} → [self : NonAssocRing α] → AddCommGroupWithOne α | null | true |
ContDiffWithinAt.contDiffBump | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup X]
[inst_3 : NormedSpace ℝ X] [inst_4 : HasContDiffBump E] {n : ℕ∞} {c g : X → E} {s : Set X}
{f : (x : X) → ContDiffBump (c x)} {x : X},
ContDiffWithinAt ℝ (↑n) c s x →
ContDiffWithinAt ℝ (↑n... | `ContDiffBump` is `𝒞ⁿ` in all its arguments. | true |
Lean.Grind.CommRing.Poly.mulM | Lean.Meta.Tactic.Grind.Arith.CommRing.SafePoly | Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Meta.Grind.Arith.CommRing.RingM Lean.Grind.CommRing.Poly | null | true |
WithCStarModule.norm_apply_le_norm | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [StarOrderedRing A]
(x : W... | null | true |
InfTopHom.dual._proof_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : Top α] [inst_2 : Min β] [inst_3 : Top β],
Function.LeftInverse (fun f => { toInfHom := InfHom.dual.symm f.toSupHom, map_top' := ⋯ }) fun f =>
{ toSupHom := InfHom.dual f.toInfHom, map_bot' := ⋯ } | null | false |
Set.bounded_ge_inter_ge | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Bounded (fun x1 x2 => x1 ≥ x2) (s ∩ {b | b ≤ a}) ↔ Set.Bounded (fun x1 x2 => x1 ≥ x2) s | null | true |
DirectSum.IsInternal.collectedBasis_orthonormal | Mathlib.Analysis.InnerProductSpace.Subspace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} [inst_3 : DecidableEq ι] {V : ι → Submodule 𝕜 E},
(OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) →
∀ (hV_sum : DirectSum.IsInternal fun i => V i) {α : ι → Type ... | null | true |
Nat.xor_right_injective | Batteries.Data.Nat.Bitwise.Lemmas | ∀ {x : ℕ}, Function.Injective fun x_1 => x ^^^ x_1 | null | true |
Function.Injective.torsor | Mathlib.Algebra.Torsor.Basic | {G : Type u_1} →
{P : Type u_2} →
{Q : Type u_3} →
[inst : Group G] →
[inst_1 : Torsor G P] →
[inst_2 : SMul G Q] →
[inst_3 : SDiv G Q] →
[Nonempty Q] →
(f : Q → P) →
Function.Injective f →
(∀ (c : G) (x : Q), ... | Pullback of a torsor along an injective map. | true |
TopologicalSpace.le_def | Mathlib.Topology.Order | ∀ {α : Type u_1} {t s : TopologicalSpace α}, t ≤ s ↔ IsOpen ≤ IsOpen | null | true |
ValuationSubring.one_mem | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K), 1 ∈ A | null | true |
_private.Lean.Meta.Tactic.Grind.Propagate.0.Lean.Meta.Grind.propagateBoolNotDown._regBuiltin.Lean.Meta.Grind.propagateBoolNotDown.declare_1._@.Lean.Meta.Tactic.Grind.Propagate.434325315._hygCtx._hyg.8 | Lean.Meta.Tactic.Grind.Propagate | IO Unit | null | false |
TrivSqZeroExt.instAlgebra._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ (R' : Type u_1) (M : Type u_2) [inst : CommSemiring R'] [inst_1 : AddCommMonoid M] [inst_2 : Module R' M]
[inst_3 : Module R'ᵐᵒᵖ M] [IsCentralScalar R' M], IsScalarTower R' R'ᵐᵒᵖ M | null | false |
CategoryTheory.CommShift₂Setup.hε | Mathlib.CategoryTheory.Shift.CommShiftTwo | ∀ {D : Type u_5} [inst : CategoryTheory.Category.{v_5, u_5} D] {M : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : CategoryTheory.HasShift D M] (self : CategoryTheory.CommShift₂Setup D M) (m n : M),
self.ε m n = (self.z (0, n) (m, 0))⁻¹ * self.z (m, 0) (0, n) | null | true |
Lean.Elab.Command.InductiveElabStep3.finalize | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep3 → Lean.Elab.TermElabM Unit | Finalize the inductive type, after they are all added to the environment, after auxiliary definitions are added, and after computed fields are registered.
The `levelParams`, `params`, and `replaceIndFVars` arguments of `prefinalize` are still valid here. | true |
CategoryTheory.PullbackShift.adjunction | Mathlib.CategoryTheory.Shift.Pullback | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u_2} →
{B : Type u_3} →
[inst_1 : AddMonoid A] →
[inst_2 : AddMonoid B] →
[inst_3 : CategoryTheory.HasShift C B] →
(φ : A →+ B) →
{D : Type u_4} →
[inst_4 ... | The adjunction `adj`, seen as an adjunction between `PullbackShift.functor F φ`
and `PullbackShift.functor G φ`.
| true |
MeasureTheory.SimpleFunc.ofIsEmpty._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} [IsEmpty α], Finite α | null | false |
HasFPowerSeriesAt.has_fpower_series_iterate_dslope_fslope | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {p : FormalMultilinearSeries 𝕜 𝕜 E} {f : 𝕜 → E} {z₀ : 𝕜} (n : ℕ),
HasFPowerSeriesAt f p z₀ →
HasFPowerSeriesAt ((Function.swap dslope z₀)^[n] f) (FormalMultilinearSeries.fslope^[n... | null | true |
Turing.TM0.Machine.map_step | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} [inst : Inhabited Γ] {Γ' : Type u_2} [inst_1 : Inhabited Γ'] {Λ : Type u_3} [inst_2 : Inhabited Λ]
{Λ' : Type u_4} [inst_3 : Inhabited Λ'] (M : Turing.TM0.Machine Γ Λ) (f₁ : Turing.PointedMap Γ Γ')
(f₂ : Turing.PointedMap Γ' Γ) (g₁ : Λ → Λ') (g₂ : Λ' → Λ) {S : Set Λ},
Function.RightInverse f₁.f f... | null | true |
CategoryTheory.NatTrans.CommShift.verticalComposition | Mathlib.CategoryTheory.Shift.CommShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D₁ : Type u_4} {D₂ : Type u_5} {D₃ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} D₁]
[inst_4 : CategoryTheo... | Assume that we have a diagram of categories
```
C₁ ⥤ D₁
‖ ‖
v v
C₂ ⥤ D₂
‖ ‖
v v
C₃ ⥤ D₃
```
with functors `F₁₂ : C₁ ⥤ C₂`, `F₂₃ : C₂ ⥤ C₃` and `F₁₃ : C₁ ⥤ C₃` on the first
column that are related by a natural transformation `α : F₁₃ ⟶ F₁₂ ⋙ F₂₃`
and similarly `β : G₁₂ ⋙ G₂₃ ⟶ G₁₃` on the second column. ... | true |
CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct.casesOn | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{D : Type u₃} →
[inst_4 : CategoryTheory.Cat... | null | false |
Lean.Json.instCoeArrayStructured | Lean.Data.Json.Basic | Coe (Array Lean.Json) Lean.Json.Structured | null | true |
groupCohomology.map_one_fst_of_isCocycle₂ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Monoid G] [inst_1 : AddCommGroup A] [inst_2 : MulAction G A] {f : G × G → A},
groupCohomology.IsCocycle₂ f → ∀ (g : G), f (1, g) = f (1, 1) | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.AddContent.0.MeasureTheory.VectorMeasure.exists_extension_of_isSetRing_of_le_measure_of_dense._simp_1_6 | Mathlib.MeasureTheory.VectorMeasure.AddContent | ∀ {α : Type u_1} {m : MeasurableSpace α} {s₁ s₂ : Set α},
MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (s₁ ∪ s₂) = True | null | false |
Ordinal.iterate_veblen_lt_gamma_zero | Mathlib.SetTheory.Ordinal.Veblen | ∀ (n : ℕ), (fun a => Ordinal.veblen a 0)^[n] 0 < Ordinal.gamma 0 | `veblen (veblen … (veblen 0 0) … 0) 0 < Γ₀` | true |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.PollSources.ctorIdx | Std.Http.Server.Connection | {α β : Type} → Std.Http.Server.Connection.PollSources✝ α β → ℕ | null | false |
ContinuousAlternatingMap.alternatizeUncurryFinCLM._proof_1 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ (𝕜 : Type u_3) (E : Type u_2) (F : Type u_1) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ}
(f : E →L[𝕜] E [⋀^Fin n]→L[𝕜] F) (v : Fin (n + 1) → E),
‖(ContinuousAlternatingMap.alternatizeUncurr... | null | false |
_private.Lean.Compiler.ExternAttr.0.Lean.parseOptNum._unary._proof_2 | Lean.Compiler.ExternAttr | ∀ (pattern : String.Slice) (it : pattern.Pos) (r : ℕ) (h : ¬it.IsAtEnd),
(invImage (fun x => PSigma.casesOn x fun it r => it) String.Slice.Pos.instWellFoundedRelation).1
⟨it.next h, r * 10 + ((it.get h).toNat - '0'.toNat)⟩ ⟨it, r⟩ | null | false |
Equiv.Perm.OnCycleFactors.odd_of_centralizer_le_alternatingGroup | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {g : Equiv.Perm α},
Subgroup.centralizer {g} ≤ alternatingGroup α → ∀ i ∈ g.cycleType, Odd i | null | true |
Matroid.exists_isBasis_union_inter_isBasis._auto_3 | Mathlib.Combinatorics.Matroid.Basic | Lean.Syntax | null | false |
_private.Mathlib.Logic.Equiv.Fin.Rotate.0.Fin.snoc_eq_cons_rotate._simp_1_1 | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
GaloisCoinsertion.isAtom_of_image | Mathlib.Order.Atoms | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : OrderBot α]
[inst_3 : OrderBot β] {l : α → β} {u : β → α} (gi : GaloisCoinsertion l u) {a : α}, IsAtom (l a) → IsAtom a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.