name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.GrothendieckTopology.MayerVietorisSquare.mk'._proof_2 | Mathlib.CategoryTheory.Sites.MayerVietorisSquare | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : CategoryTheory.HasWeakSheafify J (Type u_2)] (sq : CategoryTheory.Square C),
(∀ (F : CategoryTheory.Sheaf J (Type u_2)), (sq.op.map F.obj).IsPullback) →
(sq.map (CategoryTheory.yoneda.comp (Categ... | null | false |
AddEquiv.comp_right_injective | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (e : M ≃+ N), Function.Injective fun f => (↑e).comp f | null | true |
BitVec.ofNat_or | Init.Data.BitVec.Lemmas | ∀ {w x y : ℕ}, BitVec.ofNat w (x ||| y) = BitVec.ofNat w x ||| BitVec.ofNat w y | null | true |
LinearEquiv.prodProdProdComm | Mathlib.LinearAlgebra.Prod | (R : Type u) →
(M : Type v) →
(M₂ : Type w) →
(M₃ : Type y) →
(M₄ : Type z) →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : AddCommMonoid M₄] →
... | Four-way commutativity of `prod`. The name matches `mul_mul_mul_comm`. | true |
CategoryTheory.LocalizerMorphism.rec | Mathlib.CategoryTheory.Localization.LocalizerMorphism | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{motive : CategoryTheory.LocalizerMorphism W₁ W₂ → Sort u} →... | null | false |
_private.Mathlib.Algebra.CubicDiscriminant.0.Cubic.ext.match_1 | Mathlib.Algebra.CubicDiscriminant | ∀ {R : Type u_1} (motive : Cubic R → Prop) (h : Cubic R),
(∀ (a b c d : R), motive { a := a, b := b, c := c, d := d }) → motive h | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.withFreshNGen | Lean.Meta.Tactic.Grind.EMatch | {α : Type} → Lean.Meta.Grind.EMatch.M α → Lean.Meta.Grind.EMatch.M α | Use a fresh name generator for creating internal metavariables for theorem instantiation.
This is technique to ensure the metavariables ids do not depend on operations performed before invoking `grind`.
Without this trick, we experience counterintuitive behavior where small changes affect the metavariable ids, and
cons... | true |
Lean.Lsp.instToJsonInitializeResult.toJson | Lean.Data.Lsp.InitShutdown | Lean.Lsp.InitializeResult → Lean.Json | null | true |
Polynomial.Bivariate.swap | Mathlib.Algebra.Polynomial.Bivariate | {R : Type u_1} → [inst : CommSemiring R] → Polynomial (Polynomial R) ≃ₐ[R] Polynomial (Polynomial R) | The R-algebra automorphism given by `X ↦ Y` and `Y ↦ X`. | true |
Std.HashMap.Raw.isEmpty_emptyWithCapacity | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [BEq α] [Hashable α] {c : ℕ}, (Std.HashMap.Raw.emptyWithCapacity c).isEmpty = true | null | true |
Filter.HasBasis.disjoint_iff | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_3} {ι' : Sort u_4} {l l' : Filter α} {p : ι → Prop} {s : ι → Set α} {p' : ι' → Prop}
{s' : ι' → Set α},
l.HasBasis p s → l'.HasBasis p' s' → (Disjoint l l' ↔ ∃ i, p i ∧ ∃ i', p' i' ∧ Disjoint (s i) (s' i')) | null | true |
Semiquot.get.congr_simp | Mathlib.Data.Semiquot | ∀ {α : Type u_1} (q q_1 : Semiquot α) (e_q : q = q_1) (h : q.IsPure), q.get h = q_1.get ⋯ | null | true |
CategoryTheory.Limits.IsColimit.nonempty_isColimit_iff_isIso_desc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {s t : CategoryTheory.Limits.Cocone F} (hs : CategoryTheory.Limits.IsColimit s),
Nonempty (CategoryTheory.Limits.IsColimit t) ↔ CategoryTheory.IsIso (hs.desc t) | null | true |
ENNReal.mul_eq_right | Mathlib.Basic.ENNReal.Operations | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → (a * b = b ↔ a = 1) | null | true |
CategoryTheory.Mon.instHasZeroMorphisms | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | {D : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} D] →
[inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D] →
CategoryTheory.Limits.HasZeroMorphisms (CategoryTheory.Mon D) | null | true |
Array.pmap_attachWith | Init.Data.Array.Attach | ∀ {α : Type u_1} {q : α → Prop} {β : Type u_2} {xs : Array α} {p : { x // q x } → Prop}
{f : (a : { x // q x }) → p a → β} (H₁ : ∀ x ∈ xs, q x) (H₂ : ∀ a ∈ xs.attachWith q H₁, p a),
Array.pmap f (xs.attachWith q H₁) H₂ = Array.pmap (fun a h => f ⟨a, ⋯⟩ ⋯) xs ⋯ | null | true |
IntermediateField.fixingSubgroupEquiv._proof_2 | Mathlib.FieldTheory.Galois.Basic | ∀ {F : Type u_2} [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (K : IntermediateField F E),
Function.RightInverse (fun ϕ => ⟨AlgEquiv.restrictScalars F ϕ, ⋯⟩) fun ϕ =>
let __src := (↑ϕ).toRingEquiv;
{ toEquiv := __src.toEquiv, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ } | null | false |
isUpperSet_iff_Ioi_subset | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s : Set α}, IsUpperSet s ↔ ∀ ⦃a : α⦄, a ∈ s → Set.Ioi a ⊆ s | null | true |
ULift.isIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X] [IsIsometricSMul M X],
IsIsometricSMul (ULift.{u_2, u} M) X | null | true |
Composition.recOnSingleAppend | Mathlib.Combinatorics.Enumerative.Composition | {motive : (n : ℕ) → Composition n → Sort u_1} →
{n : ℕ} →
(c : Composition n) →
motive 0 (Composition.ones 0) →
((k n : ℕ) → (c : Composition n) → motive n c → motive (k + 1 + n) ((Composition.single (k + 1) ⋯).append c)) →
motive n c | Induction (recursion) principle on `c : Composition _`
that corresponds to the usual induction on the list of blocks of `c`. | true |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.drop.match_1.splitter | Mathlib.Data.Seq.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | true |
_private.Mathlib.Data.Finset.Option.0.Option.mem_toFinset._simp_1_1 | Mathlib.Data.Finset.Option | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
ContinuousOn.continuous_of_mulTSupport_subset | Mathlib.Topology.Algebra.Support | ∀ {α : Type u_2} {β : Type u_4} [inst : TopologicalSpace α] [inst_1 : One β] [inst_2 : TopologicalSpace β] {f : α → β}
{s : Set α}, ContinuousOn f s → IsOpen s → mulTSupport f ⊆ s → Continuous f | null | true |
Lean.Expr.getUsedConstantsAsSet | Lean.Util.FoldConsts | Lean.Expr → Lean.NameSet | Like `Expr.getUsedConstants`, but produce a `NameSet`. | true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Braided.0.CategoryTheory.Localization.Monoidal.instIsLocalizationLocalizedMonoidalToMonoidalCategory_1._proof_1 | Mathlib.CategoryTheory.Localization.Monoidal.Braided | ∀ {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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} (ε : ... | null | false |
MulAction.isBlock_top | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {B : Set X},
MulAction.IsBlock (↥⊤) B ↔ MulAction.IsBlock G B | null | true |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.Style.setOption.isSetOption._sparseCasesOn_1 | Mathlib.Tactic.Linter.Style | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Subgroup.range_zpowersHom | Mathlib.Algebra.Group.Subgroup.ZPowers.Lemmas | ∀ {G : Type u_1} [inst : Group G] (g : G), ((zpowersHom G) g).range = Subgroup.zpowers g | null | true |
Lean.Lsp.Ipc.writeRequest | Lean.Data.Lsp.Ipc | {α : Type u_1} → [Lean.ToJson α] → Lean.JsonRpc.Request α → Lean.Lsp.Ipc.IpcM Unit | null | true |
CategoryTheory.SimplicialObject.Splitting.nondegComplex | Mathlib.AlgebraicTopology.DoldKan.SplitSimplicialObject | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : CategoryTheory.SimplicialObject C} → X.Splitting → [inst_1 : CategoryTheory.Preadditive C] → ChainComplex C ℕ | If `s` is a splitting of a simplicial object `X` in a preadditive category,
`s.nondegComplex` is a chain complex which is given in degree `n` by
the nondegenerate `n`-simplices of `X`. This chain complex should be thought
as the normalized chain complex of `X` because of the isomorphism
`toKaroubiNondegComplexIsoN₁`. | true |
Equiv.lieEquiv | Mathlib.Algebra.Lie.TransferInstance | (R : Type u_1) →
{M : Type u_2} →
{L : Type u_3} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → [inst_3 : LieRing L] → [inst_4 : LieAlgebra R L] → (e : M ≃ₗ[R] L) → M ≃ₗ⁅R⁆ L | **Alias** of `LinearEquiv.lieEquiv`.
---
An equivalence `e : M ≃ₗ[R] L` gives a Lie algebra equivalence `M ≃ₗ⁅R⁆ L` where the Lie bracket
on `M` is the one obtained by transporting a Lie Bracket on `L` back along `e`. | true |
Lean.Expr.forallInfo | Lean.Expr | (a : Lean.Expr) → a.isForall = true → Lean.BinderInfo | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex.0.SSet.Subcomplex.Pairing.RankFunction.range_homOfLE_app_union_range_b_app._simp_1_3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Ordinal.instOrderTopology | Mathlib.SetTheory.Ordinal.Topology | OrderTopology Ordinal.{u} | null | true |
Add.mk | Init.Prelude | {α : Type u} → (α → α → α) → Add α | null | true |
FractionalIdeal.extendedHom_eq_zero_iff | Mathlib.RingTheory.FractionalIdeal.Extended | ∀ {A : Type u_1} {K : Type u_2} (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : IsDomain A]
[inst_2 : CommRing B] [inst_3 : IsDomain B] [inst_4 : Algebra A B] [inst_5 : Module.IsTorsionFree A B]
[inst_6 : Field K] [inst_7 : Field L] [inst_8 : Algebra A K] [inst_9 : Algebra B L] [inst_10 : IsFractionRing... | null | true |
RootPairing.restrictScalars'._proof_13 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_3} {L : Type u_4} {M : Type u_1} {N : Type u_5} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_2)
[inst_5 : Field K] [inst_6 : Module K M] (i : ι), P.root i ∈ ↑(Submodule.span K (Set.range ⇑P.root)) | null | false |
Equiv.Set.union._proof_2 | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} {s t : Set α}, Disjoint s t → ∀ x ∈ t, x ∈ s → False | null | false |
InfHom.id | Mathlib.Order.Hom.Lattice | (α : Type u_2) → [inst : Min α] → InfHom α α | `id` as an `InfHom`. | true |
FreeMagma.traverse_pure' | Mathlib.Algebra.Free | ∀ {α β : Type u} {m : Type u → Type u} [inst : Applicative m] (F : α → m β), traverse F ∘ pure = fun x => pure <$> F x | null | true |
_private.Mathlib.Tactic.NormNum.IsSquare.0.Mathlib.Meta.NormNum.evalIsSquareRat.match_91 | Mathlib.Tactic.NormNum.IsSquare | (mulQ : Q(Mul ℚ)) →
(a : Q(ℚ)) →
(motive : (b : Bool) × Mathlib.Meta.NormNum.BoolResult q(IsSquare «$a») b → Sort u_1) →
(x : (b : Bool) × Mathlib.Meta.NormNum.BoolResult q(IsSquare «$a») b) →
((b : Bool) → (pb : Mathlib.Meta.NormNum.BoolResult q(IsSquare «$a») b) → motive ⟨b, pb⟩) → motive x | null | false |
PartialEquiv.IsImage.preimage_eq | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
e.IsImage s t → e.source ∩ ↑e ⁻¹' t = e.source ∩ s | **Alias** of the forward direction of `PartialEquiv.IsImage.iff_preimage_eq`. | true |
CategoryTheory.MonoidalCategory.Arrow.PullbackHom.isTerminalIso_hom_right | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C] (X : CategoryTheory.Arrow C)
{T : C} (t : CategoryTheory.Limits.IsTerminal T) {W : C},
(CategoryTheory.MonoidalCategory.A... | null | true |
ExceptCpsT.runK_bind_lift | Init.Control.ExceptCps | ∀ {m : Type u_1 → Type u_2} {α ε β a : Type u_1} {ok : β → m a} {error : ε → m a} [inst : Monad m] (x : m α)
(f : α → ExceptCpsT ε m β),
(ExceptCpsT.lift x >>= f).runK ok error = do
let a_1 ← x
(f a_1).runK ok error | null | true |
Std.Time.Year.instOfNatOffset | Std.Time.Date.Unit.Year | {n : ℕ} → OfNat Std.Time.Year.Offset n | null | true |
Lean.Grind.CommRing.Poly.add.noConfusion | Init.Grind.Ring.CommSolver | {P : Sort u} →
{k : ℤ} →
{v : Lean.Grind.CommRing.Mon} →
{p : Lean.Grind.CommRing.Poly} →
{k' : ℤ} →
{v' : Lean.Grind.CommRing.Mon} →
{p' : Lean.Grind.CommRing.Poly} →
Lean.Grind.CommRing.Poly.add k v p = Lean.Grind.CommRing.Poly.add k' v' p' →
(k ... | null | false |
Module.ofMinimalAxioms._proof_2 | Mathlib.Algebra.Module.MinimalAxioms | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : SMul R M]
(add_smul : ∀ (r s : R) (x : M), (r + s) • x = r • x + s • x) (x : M), (AddMonoidHom.mk' (fun x_1 => x_1 • x) ⋯) 0 = 0 | null | false |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.modify._proof_1 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] (a : α) (f : β a → β a)
(m m' : Std.DHashMap α β), m.Equiv m' → Std.ExtDHashMap.mk (m.modify a f) = Std.ExtDHashMap.mk (m'.modify a f) | null | false |
Primrec.nat_rec' | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {f : α → ℕ} {g : α → β}
{h : α → ℕ × β → β},
Primrec f → Primrec g → Primrec₂ h → Primrec fun a => Nat.rec (g a) (fun n IH => h a (n, IH)) (f a) | null | true |
Complex.«term_×ℂ_» | Mathlib.Basic.Complex.Basic | Lean.TrailingParserDescr | The product of a set on the real axis and a set on the imaginary axis of the complex plane,
denoted by `s ×ℂ t`. | true |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.mkToSMatch.mkAlts.match_1 | Mathlib.Tactic.DeriveEncodable | (motive : Option Lean.Name → Sort u_1) →
(recName? : Option Lean.Name) →
((recName : Lean.Name) → motive (some recName)) → ((x : Option Lean.Name) → motive x) → motive recName? | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.initFn._@.Lean.Elab.DocString.288960067._hygCtx._hyg.2 | Lean.Elab.DocString | IO (IO.Ref (Lean.NameMap (Array (Lean.Name × Lean.Doc.DocCodeBlockExpander)))) | null | false |
Lean.Meta.arrowDomainsN | Lean.Meta.InferType | ℕ → Lean.Expr → Lean.MetaM (Array Lean.Expr) | Given `n` and a non-dependent function type `α₁ → α₂ → ... → αₙ → Sort u`, returns the
types `α₁, α₂, ..., αₙ`. Throws an error if there are not at least `n` argument types or if a
later argument type depends on a prior one (i.e., it's a dependent function type).
This can be used to infer the expected type of the alte... | true |
Std.HashSet.Equiv.mk._flat_ctor | Std.Data.HashSet.Basic | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α}, m₁.inner.Equiv m₂.inner → m₁.Equiv m₂ | null | false |
Lean.Compiler.CSimp.Entry.noConfusion | Lean.Compiler.CSimpAttr | {P : Sort u} → {t t' : Lean.Compiler.CSimp.Entry} → t = t' → Lean.Compiler.CSimp.Entry.noConfusionType P t t' | null | false |
Array.find?_filterMap | Init.Data.Array.Find | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β} {p : β → Bool},
Array.find? p (Array.filterMap f xs) = (Array.find? (fun a => Option.any p (f a)) xs).bind f | null | true |
Int32.toInt_le | Init.Data.SInt.Lemmas | ∀ (x : Int32), x.toInt ≤ Int32.maxValue.toInt | null | true |
IntermediateField.inf_relfinrank_right | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (A B : IntermediateField F E),
(A ⊓ B).relfinrank B = A.relfinrank B | null | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.isCompact_iff_totallyBounded_isComplete.match_1_3 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u_1} [uniformSpace : UniformSpace α] {s : Set α} (f : Filter α) (motive : (∃ x ∈ s, ClusterPt x f) → Prop)
(x : ∃ x ∈ s, ClusterPt x f), (∀ (a : α) (as : a ∈ s) (fa : ClusterPt a f), motive ⋯) → motive x | null | false |
Topology.IsInducing.regularSpace | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [RegularSpace X] [inst_2 : TopologicalSpace Y] {f : Y → X},
Topology.IsInducing f → RegularSpace Y | null | true |
AlgebraicGeometry.SpecMap_preimage_basicOpen | Mathlib.AlgebraicGeometry.Scheme | ∀ {R S : CommRingCat} (f : R ⟶ S) (r : ↑R),
(TopologicalSpace.Opens.map (AlgebraicGeometry.Spec.map f).base).obj (PrimeSpectrum.basicOpen r) =
PrimeSpectrum.basicOpen ((CategoryTheory.ConcreteCategory.hom f) r) | null | true |
_private.Mathlib.Order.Filter.Ultrafilter.Defs.0.Ultrafilter.exists_le.match_1_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_1} (f : Filter α) (motive : (∃ a, IsAtom a ∧ a ≤ f) → Prop) (x : ∃ a, IsAtom a ∧ a ≤ f),
(∀ (u : Filter α) (hu : IsAtom u) (huf : u ≤ f), motive ⋯) → motive x | null | false |
TopModuleCat.ofCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J] {F : CategoryTheory.Functor J (TopModuleCat R)}
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)))) {X Y : J}
(f : X ⟶ Y),
CategoryTheory.Ca... | null | false |
Mathlib.Tactic.UnfoldBoundary.UnfoldEntry.cast | Mathlib.Tactic.Translate.UnfoldBoundary | Lean.Name → Lean.Name → Lean.Name → Lean.Name → Lean.Name → Mathlib.Tactic.UnfoldBoundary.UnfoldEntry | null | true |
IsAdjoinRootMonic.powerBasis_basis | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
(h : IsAdjoinRootMonic S f), h.powerBasis.basis = h.basis | null | true |
Rack.toEnvelGroup.mapAux._sunfold | Mathlib.Algebra.Quandle | {R : Type u_1} →
[inst : Rack R] → {G : Type u_2} → [inst_1 : Group G] → ShelfHom R (Quandle.Conj G) → Rack.PreEnvelGroup R → G | null | false |
emultiplicity_le_emultiplicity_of_dvd_right | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] {a b c : α}, b ∣ c → emultiplicity a b ≤ emultiplicity a c | null | true |
SymplecticGroup.instGroupSubtypeMatrixSumMemSubmonoidSymplecticGroup | Mathlib.LinearAlgebra.SymplecticGroup | {l : Type u_1} →
{R : Type u_2} →
[inst : DecidableEq l] → [inst_1 : Fintype l] → [inst_2 : CommRing R] → Group ↥(Matrix.symplecticGroup l R) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.aux_summable_add | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {k : ℕ}, 1 ≤ k → ∀ (x : ℂ), Summable fun n => (x + (↑n + 1)) ^ (-1 - ↑k) | null | true |
CategoryTheory.Limits.DiagramOfCones.mkOfHasLimits._proof_6 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) [inst_3 : CategoryTheory.Limits.HasLimitsOfShape K C]
{j₁ j₂ j₃ :... | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt32.toUSize_not._simp_1_1 | Init.Data.UInt.Bitwise | ∀ (a : UInt32) (b : USize), (a.toUSize = b % 4294967296) = (a = b.toUInt32) | null | false |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.cancel_natIso_hom_right_assoc._simp_1_2 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Y ⟶ X) [CategoryTheory.Mono f] {g h : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) | null | false |
Submonoid.LocalizationMap.eq_iff_eq | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) (g : S.LocalizationMap P) {x y : M}, f x = f y ↔ g x = g y | null | true |
_private.Lean.Linter.AmbiguousOpen.0.Lean.Linter.scopeCandidates._sunfold | Lean.Linter.AmbiguousOpen | Lean.Environment → Lean.Name → Lean.Name → List Lean.Name | null | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.map_add_toList_roc'._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ (n m k : ℕ), n + (m + k) = n + m + k | null | false |
Finset.map_ssubset_map._simp_1 | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s t : Finset α}, (Finset.map f s ⊂ Finset.map f t) = (s ⊂ t) | null | false |
_private.Mathlib.Algebra.Group.Int.Even.0.Int.instDecidablePredIsSquare._simp_1 | Mathlib.Algebra.Group.Int.Even | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Padic.adicCompletionEquiv._proof_4 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Algebra R ℚ]
[inst_3 : IsIntegralClosure R ℤ ℚ] (p : Nat.Primes),
p = Rat.HeightOneSpectrum.primesEquiv (Rat.HeightOneSpectrum.primesEquiv.symm p) | null | false |
List.take_eq_self_iff._simp_1 | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (x : List α) {n : ℕ}, (List.take n x = x) = (x.length ≤ n) | null | false |
_private.Aesop.Forward.Substitution.0.Aesop.Substitution.mergeCompatible._proof_1 | Aesop.Forward.Substitution | ∀ (s₂ : Aesop.Substitution), ∀ i ∈ [:s₂.premises.size], i < s₂.premises.size | null | false |
Lean.Meta.Grind.AC.DiseqCnstr.brecOn.eq | Lean.Meta.Tactic.Grind.AC.Types | ∀ {motive_1 : Lean.Meta.Grind.AC.DiseqCnstr → Sort u} {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u}
(t : Lean.Meta.Grind.AC.DiseqCnstr) (F_1 : (t : Lean.Meta.Grind.AC.DiseqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.AC.DiseqCnstrProof) → t.below → motive_2 t),
t.brecOn F_1 F_2 = F_1 t (L... | null | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State._sizeOf_inst | Lean.Meta.Tactic.Simp.Arith.Int.Basic | SizeOf Lean.Meta.Simp.Arith.Int.ToLinear.State | null | false |
InfHom.instSemilatticeInf._proof_3 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : SemilatticeInf β] {x y : InfHom α β}, ⇑y < ⇑x ↔ ⇑y < ⇑x | null | false |
ContinuousAffineMap.fst_decompContinuousLinearEquiv | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ (R : Type u_1) (V : Type u_2) (W : Type u_3) [inst : NormedField R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : TopologicalSpace V] [inst_4 : AddCommGroup W] [inst_5 : Module R W] [inst_6 : TopologicalSpace W]
[inst_7 : IsTopologicalAddGroup V] [inst_8 : ContinuousSMul R V] [inst_9 : IsTopologicalAd... | null | true |
Set.Ici_sdiff_Ioi_same | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a : α}, Set.Ici a \ Set.Ioi a = {a} | null | true |
Mathlib.Tactic.Matrix.DotProductEq.l₁ | Mathlib.Tactic.Matrix.MulExpand | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{aα : Q(Add «$α»)} → {mα : Q(Mul «$α»)} → Mathlib.Tactic.Matrix.DotProductEq zα aα mα → Q(List «$α») | The first list. | true |
Module.Presentation.tautological.R | Mathlib.Algebra.Module.Presentation.Tautological | Type u → Type v → Type (max u v) | The type which parametrizes the tautological relations in an `A`-module `M`. | true |
LowerAdjoint.instInhabitedId | Mathlib.Order.Closure | {α : Type u_1} → [inst : Preorder α] → Inhabited (LowerAdjoint id) | null | true |
FirstOrder.Language.Substructure.casesOn | Mathlib.ModelTheory.Substructures | {L : FirstOrder.Language} →
{M : Type w} →
[inst : L.Structure M] →
{motive : L.Substructure M → Sort u_1} →
(t : L.Substructure M) →
((carrier : Set M) →
(fun_mem : ∀ {n : ℕ} (f : L.Functions n), FirstOrder.Language.ClosedUnder f carrier) →
motive { carrier :... | null | false |
_private.Mathlib.RingTheory.Polynomial.IsIntegral.0.IsIntegral.coeff._simp_1_7 | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | null | false |
CategoryTheory.HasExactColimitsOfShape.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {J : Type u'} →
[inst : CategoryTheory.Category.{v', u'} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasColimitsOfShape J C] →
{motive : CategoryTheory.HasExactColimitsOfShape J C → Sort u_1} →
((preservesFiniteLimits : Cate... | null | false |
NNReal.toReal_le | Mathlib.Basic.NNReal.Basic | ∀ (a b : NNReal), a ≤ b ↔ ↑a ≤ ↑b | null | true |
CategoryTheory.Functor.IsRightDerivedFunctor.isLeftKanExtension | Mathlib.CategoryTheory.Functor.Derived.RightDerived | ∀ {C : Type u_1} {D : Type u_2} {H : 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} H}
(RF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : F ⟶ L.comp RF) (W : ... | null | true |
BitVec.toNat_lt_iff_getLsbD_eq_false | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, ∀ i < w, x.toNat < 2 ^ i ↔ ∀ (k : ℕ), x.getLsbD (i + k) = false | A bitvector interpreted as a natural number is strictly smaller than `2 ^ i` if and only if
all bits at position `i` or higher are false. | true |
Representation.Coinvariants.le_comap_ker | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (S : Subgroup G) [S.Normal] (g : G),
Representation.Coinvariants.ker (MonoidHom.comp ρ S.subtype) ≤
Submodule.comap (ρ g) (Representation.Coinvariants.... | null | true |
List.getElem_concat_length | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {a : α} {i : ℕ}, i = l.length → ∀ (w : i < (l ++ [a]).length), (l ++ [a])[i] = a | null | true |
ModuleCat.smulShortComplex_X₂_carrier | Mathlib.RingTheory.Regular.Category | ∀ {R : Type u} [inst : CommRing R] (M : ModuleCat R) (r : R), ↑(M.smulShortComplex r).X₂ = ↑M | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.Mathlib.Meta.Positivity.evalENNRealRpow.match_13 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | (α : Q(Type)) →
(x : Q(Zero «$α»)) →
(val : Q(PartialOrder «$α»)) →
(a : Q(«$α»)) →
(b : Q(ℝ)) →
(motive :
Mathlib.Meta.Positivity.Strictness q(inferInstance) a (some q(inferInstance)) →
Mathlib.Meta.Positivity.Strictness q(inferInstance) b (some q(inferInstan... | null | false |
Std.ExtDTreeMap.Const.maxKey_modify | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : β → β} {he : Std.ExtDTreeMap.Const.modify t k f ≠ ∅},
(Std.ExtDTreeMap.Const.modify t k f).maxKey he = if cmp (t.maxKey ⋯) k = Ordering.eq then k else t.maxKey ⋯ | null | true |
MulEquiv.withOneCongr_refl | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} [inst : Mul α], (MulEquiv.refl α).withOneCongr = MulEquiv.refl (WithOne α) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.