name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.ObjectProperty.ColimitOfShape.mk._flat_ctor | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P : CategoryTheory.ObjectProperty C} →
{J : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} J] →
{X : C} →
(diag : CategoryTheory.Functor J C) →
(ι : diag ⟶ (CategoryTheory.Functor.const J).ob... | null | false |
_private.Std.Http.Data.URI.Encoding.0.ByteArray.push.match_1.eq_1 | Std.Http.Data.URI.Encoding | ∀ (motive : ByteArray → UInt8 → Sort u_1) (bs : Array UInt8) (b : UInt8)
(h_1 : (bs : Array UInt8) → (b : UInt8) → motive { data := bs } b),
(match { data := bs }, b with
| { data := bs }, b => h_1 bs b) =
h_1 bs b | null | true |
_private.Mathlib.Topology.DiscreteSubset.0.discreteTopology_subtype_iff._simp_1_2 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u} {s : Set α} {p : (x : α) → x ∈ s → Prop}, (∀ (x : α) (h : x ∈ s), p x h) = ∀ (x : ↑s), p ↑x ⋯ | null | false |
Ring.instFaithfulSMulNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S], FaithfulSMul R (Ring.NormalClosure R S) | null | true |
List.permutationsAux2.match_3 | Mathlib.Data.List.Defs | {α : Type u_1} →
{β : Type u_3} →
(motive : List α → (List α → β) → Sort u_2) →
(x : List α) →
(x_1 : List α → β) →
((x : List α → β) → motive [] x) →
((y : α) → (ys : List α) → (f : List α → β) → motive (y :: ys) f) → motive x x_1 | null | false |
AddSubgroup.orderIsoAddCon_symm_apply_coe | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (c : AddCon G), ↑((RelIso.symm AddSubgroup.orderIsoAddCon) c) = c.addSubgroup | null | true |
Finpartition.card_parts_equitabilise | Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {m a b : ℕ} (P : Finpartition s)
(h : a * m + b * (m + 1) = s.card), m ≠ 0 → (Finpartition.equitabilise h).parts.card = a + b | null | true |
Lean.Grind.OrderedRing.toOrderedAdd | Init.Grind.Ordered.Ring | ∀ {R : Type u} {inst : Lean.Grind.Semiring R} {inst_1 : LE R} {inst_2 : LT R} {inst_3 : Std.IsPreorder R}
[self : Lean.Grind.OrderedRing R], Lean.Grind.OrderedAdd R | null | true |
_private.Mathlib.Order.SuccPred.Tree.0.RootedTree.mem_subtrees_disjoint_iff._simp_1_2 | Mathlib.Order.SuccPred.Tree | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | null | false |
Lean.logUnknownDecl | Lean.Log | {m : Type → Type} →
[Monad m] → [Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.Name → m Unit | Log the error message "unknown declaration" | true |
Lean.expandMacros | Init.Meta.Defs | Lean.Syntax → (optParam (Lean.SyntaxNodeKind → Bool) fun k => k != `Lean.Parser.Term.byTactic) → Lean.MacroM Lean.Syntax | Expand macros in the given syntax.
A node with kind `k` is visited only if `p k` is true.
Note that the default value for `p` returns false for `by ...` nodes.
This is a "hack". The tactic framework abuses the macro system to implement extensible tactics.
For example, one can define
```lean
syntax "my_trivial" : tacti... | true |
BitVec.shiftConcat.eq_1 | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : BitVec n) (b : Bool), x.shiftConcat b = BitVec.truncate n (x.concat b) | null | true |
CategoryTheory.MonoidalCategory.tensor_obj | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C × C),
(CategoryTheory.MonoidalCategory.tensor C).obj X = CategoryTheory.MonoidalCategoryStruct.tensorObj X.1 X.2 | null | true |
Set.image_pow_of_ne_zero | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Monoid α] [inst_1 : Monoid β] [inst_2 : FunLike F α β]
[MulHomClass F α β] {n : ℕ}, n ≠ 0 → ∀ (f : F) (s : Set α), ⇑f '' s ^ n = (⇑f '' s) ^ n | null | true |
ContractibleSpace.hequiv_unit | Mathlib.Topology.Homotopy.Contractible | ∀ (X : Type u_1) [inst : TopologicalSpace X] [ContractibleSpace X], Nonempty (ContinuousMap.HomotopyEquiv X Unit) | null | true |
innerSLFlip._proof_3 | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], ContinuousAdd 𝕜 | null | false |
SubMulAction.fixingSubgroupInsertEquiv._proof_5 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_1} {α : Type u_2} [inst : Group M] [inst_1 : MulAction M α] (a : α)
(s : Set ↥(SubMulAction.ofStabilizer M a)) (m : ↥(fixingSubgroup (↥(MulAction.stabilizer M a)) s)),
↑↑m ∈ fixingSubgroup M (insert a (Subtype.val '' s)) | null | false |
CategoryTheory.Limits.BinaryCofan.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X Y : C),
CategoryTheory.Limits.BinaryCofan X Y = CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y) | null | true |
Std.WP.Except.wpInst._proof_1 | Std.WP.Monad.Instances | ∀ {ε : Type u_1} {α : Type u_2} (x : Except ε α) (post post' : α → Prop) (epost epost' : ε → Prop),
Lean.Order.PartialOrder.rel epost epost' →
Lean.Order.PartialOrder.rel post post' →
Lean.Order.PartialOrder.rel ({ apply := fun post epost => Lean.Order.pushExcept post epost x }.apply post epost)
({ ... | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0.WeierstrassCurve.Projective.nonsingular_neg._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [Nontrivial R], W'.Nonsingular ![0, 1, 0] = True | null | false |
Lean.mkFreshLMVarId | Lean.Expr | {m : Type → Type} → [Monad m] → [Lean.MonadNameGenerator m] → m Lean.LMVarId | Polymorphic operation for generating unique/fresh universe metavariable identifiers.
It is available in any monad `m` that implements the interface `MonadNameGenerator`.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.arg_mul_cos_add_sin_mul_I._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ (a b : ℝ), ↑a + ↑b * Complex.I = { re := a, im := b } | null | false |
CategoryTheory.Limits.BiconeMorphism.wι_assoc | 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} {A B : CategoryTheory.Limits.Bicone F}
(self : CategoryTheory.Limits.BiconeMorphism A B) (j : J) {Z : C} (h : B.pt ⟶ Z),
CategoryTheory.CategoryStruct.comp (A.ι j) (CategoryThe... | The triangle consisting of the two natural transformations and `hom` commutes | true |
_private.Lean.Data.Trie.0.Lean.Data.Trie.upsert.insertEmpty._unsafe_rec | Lean.Data.Trie | {α : Type} → String → (Option α → α) → ℕ → Lean.Data.Trie α | null | false |
AddMonoidHom.addSubmonoidComap.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] (f : M →+ N) (N' : AddSubmonoid N),
f.addSubmonoidComap N' = { toFun := fun x => ⟨f ↑x, ⋯⟩, map_zero' := ⋯, map_add' := ⋯ } | null | true |
Lean.Lsp.WorkDoneProgressOptions | Lean.Data.Lsp.Basic | Type | [reference](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/#workDoneProgressOptions) | true |
StandardEtalePair.inv_aeval_X_g | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_1} [inst : CommRing R] (P : StandardEtalePair R),
↑⋯.unit⁻¹ = (Ideal.Quotient.mk (Ideal.span {Polynomial.C P.f, Polynomial.X * Polynomial.C P.g - 1})) Polynomial.X | null | true |
Complex.one_re | Mathlib.Basic.Complex.Basic | Complex.re 1 = 1 | null | true |
_private.Init.Grind.Ring.CommSemiringAdapter.0.Lean.Grind.CommRing.Poly.denoteS.match_1.eq_2 | Init.Grind.Ring.CommSemiringAdapter | ∀ (motive : Lean.Grind.CommRing.Poly → Sort u_1) (k : ℤ) (m : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRing.Poly)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Poly.num k))
(h_2 :
(k : ℤ) →
(m : Lean.Grind.CommRing.Mon) → (p : Lean.Grind.CommRing.Poly) → motive (Lean.Grind.CommRing.Poly.add k m p)),
... | null | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.jp | Lean.Compiler.LCNF.InferBorrow | Lean.Name → Lean.FVarId → Lean.Compiler.LCNF.ParamMap.Key✝ | null | true |
Std.LawfulOrderBEq.mk | Init.Data.Order.Classes | ∀ {α : Type u} [inst : BEq α] [inst_1 : LE α], (∀ (a b : α), (a == b) = true ↔ a ≤ b ∧ b ≤ a) → Std.LawfulOrderBEq α | null | true |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieIdeal.mem_rootSet_of_mem_rootSpan._simp_1_2 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
XorOp.xor | Init.Prelude | {α : Type u} → [self : XorOp α] → α → α → α | The implementation of `a ^^^ b : α`. See `HXor`. | true |
Lean.Elab.Tactic.mkInitialTacticInfo | Lean.Elab.Tactic.Basic | Lean.Syntax → Lean.Elab.Tactic.TacticM (Lean.Elab.Tactic.TacticM Lean.Elab.Info) | null | true |
dite_prop_iff_and | Mathlib.Basic.Logic.Basic | ∀ {P : Prop} [inst : Decidable P] {Q : P → Prop} {R : ¬P → Prop}, dite P Q R ↔ (∀ (h : P), Q h) ∧ ∀ (h : ¬P), R h | null | true |
CategoryTheory.Limits.chosenEnd.map_comp_assoc | Mathlib.CategoryTheory.Limits.Chosen.End | ∀ {J : Type u_3} {C : Type u_4} [inst : CategoryTheory.Category.{v_3, u_4} C]
[inst_1 : CategoryTheory.Category.{v_4, u_3} J] {F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)}
[inst_2 : CategoryTheory.Limits.ChosenEndsOfShape J C] {G H : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)}
(f : F ... | null | true |
IsLowerSet.thickening' | Mathlib.Analysis.Normed.Order.UpperLower | ∀ {α : Type u_1} [inst : NormedCommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α] {s : Set α},
IsLowerSet s → ∀ (ε : ℝ), IsLowerSet (Metric.thickening ε s) | null | true |
HahnSeries.cardSuppLTSubring._proof_2 | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ (Γ : Type u_1) (R : Type u_2) (κ : Cardinal.{u_1}) [inst : PartialOrder Γ] [inst_1 : AddCommMonoid Γ]
[inst_2 : Ring R] [hκ : Fact (Cardinal.aleph0 ≤ κ)], HahnSeries.cardSupp 1 < κ | null | false |
CommMagma.rec | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} →
{motive : CommMagma G → Sort u} →
([toMul : Mul G] → (mul_comm : ∀ (a b : G), a * b = b * a) → motive { toMul := toMul, mul_comm := mul_comm }) →
(t : CommMagma G) → motive t | null | false |
continuous_max | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderClosedTopology α],
Continuous fun p => max p.1 p.2 | null | true |
QuadraticForm.QuadraticMap.discr_smul | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {n : Type w} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R] [inst_3 : Invertible 2]
{Q : QuadraticForm R (n → R)} (a : R), (a • Q).discr' = a ^ Fintype.card n * Q.discr' | **Alias** of `QuadraticForm.discr'_smul`. | true |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.instLawfulUpwardEnumerable | Init.Data.Range.Polymorphic.SInt | ∀ {α : Type u} [inst : LE α] [inst_1 : LT α] {β : Type v} [inst_2 : LE β] [inst_3 : LT β]
[inst_4 : Std.PRange.UpwardEnumerable β] [inst_5 : Std.PRange.LawfulUpwardEnumerable β]
[inst_6 : Std.PRange.LawfulUpwardEnumerableLE β] [inst_7 : Std.PRange.LawfulUpwardEnumerableLT β] [m : HasModel✝ α β],
Std.PRange.Lawful... | null | true |
Lean.Grind.CommRing.Poly.divConst._sunfold | Lean.Meta.Sym.Arith.Poly | Lean.Grind.CommRing.Poly → ℤ → Lean.Grind.CommRing.Poly | null | false |
Finset.prod_fiberwise_le_prod_of_one_le_prod_fiber | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : CommMonoid N] [inst_1 : Preorder N] {s : Finset ι} {ι' : Type u_8}
[inst_2 : DecidableEq ι'] [MulLeftMono N] {t : Finset ι'} {g : ι → ι'} {f : ι → N},
(∀ y ∉ t, 1 ≤ ∏ x ∈ s with g x = y, f x) → ∏ y ∈ t, ∏ x ∈ s with g x = y, f x ≤ ∏ x ∈ s, f x | null | true |
Int.eq_one_of_mul_eq_self_left | Init.Data.Int.Lemmas | ∀ {a b : ℤ}, a ≠ 0 → b * a = a → b = 1 | null | true |
List.Perm.flatMap_left | Mathlib.Data.List.Perm.Basic | ∀ {α : Type u_1} {β : Type u_2} (l : List α) {f g : α → List β},
(∀ a ∈ l, (f a).Perm (g a)) → (List.flatMap f l).Perm (List.flatMap g l) | null | true |
CategoryTheory.Limits.isSplitMonoEqualizes | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.IsSplitMono f] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.coneOfIsSplitMono f) | A split mono `f` equalizes `(retraction f ≫ f)` and `(𝟙 Y)`. | true |
Std.DTreeMap.Internal.Impl.Const.maxEntry?._unsafe_rec | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (Std.DTreeMap.Internal.Impl α fun x => β) → Option (α × β) | null | false |
instNonAssocRingWithConvMatrix._proof_6 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : NonAssocRing α] (n_1 : ℕ), ↑(n_1 + 1) = ↑n_1 + 1 | null | false |
Sublocale.toNucleus._proof_2 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (S : Sublocale X) (x : X), ↑(S.restrict ↑(S.restrict x)) ≤ ↑(S.restrict x) | null | false |
OrderHom.diag | Mathlib.Order.Hom.Basic | {α : Type u_2} → [inst : Preorder α] → α →o α × α | Diagonal embedding of `α` into `α × α` as an `OrderHom`. | true |
FreeGroup.invRev_cons | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {a : α × Bool},
FreeGroup.invRev (a :: L) = FreeGroup.invRev L ++ FreeGroup.invRev [a] | null | true |
Ring.DirectLimit.lift._proof_1 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j) (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P),
(∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) →
∀
a ∈
Ideal.span
{a |
... | null | false |
CategoryTheory.CosimplicialObject.Augmented.const_obj_left | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.CosimplicialObject.Augmented.const.obj X).left = X | null | true |
PerfectRing.lift_comp_lift | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing K] [inst_1 : CommRing L]
[inst_2 : CommRing M] [inst_3 : CommRing N] (i : K →+* L) (j : K →+* M) (k : K →+* N) (p : ℕ) [inst_4 : ExpChar M p]
[inst_5 : ExpChar K p] [inst_6 : PerfectRing M p] [inst_7 : IsPRadical i p] [inst_8 : ExpChar L... | null | true |
NonUnitalNonAssocCommSemiring.casesOn | Mathlib.Algebra.Ring.Defs | {α : Type u} →
{motive : NonUnitalNonAssocCommSemiring α → Sort u_1} →
(t : NonUnitalNonAssocCommSemiring α) →
([toNonUnitalNonAssocSemiring : NonUnitalNonAssocSemiring α] →
(mul_comm : ∀ (a b : α), a * b = b * a) →
motive { toNonUnitalNonAssocSemiring := toNonUnitalNonAssocSemiring, m... | null | false |
Lean.Lsp.TextDocumentSyncKind.none.elim | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentSyncKind → Sort u} →
(t : Lean.Lsp.TextDocumentSyncKind) → t.ctorIdx = 0 → motive Lean.Lsp.TextDocumentSyncKind.none → motive t | null | false |
_private.Mathlib.Analysis.Complex.UpperHalfPlane.Basic.0.Mathlib.Meta.Positivity.evalUpperHalfPlaneCoe._proof_1 | Mathlib.Analysis.Complex.UpperHalfPlane.Basic | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q Complex.instZero)), «$_zα» =Q Complex.instZero | null | false |
WithZero.instDivisionMonoid._proof_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : DivisionMonoid α] (x : WithZero α), x⁻¹⁻¹ = x | null | false |
CategoryTheory.ShortComplex.rightHomologyMapIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasRightHomology] [inst_3 : S₂.HasRightHomology],
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.rightHomologyMap e.h... | null | false |
Finsupp.sumFinsuppLEquivProdFinsupp._proof_1 | Mathlib.LinearAlgebra.Finsupp.SumProd | ∀ {M : Type u_3} (R : Type u_4) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_2}
{β : Type u_1} (m : R) (x : α ⊕ β →₀ M),
Finsupp.sumFinsuppAddEquivProdFinsupp.toFun (m • x) = (RingHom.id R) m • Finsupp.sumFinsuppAddEquivProdFinsupp.toFun x | null | false |
Computation.IsBisimulation | Mathlib.Data.Seq.Computation | {α : Type u} → (Computation α → Computation α → Prop) → Prop | Attribute expressing bisimilarity over two `Computation`s | true |
LaurentSeries.«_aux_Mathlib_RingTheory_LaurentSeries___macroRules_LaurentSeries_term_⸨X⸩_1» | Mathlib.RingTheory.LaurentSeries | Lean.Macro | null | false |
CategoryTheory.Aut.instMul | Mathlib.CategoryTheory.Endomorphism | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (X : C) → Mul (CategoryTheory.Aut X) | null | true |
LinearMap.toContinuousBilinearMap | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
[CompleteSpace 𝕜] →
{E : Type u_2} →
[inst_2 : AddCommGroup E] →
[inst_3 : Module 𝕜 E] →
[inst_4 : TopologicalSpace E] →
[IsTopologicalAddGroup E] →
[ContinuousSMul 𝕜 E] →
... | Building continuous bilinear maps from bilinear maps between finite dimensional topological
vector spaces over a complete field. | true |
Fin.predAbove_last_of_ne_last | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {i : Fin (n + 2)} (hi : i ≠ Fin.last (n + 1)), (Fin.last n).predAbove i = i.castPred hi | null | true |
Subspace.quotEquivAnnihilator._proof_1 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} [inst : Field K], RingHomCompTriple (RingHom.id K) (RingHom.id K) (RingHom.id K) | null | false |
RingConeClass.toAddGroupConeClass | Mathlib.Algebra.Order.Ring.Cone | ∀ {S : Type u_1} {R : outParam (Type u_2)} {inst : Ring R} {inst_1 : SetLike S R} [self : RingConeClass S R],
AddGroupConeClass S R | null | true |
CategoryTheory.instInhabitedSkeleton._aux_1 | Mathlib.CategoryTheory.Skeletal | (C : Type u_2) → [inst : CategoryTheory.Category.{u_1, u_2} C] → [Inhabited C] → CategoryTheory.Skeleton C | null | false |
CategoryTheory.instIsIsoAppFromLeftDerivedZeroOfProjective | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasProjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive] (X : C)
[Categ... | null | true |
CategoryTheory.Limits.cokernel.condition_assoc | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {Z : C} (h : CategoryTheory.Limits.cokernel f ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp (CategoryTheo... | null | true |
Std.DTreeMap.Raw.Const.get?_insertMany_list | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : BEq α] [Std.LawfulBEqCmp cmp],
t.WF →
∀ {l : List (α × β)} {k : α},
Std.DTreeMap.Raw.Const.get? (Std.DTreeMap.Raw.Const.insertMany t l) k =
(List.findSomeRev?
(fu... | null | true |
Set.bijOn_iUnion_of_directed | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_5} {s : ι → Set α},
Directed (fun x1 x2 => x1 ⊆ x2) s →
∀ {t : ι → Set β} {f : α → β}, (∀ (i : ι), Set.BijOn f (s i) (t i)) → Set.BijOn f (⋃ i, s i) (⋃ i, t i) | null | true |
IsLocalization.Away.mk | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (r : R),
IsUnit ((algebraMap R S) r) →
(∀ (s : S), ∃ n a, s * (algebraMap R S) r ^ n = (algebraMap R S) a) →
(∀ (a b : R), (algebraMap R S) a = (algebraMap R S) b → ∃ n, r ^ n * a = r ^ n * b) → IsLocali... | Specialized constructor for `IsLocalization.Away`. | true |
MulDistribMulAction.instQuotientSubgroupSubtypeMemSubgroup._aux_1 | Mathlib.GroupTheory.GroupAction.OfQuotient | {G : Type u_1} →
[inst : Group G] →
{H : Subgroup G} →
[H.Normal] →
{α : Type u_2} →
[inst_2 : Group α] →
[inst_3 : MulDistribMulAction G α] → G ⧸ H → ↥(FixedPoints.subgroup (↥H) α) → ↥(FixedPoints.subgroup (↥H) α) | null | false |
AlgebraicGeometry.IsImmersion.of_comp | Mathlib.AlgebraicGeometry.Morphisms.Immersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.IsImmersion (CategoryTheory.CategoryStruct.comp f g)], AlgebraicGeometry.IsImmersion f | null | true |
_private.Mathlib.GroupTheory.MonoidLocalization.Basic.0.Localization.instHasUniqueRoots._simp_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {a c : M} {b d : ↥S},
(Localization.mk a b = Localization.mk c d) = (Localization.r S) (a, b) (c, d) | null | false |
Vector.instLawfulEqCmpCompareLex | Init.Data.Ord.Vector | ∀ {α : Type u_1} {cmp : α → α → Ordering} [Std.LawfulEqCmp cmp] {n : ℕ}, Std.LawfulEqCmp (Vector.compareLex cmp) | null | true |
Polynomial.natTrailingDegree_X_le | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R], Polynomial.X.natTrailingDegree ≤ 1 | null | true |
Nat.set_induction | Mathlib.Data.Nat.Basic | ∀ {S : Set ℕ}, 0 ∈ S → (∀ k ∈ S, k + 1 ∈ S) → ∀ (n : ℕ), n ∈ S | A subset of `ℕ` containing zero and closed under `Nat.succ` contains all of `ℕ`. | true |
_private.Lean.Compiler.LCNF.Simp.ConstantFold.0.Lean.Compiler.LCNF.Simp.ConstantFold.getNatLit._sparseCasesOn_3 | Lean.Compiler.LCNF.Simp.ConstantFold | {motive : Lean.Compiler.LCNF.LitValue → Sort u} →
(t : Lean.Compiler.LCNF.LitValue) →
((val : ℕ) → motive (Lean.Compiler.LCNF.LitValue.nat val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
String.Slice.Pattern.Model.not_isLongestRevMatch_endPos | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[String.Slice.Pattern.Model.StrictPatternModel pat] {s : String.Slice},
¬String.Slice.Pattern.Model.IsLongestRevMatch pat s.endPos | null | true |
List.sublist_orderedInsert | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] (x : α) (xs : List α),
xs.Sublist (List.orderedInsert r x xs) | null | true |
CategoryTheory.OverPresheafAux.yonedaCollectionPresheafMap₁._proof_1 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {A : CategoryTheory.Functor Cᵒᵖ (Type u_2)}
{F G : CategoryTheory.Functor (CategoryTheory.CostructuredArrow CategoryTheory.yoneda A)ᵒᵖ (Type u_2)} (η : F ⟶ G)
⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.OverPresheafAux... | null | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon_obj | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.LaxMonoidalFunctor (CategoryTheory.Discrete PUnit.{w + 1}) C),
(CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon C).obj F =
F.mapAddMon.obj (CategoryTheory.AddMon.tr... | null | true |
Lean.Parser.Term.borrowed.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Mathlib.Algebra.Group.Subgroup.Ker.0.Subgroup.map_eq_map_iff._simp_1_2 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] {f : G →* N} {H K : Subgroup G},
(Subgroup.map f H ≤ Subgroup.map f K) = (H ⊔ f.ker ≤ K ⊔ f.ker) | null | false |
intervalIntegral.continuousAt_of_dominated_interval | Mathlib.MeasureTheory.Integral.DominatedConvergence | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {μ : MeasureTheory.Measure ℝ} {X : Type u_3}
[inst_2 : TopologicalSpace X] [FirstCountableTopology X] {F : X → ℝ → E} {x₀ : X} {bound : ℝ → ℝ} {a b : ℝ},
(∀ᶠ (x : X) in nhds x₀, MeasureTheory.AEStronglyMeasurable (F x) (μ.restrict (Set.uIoc a... | Continuity of interval integral with respect to a parameter at a point.
Given `F : X → ℝ → E`, assume `F x` is ae-measurable on `[a, b]` for `x` in a
neighborhood of `x₀`, and assume it is bounded by a function integrable on
`[a, b]` independent of `x` in a neighborhood of `x₀`. If `(fun x ↦ F x t)`
is continuous at `x... | true |
CategoryTheory.Adjunction.whiskerRight | Mathlib.CategoryTheory.Adjunction.Whiskering | (C : Type u_1) →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{F : CategoryTheory.Functor D E} →
{G : CategoryTheory.Functor E ... | Given an adjunction `F ⊣ G`, this provides the natural adjunction
`(whiskeringRight C _ _).obj F ⊣ (whiskeringRight C _ _).obj G`. | true |
ZFSet.not_nonempty_empty._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∅.Nonempty = False | null | false |
ContMDiffAddMonoidMorphism.contMDiff_toFun | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {H' : Type u_5} [inst_4 : TopologicalSpace H']
{E' : Type u_6} [inst_5 : NormedAddCommGroup E'] [inst_6 : NormedSpace 𝕜 E'] {I : ModelWithCor... | null | true |
Aesop.instBEqForwardRuleMatch.beq | Aesop.Forward.Match.Types | Aesop.ForwardRuleMatch → Aesop.ForwardRuleMatch → Bool | null | true |
Nat.divisors_ofNat | Mathlib.Tactic.Simproc.Divisors | Lean.Meta.Simp.DSimproc | The dsimproc `Nat.divisors_ofNat` computes the finset `Nat.divisors n` when `n` is a
numeral. For instance, this simplifies `Nat.divisors 6` to `{1, 2, 3, 6}`. | true |
CategoryTheory.Comma.mapLeftIso_inverse_map_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ : CategoryTheory.Functor A T} (i : L₁ ≅ L₂) {X Y : CategoryTheory.Comma L₂ R} (f : X ⟶ Y),
((C... | null | true |
HomotopyEquiv.toHomologyIso | Mathlib.Algebra.Homology.Homotopy | {C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{ι : Type u_3} →
{c : ComplexShape ι} →
{K L : HomologicalComplex C c} →
HomotopyEquiv K L →
(i : ι) → [inst_2 : K.HasHomology i] → [inst_3 : L.HasHomology i... | The isomorphism in homology induced by a homotopy equivalence. | true |
FirstOrder.Language.realize_denselyOrdered_iff | Mathlib.ModelTheory.Order | ∀ {L : FirstOrder.Language} {M : Type w'} [inst : L.IsOrdered] [inst_1 : L.Structure M] [inst_2 : Preorder M]
[L.OrderedStructure M], M ⊨ L.denselyOrderedSentence ↔ DenselyOrdered M | null | true |
CommRingCat.Under.instPreservesLimitUnderDiscreteFunctorTensorProdOfFinite | Mathlib.Algebra.Category.Ring.Under.Limits | ∀ {R S : CommRingCat} [inst : Algebra ↑R ↑S] (J : Type u) [Finite J] (f : J → CategoryTheory.Under R),
CategoryTheory.Limits.PreservesLimit (CategoryTheory.Discrete.functor f) (R.tensorProd S) | null | true |
CategoryTheory.Limits.ChosenCoendsOfShape.mk | Mathlib.CategoryTheory.Limits.Chosen.End | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{C : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
(cowedge : (F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)) → CategoryTheory.Limits.Cowedge F) →
((F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory... | null | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.exists_goodδ._simp_1_3 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b : α}, (a - b ≤ 0) = (a ≤ b) | null | false |
Part.none_ne_some | Mathlib.Data.Part | ∀ {α : Type u_1} (x : α), Part.none ≠ Part.some x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.