name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Mathlib.Tactic.Abel.AbelNF.Config.contextual._inherited_default | Mathlib.Tactic.Abel | Bool | null | false |
CategoryTheory.Comma.toPUnitIdEquiv_functor_iso | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A]
{L : CategoryTheory.Functor A (CategoryTheory.Discrete PUnit.{u_1 + 1})}
{R : CategoryTheory.Functor (CategoryTheory.Discrete PUnit.{u_2 + 1}) (CategoryTheory.Discrete PUnit.{u_1 + 1})},
(CategoryTheory.Comma.toPUnitIdEquiv L R).functor = CategoryTheory.... | null | true |
Std.DTreeMap.Internal.Impl.Const.size_filter!_le_size | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
{f : α → β → Bool}, t.WF → (Std.DTreeMap.Internal.Impl.filter! f t).size ≤ t.size | null | true |
mem_nonZeroDivisorsLeft_iff._simp_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] {x : M₀}, (x ∈ nonZeroDivisorsLeft M₀) = ∀ (y : M₀), x * y = 0 → y = 0 | null | false |
_private.Lean.Widget.UserWidget.0.Lean.Widget.getWidgets.match_1 | Lean.Widget.UserWidget | (motive : Option Lean.Elab.InfoTree → Sort u_1) →
(x : Option Lean.Elab.InfoTree) →
((infoTree : Lean.Elab.InfoTree) →
(cc : Lean.Elab.CommandContextInfo) →
(t : Lean.Elab.InfoTree) →
(h : infoTree = Lean.Elab.InfoTree.context (Lean.Elab.PartialContextInfo.commandCtx cc) t) →
... | null | false |
Submodule.IsCoideal.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Quotient | ∀ {R : Type u_1} {C : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup C] [inst_2 : Module R C]
[inst_3 : CoalgebraStruct R C] {I : Submodule R C},
(∀ ⦃x : C⦄, x ∈ I → CoalgebraStruct.counit x = 0) →
(∀ ⦃x : C⦄, x ∈ I → (TensorProduct.map I.mkQ I.mkQ) (CoalgebraStruct.comul x) = 0) → I.IsCoideal | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int.0.Int.reduceBinIntNatOp | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | Lean.Name → (ℤ → ℕ → ℤ) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep | null | true |
CategoryTheory.Comma.eqToHom_left | 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] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) (X Y : CategoryTheory.Comma L R) (H : X = Y),
(CategoryTheory.eqToHo... | null | true |
IsTopologicalAddGroup.rightUniformSpace._proof_3 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G],
∀ U ∈ nhds 0,
U ∈ Filter.map (fun p => p.2 + -p.1) ((Filter.comap (fun p => p.2 + -p.1) (nhds 0)).lift' fun s => SetRel.comp s s) | null | false |
div_le_div_iff' | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : CommGroup α] [inst_1 : LE α] [MulLeftMono α] {a b c d : α}, a / b ≤ c / d ↔ a * d ≤ c * b | See also `div_le_div_iff` for a version that works for `LinearOrderedSemifield` with
additional assumptions. | true |
LipschitzWith.norm_sub_le_of_le | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} {F : Type u_3} [inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] {f : E → F}
{C : NNReal} {a b : E} {r : ℝ}, LipschitzWith C f → ‖a - b‖ ≤ r → ‖f a - f b‖ ≤ ↑C * r | null | true |
Subgroup.periods.eq_1 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.periods = 𝒢.adjoinNegOne.strictPeriods | null | true |
Filter.tendsto_image_smallSets._simp_1 | Mathlib.Order.Filter.SmallSets | ∀ {α : Type u_1} {β : Type u_2} {la : Filter α} {lb : Filter β} {f : α → β},
Filter.Tendsto (fun x => f '' x) la.smallSets lb.smallSets = Filter.Tendsto f la lb | null | false |
_private.Mathlib.Algebra.Order.Star.Prod.0.Prod.instStarOrderedRing._simp_6 | Mathlib.Algebra.Order.Star.Prod | ∀ {a b c d : Prop}, ((a ∧ b) ∧ c ∧ d) = ((a ∧ c) ∧ b ∧ d) | null | false |
CategoryTheory.Limits.PreservesColimit₂.of_preservesColimit₂_flip | Mathlib.CategoryTheory.Limits.Preserves.Bifunctor | ∀ {J₁ : Type u_1} {J₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} J₂] {C₁ : Type u_3} {C₂ : Type u_4} {C : Type u_5}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₁] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₂]
[inst_4 : CategoryTheory.Category.{v_5,... | null | true |
CategoryTheory.conjugateEquiv_mateEquiv_vcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D}
{L₁ : Ca... | The mates equivalence commutes with this composition, essentially by `mateEquiv_vcomp`. | true |
Turing.ToPartrec.Cfg.halt.elim | Mathlib.Computability.TuringMachine.Config | {motive : Turing.ToPartrec.Cfg → Sort u} →
(t : Turing.ToPartrec.Cfg) → t.ctorIdx = 0 → ((a : List ℕ) → motive (Turing.ToPartrec.Cfg.halt a)) → motive t | null | false |
CategoryTheory.PreOneHypercover.toPullback_snd_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S) {i₁ i₂ : E.I₀}
[inst_1 : CategoryTheory.Limits.HasPullback (E.f i₁) (E.f i₂)] (k : E.I₁ i₁ i₂) {Z : C} (h : E.X i₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (E.toPullback k)
(CategoryTheory.CategoryStruct.c... | null | true |
SubfieldClass.toField._proof_7 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {S : Type u_2} {K : Type u_1} [inst : Field K] [inst_1 : SetLike S K] [inst_2 : SubfieldClass S K] (s : S), 0⁻¹ = 0 | null | false |
DFinsupp.instZero | Mathlib.Data.DFinsupp.Defs | {ι : Type u} → {β : ι → Type v} → [inst : (i : ι) → Zero (β i)] → Zero (Π₀ (i : ι), β i) | null | true |
Std.DTreeMap.Internal.Impl.minKey!_eq_getElem!_keysArray | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α], t.WF → t.minKey! = t.keysArray[0]! | null | true |
absorbs_iff_eventually_cobounded_mapsTo | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
{s t : Set α}, Absorbs G₀ s t ↔ ∀ᶠ (c : G₀) in Bornology.cobounded G₀, Set.MapsTo (fun x => c⁻¹ • x) t s | null | true |
Std.ExtDHashMap.getKey?.congr_simp | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtDHashMap α β), m = m_1 → ∀ (a a_1 : α), a = a_1 → m.getKey? a = m_1.getKey? a_1 | null | true |
FunLike.addRightCancelSemigroup.eq_1 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Add F]
[inst_2 : AddRightCancelSemigroup β] [inst_3 : IsAddApply F α β],
FunLike.addRightCancelSemigroup = Function.Injective.addRightCancelSemigroup (fun f => ⇑f) ⋯ ⋯ | null | true |
List.Matcher.find? | Batteries.Data.List.Matcher | {α : Type u_1} → [BEq α] → List.Matcher α → List α → Option (ℕ × ℕ) | Find the start and end positions of the first infix sublist of `l` matching `m.pattern`,
or `none` if there is no such sublist.
| true |
CategoryTheory.Regular.frobeniusStrongEpiMonoFactorisation._proof_3 | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Regular C] {A B : C} (f : A ⟶ B)
(A' : CategoryTheory.Subobject A) (B' : CategoryTheory.Subobject B),
CategoryTheory.StrongEpi (CategoryTheory.Regular.frobeniusMorphism f A' B') | null | false |
Lean.Lsp.LeanDeclIdent.mk.injEq | Lean.Data.Lsp.Internal | ∀ (module decl module_1 decl_1 : Lean.Name),
({ module := module, decl := decl } = { module := module_1, decl := decl_1 }) = (module = module_1 ∧ decl = decl_1) | null | true |
Monotone.iSup_comp_eq | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : CompleteLattice α] [inst_1 : Preorder β] {f : β → α},
Monotone f → ∀ {s : ι → β}, (∀ (x : β), ∃ i, x ≤ s i) → ⨆ x, f (s x) = ⨆ y, f y | null | true |
MonoidHom.compAddChar_apply | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddMonoid A] [inst_1 : Monoid M] [inst_2 : Monoid N] (f : M →* N)
(φ : AddChar A M), ⇑(f.compAddChar φ) = ⇑f ∘ ⇑φ | null | true |
instMonoidalClosedSheafOfHasSheafifyOfFunctorOpposite._proof_6 | Mathlib.CategoryTheory.Sites.CartesianClosed | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_4) [inst_1 : CategoryTheory.Category.{u_2, u_4} A]
(F : (CategoryTheory.sheafToPresheaf J A).EssImageSubcategory), CategoryTheory.Presheaf.IsSheaf J F.obj | null | false |
AddOpposite.instSemiring._proof_6 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : Semiring R] (a : Rᵃᵒᵖ), 0 * a = 0 | null | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.disjoint_union_right._simp_1_2 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
CategoryTheory.HasShift.mkShiftCoreOp._proof_6 | Mathlib.CategoryTheory.Shift.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] (A : Type u_3) [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (n : A) (X : Cᵒᵖ),
(CategoryTheory.shiftFunctor C (0 + n)).op.obj X =
(CategoryTheory.shiftFunctor C n).op.obj ((CategoryTheory.Functor.id Cᵒᵖ).obj X) | null | false |
ContinuousOn.cfcₙ' | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {X : Type u_1} {𝕜 : Type u_2} {A : Type u_3} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : StarRing A] [inst_3 : NormedSpace 𝕜 A] [inst_4 : IsScalarTower 𝕜 A A] [inst_5 : SMulCommClass 𝕜 A A]
[ContinuousStar A] [inst_7 : NonUnitalIsometricContinuousFunctionalCalculus 𝕜 A p] [in... | If `f : 𝕜 → 𝕜` is continuous on a compact set `s` and `f 0 = 0` and `a : X → A` is continuous
on `t : Set X`, and `a x` satisfies the predicate `p` associated to `𝕜` and has quasispectrum
contained in `s` for all `x ∈ t`, then `fun x ↦ cfcₙ f (a x)` is continuous on `t`. | true |
AddSubgroup.addCommutator_bot_left | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H₁ : AddSubgroup G), ⁅⊥, H₁⁆ = ⊥ | null | true |
instBooleanRingCarrierToBddLatToBddDistLatOfAsBoolAlg._aux_13 | Mathlib.Algebra.Category.BoolRing | {R : Type u_1} → [inst : BooleanRing R] → One ↑(↧(AsBoolAlg R)).toBddDistLat.toBddLat.toLat | null | false |
Finsupp.lmapDomain_linearCombination | Mathlib.LinearAlgebra.Finsupp.LinearCombination | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{α' : Type u_5} {M' : Type u_6} [inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {v : α → M} {v' : α' → M'}
(f : α → α') (g : M →ₗ[R] M'),
(∀ (i : α), g (v i) = v' (f i)) →
Finsupp.linearCombi... | null | true |
zpow_one_sub_natCast | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] (a : G) (n : ℕ), a ^ (1 - ↑n) = a / a ^ n | null | true |
CategoryTheory.Oplax.OplaxTrans.naturality_id_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (self : CategoryTheory.Oplax.OplaxTrans F G) (a : B) {Z : F.obj a ⟶ G.obj a}
(h : CategoryTheory.CategoryStruct.comp (self.app a) (CategoryTheory.CategoryStruct.id (G.obj... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_filterMap._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 |
EuclideanGeometry.oangle_rotate_sign | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
(p₁ p₂ p₃ : P), (EuclideanGeometry.oangle p₂ p₃ p₁).sign = (EuclideanGeometry.oangle p₁ ... | Rotating the points in an oriented angle does not change the sign of that angle. | true |
Set.graphOn_nonempty | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β}, (Set.graphOn f s).Nonempty ↔ s.Nonempty | null | true |
Std.HashMap.getElem!_diff_of_not_mem_right | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k : α} [inst : Inhabited β], k ∉ m₂ → (m₁ \ m₂)[k]! = m₁[k]! | null | true |
Real.normedField._proof_11 | Mathlib.Analysis.Normed.Field.Basic | ∀ (n : ℕ) (a : ℝ), Int.negSucc n • a = -(↑n.succ • a) | null | false |
HomologicalComplex.instEpiFπTruncGE | Mathlib.Algebra.Homology.Embedding.TruncGE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c') (e : c.Embedding c') [inst_2 : e.IsTruncGE] [inst_3 : ∀ (i' : ι'), K.HasHomology i']
[inst_4 :... | null | true |
GradedRingHom.copy | Mathlib.RingTheory.GradedAlgebra.RingHom | {ι : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_6} →
{τ : Type u_7} →
[inst : Semiring A] →
[inst_1 : Semiring B] →
[inst_2 : SetLike σ A] →
[inst_3 : SetLike τ B] → {𝒜 : ι → σ} → {ℬ : ι → τ} → (f : 𝒜 →+*ᵍ ℬ) → (f' : A → B) → f' = ... | Copy of a `GradedRingHom` with a new `toFun` equal to the old one. Useful to fix definitional
equalities. | true |
Std.Async.TCP.Socket.Server._sizeOf_inst | Std.Async.TCP | SizeOf Std.Async.TCP.Socket.Server | null | false |
TannakaDuality.FiniteGroup.instMonoidalFDRepFGModuleCatForget₂HomSubtypeLinearMapIdCarrierObjModuleCatIsFGV._proof_10 | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (X : Action (FGModuleCat k) G),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor ((Action.forget (FGModuleCat k) G).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((Action.forget (FGModuleCat k) ... | null | false |
IO.FS.SystemTime.mk.sizeOf_spec | Init.System.IO | ∀ (sec : ℤ) (nsec : UInt32), sizeOf { sec := sec, nsec := nsec } = 1 + sizeOf sec + sizeOf nsec | null | true |
CategoryTheory.Limits.biproduct.ι_fromSubtype_assoc | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) [inst_2 : CategoryTheory.Limits.HasBiproduct f]
(p : J → Prop) [inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict p f)] (j : Subtype p) {Z : C}
(h : ⨁ f ⟶ Z),
Categor... | null | true |
Monoid.CoprodI.Word.smul_eq_of_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] {i : ι} (m : M i) (w : Monoid.CoprodI.Word M), m • w = Monoid.CoprodI.of m • w | null | true |
Batteries.AssocList.toList_modify | Batteries.Data.AssocList.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → β} [inst : BEq α] (a : α) (l : Batteries.AssocList α β),
(Batteries.AssocList.modify a f l).toList =
List.replaceF
(fun x =>
match x with
| (k, v) => bif k == a then some (a, f k v) else none)
l.toList | null | true |
CategoryTheory.Injective.instOfNonempty | Mathlib.CategoryTheory.Preadditive.Injective.Basic | ∀ (X : Type u₁) [Nonempty X], CategoryTheory.Injective X | The axiom of choice says that every nonempty type is an injective object in `Type`. | true |
SMulCommClass.recOn | Mathlib.Algebra.Group.Action.Defs | {M : Type u_9} →
{N : Type u_10} →
{α : Type u_11} →
[inst : SMul M α] →
[inst_1 : SMul N α] →
{motive : SMulCommClass M N α → Sort u} →
(t : SMulCommClass M N α) →
((smul_comm : ∀ (m : M) (n : N) (a : α), m • n • a = n • m • a) → motive ⋯) → motive t | null | false |
Submonoid.map_bot | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F), Submonoid.map f ⊥ = ⊥ | null | true |
OrderIso.map_atTop | Mathlib.Order.Filter.AtTopBot.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β),
Filter.map (⇑e) Filter.atTop = Filter.atTop | null | true |
Polynomial.squarefree_cyclotomic | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_2) [inst : Field K] [NeZero ↑n], Squarefree (Polynomial.cyclotomic n K) | null | true |
StalkSkyscraperPresheafAdjunctionAuxs.toSkyscraperPresheaf._proof_1 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasColimits C] {𝓕 : TopCat.Presheaf C X} {c : C} (f : 𝓕.stalk p₀ ⟶ c)
(U V : (Topol... | null | false |
skyscraperPresheafCocone | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
(A : C) →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
(y : ↑X) →
CategoryTheory.Limits.Coco... | The cocone at `*` for the stalk functor of `skyscraperPresheaf p₀ A` when `y ∉ closure {p₀}`
| true |
GradedTensorProduct.instRing._proof_18 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_3} {ι : Type u_4} {A : Type u_1} {B : Type u_2} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
Fin.addNat_inj | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (m : ℕ) {i j : Fin n}, i.addNat m = j.addNat m ↔ i = j | null | true |
SchwartzMap.instUniformSpace._proof_2 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F],
((Filter.comap (fun p => p.2 + -p.1) (nhds 0)).lift' fun s => SetRel.comp s s) ≤
Filter.comap (fun p => p.2 + -p.1) (nhds 0) | null | false |
Lean.Elab.Term.ElabElim.State.noConfusion | Lean.Elab.App | {P : Sort u} → {t t' : Lean.Elab.Term.ElabElim.State} → t = t' → Lean.Elab.Term.ElabElim.State.noConfusionType P t t' | null | false |
Lean.Elab.Command.CoinductiveElabData.declId | Lean.Elab.Coinductive | Lean.Elab.Command.CoinductiveElabData → Lean.Syntax | Declaration Id from the original `InductiveView` | true |
Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (x : Lean.Grind.AC.Var) (c₁ : Lean.Meta.Grind.AC.EqCnstr) (x_1 : Lean.Grind.AC.Var)
(c₁_1 : Lean.Meta.Grind.AC.EqCnstr),
(Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent x c₁ =
Lean.Meta.Grind.AC.EqCnstrProof.superpose_tail_idempotent x_1 c₁_1) =
(x = x_1 ∧ c₁ = c₁_1) | null | true |
IsUltrametricDist.nonarchimedeanAddGroup | Mathlib.Analysis.Normed.Group.Ultra | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] [IsUltrametricDist M], NonarchimedeanAddGroup M | A commutative additive group with an ultrametric group seminorm is nonarchimedean
(as a topological group, i.e. every neighborhood of 0 contains an open subgroup). | true |
Polynomial.natDegree_map_eq_of_isUnit_leadingCoeff | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {S : Type v} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] [Nontrivial S] (f : R →+* S),
IsUnit p.leadingCoeff → (Polynomial.map f p).natDegree = p.natDegree | null | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorLoop.loopWf_eq._unary | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α] {n : Type u → Type w}
[inst_5 : Monad n] [LawfulMonad n] (γ : Type u) {lift : (γ δ : Type u) → (γ → n δ) → Id γ → n δ}
[ins... | null | false |
_private.Mathlib.Tactic.Inclusion.ExtensionAPI.Basic.0.Inclusion.mkHypExprInclusionBody.match_1 | Mathlib.Tactic.Inclusion.ExtensionAPI.Basic | (motive : Inclusion.ExprInclusionBody × Inclusion.InclusionM.State → Sort u_1) →
(x : Inclusion.ExprInclusionBody × Inclusion.InclusionM.State) →
((body : Inclusion.ExprInclusionBody) →
(inclusionState : Inclusion.InclusionM.State) → motive (body, inclusionState)) →
motive x | null | false |
CategoryTheory.Functor.addMonObjObj._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] (X : C) [inst_5 : CategoryTheory.AddMonObj... | null | false |
SSet.RelativeMorphism.precomp_homotopyClass | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y Z : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet} {C : Z.Subcomplex}
{ψ : B.toSSet ⟶ C.toSSet} (f : SSet.RelativeMorphism A B φ) (f' : SSet.RelativeMorphism B C ψ)
{φψ : A.toSSet ⟶ C.toSSet} (fac : CategoryTheory.CategoryStruct.comp φ ψ = φψ),
f'.homotopyClass.precomp f fac = (f.com... | null | true |
Ideal.inertiaDeg_le_inertiaDeg | Mathlib.NumberTheory.RamificationInertia.Inertia | ∀ {R : Type u} [inst : CommRing R] {S : Type v} [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R) (P : Ideal S)
{T : Type u_2} [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [IsScalarTower R S T]
[Module.Finite R T] (Q : Ideal T) [P.LiesOver p] [Q.LiesOver P] [p.IsPrime], P.inertiaDeg'... | **Alias** of `Ideal.inertiaDeg'_le_inertiaDeg'`. | true |
Topology.IsInducing.continuousVAdd | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X]
[inst_2 : TopologicalSpace Y] [inst_3 : VAdd M X] [ContinuousVAdd M X] {g : Y → X} {N : Type u_5} [inst_5 : VAdd N Y]
[inst_6 : TopologicalSpace N] {f : N → M},
Topology.IsInducing g → Continuous f → (∀ {c : N... | Suppose that `N` additively acts on `X` and `M` continuously additively acts on `Y`.
Suppose that `g : Y → X` is an additive action homomorphism in the following sense:
there exists a continuous function `f : N → M` such that `g (c +ᵥ x) = f c +ᵥ g x`.
Then the action of `N` on `X` is continuous as well.
In many cases... | true |
_private.Lean.Language.Basic.0.Lean.Language.Snapshot.Diagnostics.mk.noConfusion | Lean.Language.Basic | {P : Sort u} →
{msgLog : Lean.MessageLog} →
{interactiveDiagsRef? : Option (IO.Ref (Option Dynamic))} →
{msgLog' : Lean.MessageLog} →
{interactiveDiagsRef?' : Option (IO.Ref (Option Dynamic))} →
{ msgLog := msgLog, interactiveDiagsRef? := interactiveDiagsRef? } =
{ msgLog := ... | null | false |
Array.iter_equiv_iter_toList | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {α : Type w} {array : Array α}, array.iter.Equiv array.toList.iter | null | true |
IsRetrocompact.univ | Mathlib.Topology.Constructible | ∀ {X : Type u_2} [inst : TopologicalSpace X], IsRetrocompact Set.univ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.keys_filter._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
Std.DHashMap.Internal.Raw₀.getD_eq_getDₘ | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] [inst_2 : Hashable α]
(m : Std.DHashMap.Internal.Raw₀ α β) (a : α) (fallback : β a), m.getD a fallback = m.getDₘ a fallback | null | true |
ArithmeticFunction.arith_mult? | Mathlib.Tactic.ArithMult | Lean.ParserDescr | `arith_mult` solves goals of the form `IsMultiplicative f` for `f : ArithmeticFunction R`
by applying lemmas tagged with the user attribute `arith_mult`, and prints out the generated
proof term. | true |
_private.Mathlib.Geometry.Manifold.Notation.0.initFn._@.Mathlib.Geometry.Manifold.Notation.974079890._hygCtx._hyg.2 | Mathlib.Geometry.Manifold.Notation | IO Unit | Trace class for the `MDiff` elaborator and friends, which infer a model with corners on the domain
(resp. codomain) of the map in question.
| false |
PresheafOfModules.instAddCommGroupHom._proof_7 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (a : M₁ ⟶ M₂), 0 • a = 0 | null | false |
String.Slice.Pattern.Model.IsLongestMatchAtChain.sliceTo | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {startPos endPos : s.Pos}
(h : String.Slice.Pattern.Model.IsLongestMatchAtChain pat startPos endPos) (p : s.Pos) (hp : endPos ≤ p),
String.Slice.Pattern.Model.IsLongestMatchAtChain pat (p.sliceTo startPos ⋯) (p.sliceTo en... | null | true |
MeasurableSet.Subtype.instCompl | Mathlib.MeasureTheory.MeasurableSpace.MeasurablyGenerated | {α : Type u_1} → [inst : MeasurableSpace α] → Compl (Subtype MeasurableSet) | null | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.compileToSimpleGroundExpr.compileNonFinalLet._sparseCasesOn_2 | Lean.Compiler.LCNF.SimpleGroundExpr | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
MeasureTheory.SimpleFunc.instAddMonoid | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} → {β : Type u_2} → [inst : MeasurableSpace α] → [AddMonoid β] → AddMonoid (MeasureTheory.SimpleFunc α β) | null | true |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_map_τ₁ | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)} (φ : X ⟶ Y),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J... | null | true |
Std.ExtDHashMap.isEmpty_union | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ ∪ m₂).isEmpty = (m₁.isEmpty && m₂.isEmpty) | null | true |
_private.Init.Data.Array.Nat.0.Array.sum_pos_iff_exists_pos_nat._simp_1_2 | Init.Data.Array.Nat | ∀ {l : List ℕ}, (0 < l.sum) = ∃ x ∈ l, 0 < x | null | false |
Sym2.gameAdd_mk'_iff | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {rα : α → α → Prop} {a₁ a₂ b₁ b₂ : α},
Sym2.GameAdd rα s(a₁, b₁) s(a₂, b₂) ↔ Prod.GameAdd rα rα (a₁, b₁) (a₂, b₂) ∨ Prod.GameAdd rα rα (b₁, a₁) (a₂, b₂) | null | true |
Simps.findProjection | Mathlib.Tactic.Simps.Basic | Lean.Name → Simps.ParsedProjectionData → List Lean.Level → Lean.CoreM Simps.ParsedProjectionData | Auxiliary function for `getRawProjections`.
Generates the default projection, and looks for a custom projection declared by the user,
and replaces the default projection with the custom one, if it can find it. | true |
CategoryTheory.Equivalence.pow_neg_one | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (e : C ≌ C), e ^ (-1) = e.symm | null | true |
Lean.Elab.Tactic.Grind.ExtraTheorem.fvar.elim | Lean.Elab.Tactic.Grind.Basic | {motive : Lean.Elab.Tactic.Grind.ExtraTheorem → Sort u} →
(t : Lean.Elab.Tactic.Grind.ExtraTheorem) →
t.ctorIdx = 1 → ((fvarId : Lean.FVarId) → motive (Lean.Elab.Tactic.Grind.ExtraTheorem.fvar fvarId)) → motive t | null | false |
FunLike.addAction._proof_1 | Mathlib.Algebra.Module.FunLike | ∀ {M : Type u_4} {F : Type u_3} {α : Type u_1} {β : Type u_2} [i : FunLike F α β] [inst : VAdd M F]
[inst_1 : AddMonoid M] [inst_2 : AddAction M β] [IsVAddApply M F α β] (n : M) (f : F), ⇑(n +ᵥ f) = n +ᵥ ⇑f | null | false |
Sym2.attachWith | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → {P : α → Prop} → (s : Sym2 α) → (∀ a ∈ s, P a) → Sym2 { a // P a } | "Attach" a proof `P a` that holds for all the elements of `s` to produce a new Sym2 object
with the same elements but in the type `{x // P x}`.
| true |
HomotopicalAlgebra.Precylinder.LeftHomotopy.trans._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {P : HomotopicalAlgebra.Precylinder X} {Y : C}
{f₀ f₁ f₂ : X ⟶ Y} (h : P.LeftHomotopy f₀ f₁) {P' : HomotopicalAlgebra.Precylinder X} (h' : P'.LeftHomotopy f₁ f₂),
CategoryTheory.CategoryStruct.comp P.i₁ h.h = CategoryTheory.CategoryStruct.comp P... | null | false |
CategoryTheory.GrothendieckTopology.Point.Hom.presheafFiber_comp | Mathlib.CategoryTheory.Sites.Point.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] [inst_2 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, v', u'} A]
{Φ₁ Φ₂ Φ₃ : J.Point} (f : Φ₁ ⟶ Φ₂) (g : Φ₂ ⟶ Φ₃),
CategoryTheory.GrothendieckTopology... | null | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.casesOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_8 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
((p : Int.Internal.Linear.Poly) → (h : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) → motive_8 { p := p, h := h }) →
motive_8 t | null | false |
OrderDual.instGroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [Group α] → Group αᵒᵈ | null | true |
AList.mem_lookup_union_middle | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {b : β a} {s₁ s₂ s₃ : AList β},
b ∈ AList.lookup a (s₁ ∪ s₃) → a ∉ s₂ → b ∈ AList.lookup a (s₁ ∪ s₂ ∪ s₃) | null | true |
IsPrimitiveRoot.exists_pow_eq_pow_two_mul | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M},
IsPrimitiveRoot ζ k → Odd k → ∀ (n : ℕ), ∃ m, ζ ^ n = ζ ^ (2 * m) | If `ζ` is a primitive `k`-th root of unity with `k` odd, then every power of `ζ` is an even
power of `ζ`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.