name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
QuaternionAlgebra.imJₗ._proof_2 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} (c₁ c₂ c₃ : R) [inst : CommRing R] (x : R) (x_1 : QuaternionAlgebra R c₁ c₂ c₃),
(x • x_1).imJ = (x • x_1).imJ | null | false |
CategoryTheory.Abelian.SpectralObject.isoMapFourδ₄Toδ₃' | Mathlib.Algebra.Homology.SpectralObject.EpiMono | {C : Type u_1} →
{ι' : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : Preorder ι'] →
(X' : CategoryTheory.Abelian.SpectralObject C ι') →
(i₀ i₁ i₂ i₃ i₄ : ι') →
(hi₀₁ : i₀ ≤ i₁) →
(hi₁₂ :... | For a spectral object indexed by a preorder, this is the isomorphism
`E^{n₁}(i₀ ≤ i₁ ≤ i₂ ≤ i₃) ≅ E^{n₁}(i₀ ≤ i₁ ≤ i₂ ≤ i₄)`
when `H^{n₁-1}(i₃ ≤ i₄)` is a zero object. | true |
_private.Mathlib.Order.KrullDimension.0.Order.coheight_of_noMaxOrder.match_1_1 | Mathlib.Order.KrullDimension | ∀ (m : ℕ) (motive : Fin m → Prop) (h : Fin m), (∀ (i : ℕ) (hi : i < m), motive ⟨i, hi⟩) → motive h | null | false |
Std.DTreeMap.forM_eq_forM | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {m : Type w → Type w'}
[inst : Monad m] [LawfulMonad m] {f : (a : α) → β a → m PUnit.{w + 1}},
Std.DTreeMap.forM f t = forM t fun a => f a.fst a.snd | null | true |
Lattice.toLinearOrder | Mathlib.Order.Lattice | (α : Type u) →
[inst : Lattice α] →
[DecidableEq α] → [DecidableLE α] → [DecidableLT α] → [Std.Total fun x1 x2 => x1 ≤ x2] → LinearOrder α | A lattice with total order is a linear order.
See note [reducible non-instances]. | true |
CategoryTheory.Localization.Monoidal.leftUnitor | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 ... | The left unitor in the localized monoidal category `LocalizedMonoidal L W ε`. | true |
Real.abs_arctan_lt_abs | Mathlib.Analysis.SpecialFunctions.Trigonometric.Bounds | ∀ {x : ℝ}, x ≠ 0 → |Real.arctan x| < |x| | null | true |
BoxIntegral.HasIntegral.tendsto | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {f : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤} {y : F},
... | Reinterpret `BoxIntegral.HasIntegral` as `Filter.Tendsto`, e.g., dot-notation theorems
that are shadowed in the `BoxIntegral.HasIntegral` namespace. | true |
Finsupp.tail._proof_1 | Mathlib.Data.Finsupp.Fin | ∀ {n : ℕ}, Finite (Fin n) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_filterMap_le_size._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Subgroup.inf_subgroupOf_left | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (H K : Subgroup G), (K ⊓ H).subgroupOf K = H.subgroupOf K | null | true |
Lean.Lsp.DocumentHighlightParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | ∀ (toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams),
sizeOf { toTextDocumentPositionParams := toTextDocumentPositionParams } = 1 + sizeOf toTextDocumentPositionParams | null | true |
ZeroAtInftyContinuousMap.copy | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : Zero β] → (f : ZeroAtInftyContinuousMap α β) → (f' : α → β) → f' = ⇑f → ZeroAtInftyContinuousMap α β | Copy of a `ZeroAtInftyContinuousMap` with a new `toFun` equal to the old one. Useful
to fix definitional equalities. | true |
CategoryTheory.Functor.colimitIsoColimitGrothendieck._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_6} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} H] (G : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension G] [CategoryTheory... | null | false |
_private.Mathlib.Data.List.Sublists.0.List.nodup_sublistsLen._simp_1_1 | Mathlib.Data.List.Sublists | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
map_eq_zero_iff | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Zero M] [inst_1 : Zero N] [inst_2 : FunLike F M N]
[ZeroHomClass F M N] (f : F), Function.Injective ⇑f → ∀ {x : M}, f x = 0 ↔ x = 0 | null | true |
_private.Init.Data.Ord.Array.0.Array.compareLex.match_1.eq_1 | Init.Data.Ord.Array | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.eq)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.eq => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | null | true |
TensorAlgebra.ι_eq_zero_iff | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
(TensorAlgebra.ι R) x = 0 ↔ x = 0 | null | true |
Std.Iterators.Types.ListIterator.mk | Init.Data.Iterators.Producers.Monadic.List | {α : Type w} → List α → Std.Iterators.Types.ListIterator α | null | true |
Lean.Parser.Term.hole | Lean.Parser.Term.Basic | Lean.Parser.Parser | A *hole* (or *placeholder term*), which stands for an unknown term that is expected to be inferred based on context.
For example, in `@id _ Nat.zero`, the `_` must be the type of `Nat.zero`, which is `Nat`.
The way this works is that holes create fresh metavariables.
The elaborator is allowed to assign terms to metava... | true |
Lean.Meta.Grind.EMatchTheoremConstraint.check.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (e e_1 : Lean.Expr),
(Lean.Meta.Grind.EMatchTheoremConstraint.check e = Lean.Meta.Grind.EMatchTheoremConstraint.check e_1) = (e = e_1) | null | true |
NonUnitalStarAlgHom.restrictScalars_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ (R : Type u_1) {S : Type u_2} {A : Type u_3} {B : Type u_4} [inst : Monoid R] [inst_1 : Monoid S] [inst_2 : Star A]
[inst_3 : Star B] [inst_4 : NonUnitalNonAssocSemiring A] [inst_5 : NonUnitalNonAssocSemiring B]
[inst_6 : MulAction R S] [inst_7 : DistribMulAction S A] [inst_8 : DistribMulAction S B]
[inst_9 : D... | null | true |
CategoryTheory.ObjectProperty.ContainsZero.mk | Mathlib.CategoryTheory.ObjectProperty.ContainsZero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C},
(∃ Z, CategoryTheory.Limits.IsZero Z ∧ P Z) → P.ContainsZero | null | true |
_private.Lean.Meta.Tactic.Grind.Injective.0.Lean.Meta.Grind.getSymbols | Lean.Meta.Tactic.Grind.Injective | Lean.Expr → Bool → Lean.MetaM (List Lean.HeadIndex) | null | true |
TopCat.Presheaf.stalkPushforward._proof_3 | Mathlib.Topology.Sheaves.Stalks | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasColimits C] {X : TopCat}
(F : TopCat.Presheaf C X) (x : ↑X),
CategoryTheory.Limits.HasColimit
(((CategoryTheory.Functor.whiskeringLeft (TopologicalSpace.OpenNhds x)ᵒᵖ (TopologicalSpace.Opens ↑X)ᵒᵖ C).obj
(Topologi... | null | false |
CategoryTheory.ShortComplex.RightHomologyMapData.neg | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
CategoryTheory.ShortComplex.RightHomolo... | Given a right homology map data for morphism `φ`, this is the induced right homology
map data for `-φ`. | true |
Monoid.Coprod.range_inl_sup_range_inr | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H],
Monoid.Coprod.inl.range ⊔ Monoid.Coprod.inr.range = ⊤ | null | true |
LieAlgebra.SemiDirectSum.right | Mathlib.Algebra.Lie.SemiDirect | {R : Type u_1} →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : LieRing K] →
[inst_2 : LieAlgebra R K] →
{L : Type u_3} →
[inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → {x : L →ₗ⁅R⁆ LieDerivation R K K} → K ⋊⁅x⁆ L → L | The element of L | true |
IsStablyFiniteRing.mk | Mathlib.Data.Matrix.Mul | ∀ {R : Type u_7} [inst : MulOne R] [inst_1 : AddCommMonoid R],
(∀ (n : ℕ), IsDedekindFiniteMonoid (Matrix (Fin n) (Fin n) R)) → IsStablyFiniteRing R | null | true |
DomMulAct.instIsRightCancelMulOfMulOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} [inst : Mul Mᵐᵒᵖ] [IsRightCancelMul Mᵐᵒᵖ], IsRightCancelMul Mᵈᵐᵃ | null | true |
IsAddKleinFour.card_four | Mathlib.GroupTheory.SpecificGroups.KleinFour | ∀ {G : Type u_1} {inst : AddGroup G} [self : IsAddKleinFour G], Nat.card G = 4 | null | true |
Combinatorics.Additive.«termE[_]» | Mathlib.Combinatorics.Additive.Energy | Lean.ParserDescr | The additive energy of a finset `s` in a group is the number of quadruples
`(a₁, a₂, b₁, b₂) ∈ s × s × s × s` such that `a₁ + b₁ = a₂ + b₂`. | true |
Nat.ofDigits | Mathlib.Data.Nat.Digits.Defs | {α : Type u_1} → [Semiring α] → α → List ℕ → α | `ofDigits b L` takes a list `L` of natural numbers, and interprets them
as a number in semiring, as the little-endian digits in base `b`.
| true |
Preorder.mk._flat_ctor | Mathlib.Order.Defs.PartialOrder | {α : Type u_2} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
autoParam (∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) Preorder.lt_iff_le_not_ge._autoParam → Preorder α | null | false |
IsSupFiniteCompact.isSupClosedCompact | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_4} [inst : CompleteLattice α], IsSupFiniteCompact α → IsSupClosedCompact α | null | true |
CategoryTheory.Functor.FullyFaithful.compUliftYonedaCompWhiskeringLeft | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
F.FullyFaithful →
(F.comp
(CategoryTheory.uliftYoneda.{v₁, v₂, u₂}.comp
((CategoryT... | `FullyFaithful.homEquiv` as a natural isomorphism. | true |
Lean.Syntax.SepArray.recOn | Init.Prelude | {sep : String} →
{motive : Lean.Syntax.SepArray sep → Sort u} →
(t : Lean.Syntax.SepArray sep) →
((elemsAndSeps : Array Lean.Syntax) → motive { elemsAndSeps := elemsAndSeps }) → motive t | null | false |
Multiset.keys | Mathlib.Data.Finmap | {α : Type u} → {β : α → Type v} → Multiset (Sigma β) → Multiset α | Multiset of keys of an association multiset. | true |
CategoryTheory.InjectiveResolution.extMk._proof_3 | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {n : ℕ} (m : ℕ), n + 1 = m → ↑n + 1 = ↑m | null | false |
Filter.instCompleteLatticeFilter._proof_3 | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} (x x_1 x_2 : Filter α), x ≤ x_2 → x_1 ≤ x_2 → ∀ x_3 ∈ x_2, x_3 ∈ x ∧ x_3 ∈ x_1 | null | false |
Std.Time.PlainDateTime.ctorIdx | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → ℕ | null | false |
Unitary.coe_symm_linearIsometryEquiv_apply | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] (e : H ≃ₗᵢ[𝕜] H), ↑(Unitary.linearIsometryEquiv.symm e) = ↑↑e | null | true |
Quotient.«_aux_Mathlib_Data_Quot___macroRules_Quotient_term⟦_⟧_1» | Mathlib.Data.Quot | Lean.Macro | null | false |
VAdd.mk.noConfusion | Mathlib.Algebra.Notation.Defs | {G : Type u} →
{P : Type v} →
{P_1 : Sort u_1} → {vadd vadd' : G → P → P} → { vadd := vadd } = { vadd := vadd' } → (vadd ≍ vadd' → P_1) → P_1 | null | false |
RingCat.Colimits.Prequotient.below | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J RingCat} →
{motive : RingCat.Colimits.Prequotient F → Sort u} → RingCat.Colimits.Prequotient F → Sort (max (v + 1) u) | null | false |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.ExtractClosed.extractFVar.match_1 | Lean.Compiler.LCNF.ExtractClosed | (motive : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure)) →
((letDecl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) → motive (some letDecl)) →
((x : Option (Lean.Compiler.LCNF.Let... | null | false |
UniformOnFun.inf_eq | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {γ : Type u_3} {𝔖 : Set (Set α)} {u₁ u₂ : UniformSpace γ},
UniformOnFun.uniformSpace α γ 𝔖 = UniformOnFun.uniformSpace α γ 𝔖 ⊓ UniformOnFun.uniformSpace α γ 𝔖 | If `u₁` and `u₂` are two uniform structures on `γ`, then
`𝒱(α, γ, 𝔖, u₁ ⊓ u₂) = 𝒱(α, γ, 𝔖, u₁) ⊓ 𝒱(α, γ, 𝔖, u₂)`. | true |
FirstOrder.Language.Substructure.mem_carrier | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {s : L.Substructure M} {x : M}, x ∈ ↑s ↔ x ∈ s | null | true |
CategoryTheory.instPreservesFiniteColimitsObjFunctorRightExactFunctor | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : C ⥤ᵣ D), CategoryTheory.Limits.PreservesFiniteColimits F.obj | null | true |
isArtinianRing_iff | Mathlib.RingTheory.Artinian.Defs | ∀ {R : Type u_1} [inst : Semiring R], IsArtinianRing R ↔ IsArtinian R R | null | true |
DirectSum.gMulHom._proof_4 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_2} (A : ι → Type u_1) [inst : Add ι] [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : DirectSum.GNonUnitalNonAssocSemiring A] {i j : ι} (x x_1 : A i), GradedMonoid.GMul.mul (x + x_1) 0 = 0 | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.iteratedDerivWithin_tsum_exp_aux_eq._simp_1_5 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ) [inst_2 : n.AtLeastTwo], (OfNat.ofNat n = 0) = False | null | false |
_private.Lean.Parser.0.Lean.PrettyPrinter.Parenthesizer.charLit.parenthesizer._regBuiltin.Lean.PrettyPrinter.Parenthesizer.charLit.parenthesizer_1 | Lean.Parser | IO Unit | null | false |
AlgebraicGeometry.GeometricallyReduced.eq_geometrically | Mathlib.AlgebraicGeometry.Geometrically.Reduced | @AlgebraicGeometry.GeometricallyReduced = AlgebraicGeometry.geometrically AlgebraicGeometry.IsReduced | null | true |
Int.instCommRing._proof_4 | Mathlib.Algebra.Ring.Int.Defs | ↑0 = ↑0 | null | false |
Std.TreeMap.minEntry! | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Inhabited (α × β)] → Std.TreeMap α β cmp → α × β | Tries to retrieve the key-value pair with the smallest key in the tree map, panicking if the map is
empty.
| true |
CategoryTheory.Limits.Cocone.isColimitOfIsIsoColimMapι | Mathlib.CategoryTheory.Limits.Connected | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C] →
[inst_2 : CategoryTheory.IsConnected J] →
{F : CategoryTheory.Functor J C} →
[inst_3 : CategoryTheory.Limits.HasColimit F] →
(c : Category... | If `J` is connected, `F : J ⥤ C` and `C` is a cocone on `F`, then to check that `c` is a
colimit it is sufficient to check that `colimMap c.ι` is an isomorphism. The converse is also
true, see `Cocone.isColimit_iff_isIso_colimMap_ι`. | true |
IteratedWreathProduct_zero | Mathlib.GroupTheory.RegularWreathProduct | ∀ (G : Type u), IteratedWreathProduct G 0 = PUnit.{u + 1} | null | true |
EReal.neTopBotEquivReal._proof_3 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), ↑x ∈ {⊥, ⊤}ᶜ | null | false |
TrivSqZeroExt | Mathlib.Algebra.TrivSqZeroExt.Basic | Type u → Type v → Type (max u v) | "Trivial Square-Zero Extension".
Given a module `M` over a ring `R`, the trivial square-zero extension of `M` over `R` is defined
to be the `R`-algebra `R × M` with multiplication given by
`(r₁ + m₁) * (r₂ + m₂) = r₁ r₂ + r₁ m₂ + r₂ m₁`.
It is a square-zero extension because `M^2 = 0`.
| true |
CategoryTheory.Functor.PullbackObjObj.mk.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{inst : CategoryTheory.Category.{v₁, u₁} C₁} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} C₂} →
{inst_2 : CategoryTheory.Category.{v₃, u₃} C₃} →
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} →
{... | null | false |
LocalizedModule.lift | Mathlib.Algebra.Module.LocalizedModule.Basic | {R : Type u_1} →
[inst : CommSemiring R] →
(S : Submonoid R) →
{M : Type u_2} →
{M'' : Type u_4} →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M''] →
[inst_3 : Module R M] →
[inst_4 : Module R M''] →
(M →ₗ[R] M'') →
... | If `g` is a linear map `M → M''` such that all scalar multiplication by `s : S` is invertible, then
there is a linear map `LocalizedModule S M → M''`.
| true |
TypeName.recOn | Init.Dynamic | {α : Type u} →
{motive : TypeName α → Sort u_1} →
(t : TypeName α) → ((data : (TypeNameData α).type) → motive { data := data }) → motive t | null | false |
SimplicialObject.opFunctorCompOpFunctorIso | Mathlib.AlgebraicTopology.SimplicialObject.Op | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
SimplicialObject.opFunctor.comp SimplicialObject.opFunctor ≅
CategoryTheory.Functor.id (CategoryTheory.SimplicialObject C) | The functor `opFunctor : SimplicialObject C ⥤ SimplicialObject C`
is a covariant involution. | true |
Int.not_le_of_gt | Init.Data.Int.Order | ∀ {a b : ℤ}, b < a → ¬a ≤ b | null | true |
compl_eq_iff_isCompl | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : BooleanAlgebra α], xᶜ = y ↔ IsCompl x y | null | true |
Int.instCommRing._proof_12 | Mathlib.Algebra.Ring.Int.Defs | ∀ (x : ℕ), Int.negSucc x = Int.negSucc x | null | false |
SimpleGraph.preconnected_top._simp_1 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u}, ⊤.Preconnected = True | null | false |
Lean.Meta.Grind.SavedState.casesOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SavedState → Sort u} →
(t : Lean.Meta.Grind.SavedState) →
((«meta» : Lean.Meta.SavedState) → (grind : Lean.Meta.Grind.State) → motive { «meta» := «meta», grind := grind }) →
motive t | null | false |
WithBot.unbot_le_iff._simp_2 | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithBot α} (hx : x ≠ ⊥), (x.unbot hx ≤ a) = (x ≤ ↑a) | null | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_triple._simp_1_1 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} {a : α} {l : List α} {p : α → α → α → Prop},
List.Triplewise p (a :: l) = (List.Pairwise (p a) l ∧ List.Triplewise p l) | null | false |
Lean.Elab.Tactic.evalFocus | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | null | true |
Subgroup.isMulFG_iff | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, IsMulFG ↥H ↔ ∃ S, Subgroup.closure ↑S = H | null | true |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_nhdsLT._proof_1_2 | Mathlib.Analysis.Calculus.LHopital | ∀ {a : ℝ} {f f' : ℝ → ℝ} (s₁ : Set ℝ),
(∀ y ∈ s₁, HasDerivAt f (f' y) y) →
∀ (s₂ s₃ : Set ℝ) (l : ℝ), Set.Ioo l a ⊆ s₁ ∩ s₂ ∩ s₃ → ∀ x ∈ Set.Ioo l a, HasDerivAt f (f' x) x | null | false |
Subtype.forall' | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {p : α → Prop} {q : (x : α) → p x → Prop}, (∀ (x : α) (h : p x), q x h) ↔ ∀ (x : { a // p a }), q ↑x ⋯ | An alternative version of `Subtype.forall`. This one is useful if Lean cannot figure out `q`
when using `Subtype.forall` from right to left. | true |
Lean.Parser.Command.openRenamingItem.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.ShortComplex.isoCyclesOfIsLimit_hom_iCycles | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology] {kf : CategoryTheory.Limits.KernelFork S.g}
(hkf : CategoryTheory.Limits.IsLimit kf),
CategoryTheory.CategoryStruct.comp (S.isoCyclesO... | null | true |
Multiset.cons_inj_right._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (a : α) {s t : Multiset α}, (a ::ₘ s = a ::ₘ t) = (s = t) | null | false |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.isIrreducible_zeroLocus_iff_of_radical._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X},
IsPreirreducible s = ∀ (z₁ z₂ : Set X), IsClosed z₁ → IsClosed z₂ → s ⊆ z₁ ∪ z₂ → s ⊆ z₁ ∨ s ⊆ z₂ | null | false |
Std.DHashMap.Raw.Const.getD_diff_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m₁.WF →
m₂.WF →
∀ {k : α} {fallback : β},
k ∉ m₂ → Std.DHashMap.Raw.Const.getD (m₁.diff m₂) k fallback = Std.DHashMap.Raw.Const.getD m₁ k fallback | null | true |
_private.Mathlib.Tactic.Translate.GuessName.0.Mathlib.Tactic.GuessName.fixAbbreviationAux.match_3.eq_2 | Mathlib.Tactic.Translate.GuessName | ∀ (motive : List String → List String → Sort u_1) (x : String) (s : List String) (h_1 : Unit → motive [] [])
(h_2 : (x : String) → (s : List String) → motive [] (x :: s))
(h_3 : (pre : String) → (l s' : List String) → motive (pre :: l) s'),
(match [], x :: s with
| [], [] => h_1 ()
| [], x :: s => h_2 x s... | null | true |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic._aux_Batteries_Tactic_Trans___elabRules_Batteries_Tactic_tacticTrans____1.match_3 | Batteries.Tactic.Trans | (motive : Batteries.Tactic.TransRelation → Sort u_1) →
(rel : Batteries.Tactic.TransRelation) →
((name : Lean.Name) → (info : Lean.BinderInfo) → motive (Batteries.Tactic.TransRelation.implies name info)) →
((rel : Lean.Expr) → motive (Batteries.Tactic.TransRelation.app rel)) → motive rel | null | false |
ProperCone.innerDual_empty | Mathlib.Analysis.Convex.Cone.InnerDual | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : CompleteSpace E],
ProperCone.innerDual ∅ = ⊤ | null | true |
WeierstrassCurve.b₂._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | (3 + 1).AtLeastTwo | null | false |
CategoryTheory.CartesianMonoidalCategory.preservesMonomorphisms_tensorLeft | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C] (X : C),
(CategoryTheory.MonoidalCategory.tensorLeft X).PreservesMonomorphisms | null | true |
_private.Mathlib.Computability.Ackermann.0.ack.match_1.eq_2 | Mathlib.Computability.Ackermann | ∀ (motive : ℕ → ℕ → Sort u_1) (m : ℕ) (h_1 : (n : ℕ) → motive 0 n) (h_2 : (m : ℕ) → motive m.succ 0)
(h_3 : (m n : ℕ) → motive m.succ n.succ),
(match m.succ, 0 with
| 0, n => h_1 n
| m.succ, 0 => h_2 m
| m.succ, n.succ => h_3 m n) =
h_2 m | null | true |
CategoryTheory.ProfCat.rec | Mathlib.CategoryTheory.Profunctor.Bicategory | {motive : CategoryTheory.ProfCat → Sort u_1} →
((obj : Type u) → [str : CategoryTheory.Category.{v, u} obj] → motive { obj := obj, str := str }) →
(t : CategoryTheory.ProfCat) → motive t | null | false |
Submodule.rTensorOne' | Mathlib.LinearAlgebra.TensorProduct.Submodule | {R : Type u} →
{S : Type v} →
[inst : CommSemiring R] →
[inst_1 : Semiring S] → [inst_2 : Algebra R S] → (M : Submodule R S) → TensorProduct R ↥M ↥⊥ →ₗ[R] ↥M | If `M` is a submodule in an algebra `S` over `R`, there is the natural `R`-linear map
`M ⊗[R] i(R) →ₗ[R] M` induced by multiplication in `S`, here `i : R → S` is the structure map.
This is promoted to an isomorphism of `R`-modules as `Submodule.rTensorOne`. Use that instead. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.coloringTwoOfVert._proof_2 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V},
G.IsTree → ∀ (u : V) {v w : V}, G.Adj v w → ¬⟨G.dist u v % 2, ⋯⟩ = ⟨G.dist u w % 2, ⋯⟩ | null | false |
Std.DHashMap.Internal.Raw₀.getD_insert | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α],
(↑m).WF →
∀ {k a : α} {fallback : β a} {v : β k},
(m.insert k v).getD a fallback = if h : (k == a) = true then cast ⋯ v else m.getD a fallback | null | true |
_private.Mathlib.Tactic.Positivity.Finset.0.Mathlib.Meta.Positivity.evalFinsetDens._proof_2 | Mathlib.Tactic.Positivity.Finset | ∀ (𝕜 : Q(Type)) (val : Q(PartialOrder «$𝕜»)), «$val» =Q instDistribLatticeOfLinearOrder.toSemilatticeInf.toPartialOrder | null | false |
AlgebraicGeometry.PresheafedSpace.GlueData.ιInvApp | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(D : AlgebraicGeometry.PresheafedSpace.GlueData C) →
[inst_1 : CategoryTheory.Limits.HasLimits C] →
{i : D.J} →
(U : TopologicalSpace.Opens ↑↑(D.U i)) →
(D.U i).presheaf.obj (Opposite.op U) ⟶ CategoryTheory.Limits.limit... | (Implementation) The natural map `Γ(𝒪_{U_i}, U) ⟶ Γ(𝒪_X, 𝖣.ι i '' U)`.
This forms the inverse of `(𝖣.ι i).c.app (op U)`. | true |
Real.toNNReal_lt_toNNReal_iff | Mathlib.Basic.NNReal.Defs | ∀ {r p : ℝ}, 0 < p → (r.toNNReal < p.toNNReal ↔ r < p) | null | true |
isLocallyClosed_Ioi | Mathlib.Topology.Order.IsLocallyClosed | ∀ {X : Type u_1} [inst : TopologicalSpace X] {a : X} [inst_1 : LinearOrder X] [ClosedIicTopology X],
IsLocallyClosed (Set.Ioi a) | null | true |
SimpleGraph.adjMatrix_hadamard_one | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ (α : Type u_1) {V : Type u_2} (G : SimpleGraph V) [inst : DecidableRel G.Adj] [inst_1 : DecidableEq V]
[inst_2 : MulZeroOneClass α], (SimpleGraph.adjMatrix α G).hadamard 1 = 0 | null | true |
List.countP_attach | Init.Data.List.Attach | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, List.countP (fun a => p ↑a) l.attach = List.countP p l | null | true |
CategoryTheory.fieldEndOfFiniteDimensional._proof_5 | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasKernels C] (X : C) [inst_3 : CategoryTheory.Simple X] (n : ℕ)
(a : CategoryTheory.End X), a ^ ↑n.succ = a ^ ↑n * a | null | false |
Set.ite_inter_inter | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (t s₁ s₂ s₁' s₂' : Set α), t.ite (s₁ ∩ s₂) (s₁' ∩ s₂') = t.ite s₁ s₁' ∩ t.ite s₂ s₂' | null | true |
Pi.basis._proof_1 | Mathlib.LinearAlgebra.StdBasis | ∀ {R : Type u_1} [inst : Semiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
Stream'.get.eq_1 | Mathlib.Data.Stream.Init | ∀ {α : Type u} (s : Stream' α) (n : ℕ), s.get n = s n | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.