name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.FileChangeType.noConfusionType | Lean.Data.Lsp.Workspace | Sort v✝ → Lean.Lsp.FileChangeType → Lean.Lsp.FileChangeType → Sort v✝ | null | true |
_private.Mathlib.Order.CountableSupClosed.0.countableInfClosure._proof_3 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_1} (s : Set α), ∀ x ∈ s, {x} ⊆ s | null | false |
ULift.isAddLeftRegular_down._simp_1 | Mathlib.Algebra.Regular.ULift | ∀ {R : Type v} [inst : Add R] {a : ULift.{u, v} R}, IsAddLeftRegular a.down = IsAddLeftRegular a | null | false |
AlgebraicGeometry.stalkClosedPointIso_inv | Mathlib.AlgebraicGeometry.Stalk | ∀ (R : CommRingCat) [inst : IsLocalRing ↑R],
(AlgebraicGeometry.stalkClosedPointIso R).inv =
AlgebraicGeometry.StructureSheaf.toStalk (↑R) (IsLocalRing.closedPoint ↑R) | null | true |
OrderMonoidIso.cancel_left | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : Mul α] [inst_4 : Mul β] [inst_5 : Mul γ] {g : α ≃*o β} {f₁ f₂ : β ≃*o γ},
Function.Surjective ⇑g → (g.trans f₁ = g.trans f₂ ↔ f₁ = f₂) | null | true |
RootPairingCat.ctorIdx | Mathlib.LinearAlgebra.RootSystem.RootPairingCat | {R : Type u} → {inst : CommRing R} → RootPairingCat R → ℕ | null | false |
Lean.Meta.Sym.Arith.Semiring.mulFn? | Lean.Meta.Sym.Arith.Types | Lean.Meta.Sym.Arith.Semiring → Option Lean.Expr | null | true |
LightCondMod.LocallyConstant.instFaithfulModuleCatSheafLightProfiniteCoherentTopologyConstantSheaf | Mathlib.Condensed.Discrete.Module | ∀ (R : Type u) [inst : Ring R],
(CategoryTheory.constantSheaf (CategoryTheory.coherentTopology LightProfinite) (ModuleCat R)).Faithful | null | true |
BoundedLatticeHomClass.toBoundedOrderHomClass | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : Lattice α] [inst_2 : Lattice β]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [BoundedLatticeHomClass F α β], BoundedOrderHomClass F α β | null | true |
ContMDiffMap.commGroup._proof_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E' : Type u_3} [inst_1 : NormedAddCommGroup E']
[inst_2 : NormedSpace 𝕜 E'] {H' : Type u_2} [inst_3 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{n : WithTop ℕ∞} {G : Type u_4} [inst_4 : CommGroup G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSp... | null | false |
Std.Sat.AIG.RelabelNat.State.Inv1.lt_of_get?_eq_some | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] [EquivBEq α] {n m : ℕ} (map : Std.HashMap α ℕ) (x : α),
Std.Sat.AIG.RelabelNat.State.Inv1 n map → map[x]? = some m → m < n | null | true |
UniformSpaceCat.noConfusionType | Mathlib.Topology.Category.UniformSpace | Sort u_1 → UniformSpaceCat → UniformSpaceCat → Sort u_1 | null | false |
String.Pos.Raw.extract.go₂._f | Init.Data.String.Basic | (a : List Char) →
List.below (motive := fun a => String.Pos.Raw → String.Pos.Raw → List Char) a →
String.Pos.Raw → String.Pos.Raw → List Char | null | false |
CategoryTheory.MorphismProperty.prop_single | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.MorphismProperty.single f f | null | true |
Int.toNat_lt | Init.Data.Int.Order | ∀ {n : ℕ} {z : ℤ}, 0 ≤ z → (z.toNat < n ↔ z < ↑n) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal.0.SSet.Truncated.StrictSegal.spineToDiagonal._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ} (m : ℕ), ¬1 ≤ n + 1 → False | null | false |
Lean.Meta.GeneralizeArg.casesOn | Lean.Meta.Tactic.Generalize | {motive : Lean.Meta.GeneralizeArg → Sort u} →
(t : Lean.Meta.GeneralizeArg) →
((expr : Lean.Expr) →
(xName? hName? : Option Lean.Name) → motive { expr := expr, xName? := xName?, hName? := hName? }) →
motive t | null | false |
lp.nonUnitalNormedRing._proof_3 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {I : Type u_1} {B : I → Type u_2} [inst : (i : I) → NonUnitalNormedRing (B i)] (f g : ↥(lp B ⊤)), ‖f * g‖ ≤ ‖f‖ * ‖g‖ | null | false |
Prod.instSemiring._proof_2 | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (a : R × S), 1 * a = a | null | false |
FP.FloatCfg.emax | Mathlib.Data.FP.Basic | [self : FP.FloatCfg] → ℕ | null | true |
Prod.instAddMonoid._proof_3 | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : AddMonoid N] (a b c : M × N), a + b + c = a + (b + c) | null | false |
Mathlib.Tactic.Ring.ExceptType.tooSmall | Mathlib.Tactic.Ring.Compare | Mathlib.Tactic.Ring.ExceptType | null | true |
CategoryTheory.Bicategory.whiskerLeft_hom_inv_whiskerRight | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ≅ h) (k : c ⟶ d),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight η.hom k))
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicate... | null | true |
oneLePart_of_le_one | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : DivInvMonoid α] {a : α}, a ≤ 1 → a⁺ᵐ = 1 | **Alias** of the reverse direction of `oneLePart_eq_one`. | true |
ENNReal.coe_rpow_of_nonneg._simp_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (x : NNReal) {y : ℝ}, 0 ≤ y → ↑x ^ y = ↑(x ^ y) | null | false |
WeierstrassCurve.Jacobian.Point.neg_def | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (P : W.Point), -P = P.neg | null | true |
Lean.Meta.Context.noConfusion | Lean.Meta.Basic | {P : Sort u} → {t t' : Lean.Meta.Context} → t = t' → Lean.Meta.Context.noConfusionType P t t' | null | false |
NonUnitalSubalgebra.toNonUnitalStarSubalgebra | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Star A] → (s : NonUnitalSubalgebra R A) → (∀ x ∈ s, star x ∈ s) → NonUnitalStarSubalgebra R A | A non-unital subalgebra closed under `star` is a non-unital star subalgebra. | true |
_private.Mathlib.Combinatorics.Hypergraph.Basic.0.Hypergraph.eq_bot_or_isNonempty._proof_1_1 | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_1} (H : Hypergraph α), H.vertexSet = ∅ ∧ H.edgeSet = ∅ ∨ H.vertexSet.Nonempty ∨ H.edgeSet.Nonempty | null | false |
CategoryTheory.ObjectProperty.createsKernels._proof_2 | Mathlib.CategoryTheory.ObjectProperty.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P : CategoryTheory.ObjectProperty C) [P.IsClosedUnderKernels] {X Y : P.FullSubcategory} (f : X ⟶ Y)
[inst_3 : CategoryTheory.Limits.HasKernel f.hom], P (CategoryTheory.Limits.kernel f.hom) | null | false |
ContMDiff.inv | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : 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] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{G : Type u_4} [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] {E'... | null | true |
Mathlib.Tactic.ClickSuggestions.Premise.toString | Mathlib.Tactic.ClickSuggestions.Util | Mathlib.Tactic.ClickSuggestions.Premise → String | Print a premise as a string. | true |
OrderDual.instRightCancelMonoid | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [RightCancelMonoid α] → RightCancelMonoid αᵒᵈ | null | true |
ProofWidgets.HtmlDisplayProps.casesOn | ProofWidgets.Component.HtmlDisplay | {motive : ProofWidgets.HtmlDisplayProps → Sort u} →
(t : ProofWidgets.HtmlDisplayProps) → ((html : ProofWidgets.Html) → motive { html := html }) → motive t | null | false |
_private.Lean.Data.PersistentArray.0.Lean.PersistentArray.forIn.match_1 | Lean.Data.PersistentArray | {β : Type u_1} →
(motive : ForInStep β → Sort u_2) →
(__do_lift : ForInStep β) →
((r : β) → motive (ForInStep.done r)) → ((bNew : β) → motive (ForInStep.yield bNew)) → motive __do_lift | null | false |
Lean.Elab.Term.Do.ToTerm.breakToTerm | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.M Lean.Syntax | null | true |
IsAlgClosure.equivOfEquivAux._proof_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {R : Type u_3} {S : Type u_2} (L : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Field L]
[inst_3 : Algebra S L] (hSR : S ≃+* R) (x : S), (algebraMap S L) x = (algebraMap R L) ((algebraMap S R) x) | null | false |
ContinuousMap.evalAlgHom._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {X : Type u_2} (R : Type u_1) [inst : TopologicalSpace X] [inst_1 : CommSemiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] (x : X), 1 x = 1 x | null | false |
CategoryTheory.MonObj.instIsMonHomLift | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N O : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] [inst_4 : CategoryTheory.MonObj O]
[inst_5 : CategoryTheory.BraidedCategory C] {f : M ⟶ N} {g : M ⟶ O} [CategoryTheory.... | null | true |
isBinaryCoproductOfIsInitialIsPushout | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C) →
(c : CategoryTheory.Limits.Cocone F) →
{X : C} →
(hX : CategoryTheory.Limits.IsInitial X) →
(f : X ⟶ F.obj { as := CategoryThe... | If a cospan is the pushout cospan under the initial object, then it is a binary coproduct. | true |
ofAdd_toAdd | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u} (x : Multiplicative α), Multiplicative.ofAdd (Multiplicative.toAdd x) = x | null | true |
_private.Mathlib.Data.ZMod.ValMinAbs.0.ZMod.valMinAbs_zero._simp_1_3 | Mathlib.Data.ZMod.ValMinAbs | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Zero α] [IsBotZeroClass α] {a : α}, (0 ≤ a) = True | null | false |
Homeomorph.finTwoArrow._proof_1 | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous (Homeomorph.piFinTwo fun x => X).toFun | null | false |
Fin.eq_true_of_findRev?_eq_some | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {i : Fin n} {p : Fin n → Bool}, Fin.findRev? p = some i → p i = true | null | true |
Pi.natCast_def._simp_1 | Mathlib.Data.Nat.Cast.Pi | ∀ {ι : Type u_1} {π : ι → Type u_2} [inst : (i : ι) → NatCast (π i)] (n : ℕ), (fun x => ↑n) = ↑n | null | false |
Bool.completeLinearOrder._proof_5 | Mathlib.Data.Fintype.Order | ∀ (a : Bool), a ⇨ ⊥ = aᶜ | null | false |
Path.map_coe | Mathlib.Topology.Path | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {x y : X} (γ : Path x y)
{f : X → Y} (h : Continuous f), ⇑(γ.map h) = f ∘ ⇑γ | null | true |
Equiv.Perm.subgroupOfMulAction._proof_1 | Mathlib.GroupTheory.Perm.Subgroup | ∀ (G : Type u_1) (H : Type u_2) [inst : Group G] [inst_1 : MulAction G H] [FaithfulSMul G H],
Function.HasLeftInverse MulAction.toPerm | null | false |
UniqueFactorizationMonoid.prime_of_factor | Mathlib.RingTheory.UniqueFactorizationDomain.Defs | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] {a : α},
∀ x ∈ UniqueFactorizationMonoid.factors a, Prime x | null | true |
Finset.truncatedSup_union_right | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeSup α] {s t : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : OrderTop α]
[inst_3 : DecidableEq α], a ∉ lowerClosure ↑s → a ∈ lowerClosure ↑t → (s ∪ t).truncatedSup a = t.truncatedSup a | null | true |
Set.Nonempty.inl | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s.Nonempty → (s ∪ t).Nonempty | null | true |
_private.Init.Data.List.Nat.Basic.0.List.getElem_eq_getElem_reverse._proof_1_1 | Init.Data.List.Nat.Basic | ∀ {α : Type u_1} {l : List α} {i : ℕ}, i < l.length → ¬i = l.length - 1 - (l.length - 1 - i) → False | null | false |
MulAction.orbitEquivQuotientStabilizer.match_1 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ (G : Type u_2) {X : Type u_1} [inst : Group G] [inst_1 : MulAction G X] (b : X)
(motive : ↑(MulAction.orbit G b) → Prop) (x : ↑(MulAction.orbit G b)),
(∀ (val : X) (g : G) (hgb : (fun m => m • b) g = val), motive ⟨val, ⋯⟩) → motive x | null | false |
CategoryTheory.RepresentablyCoflat | Mathlib.CategoryTheory.Functor.Flat | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` is representably coflat if the comma category `(F/X)` is filtered for
each `X : D`. | true |
CategoryTheory.ObjectProperty.instIsClosedUnderLimitsOfShapeOppositeOpOfIsClosedUnderColimitsOfShape_1 | 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] [P.IsClosedUnderColimitsOfShape Jᵒᵖ], P.op.IsClosedUnderLimitsOfShape J | null | true |
Std.Async.System.CPUInfo.casesOn | Std.Async.System | {motive : Std.Async.System.CPUInfo → Sort u} →
(t : Std.Async.System.CPUInfo) →
((model : String) →
(speed : ℕ) → (times : Std.Async.System.CPUTimes) → motive { model := model, speed := speed, times := times }) →
motive t | null | false |
Fin.finsetImage_succ_Ico | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (i j : Fin n), Finset.image Fin.succ (Finset.Ico i j) = Finset.Ico i.succ j.succ | null | true |
Subgroup.instDistribMulActionSubtypeMem._proof_1 | Mathlib.Algebra.Group.Subgroup.Actions | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : AddMonoid α] [inst_2 : DistribMulAction G α] (S : Subgroup G)
(r : ↥S.toSubmonoid), ↑r • 0 = 0 | null | false |
LightProfinite.instCountableDiscreteQuotient | Mathlib.Topology.Category.LightProfinite.Basic | ∀ (S : LightProfinite), Countable (DiscreteQuotient ↑(lightToProfinite.obj S).toTop) | null | true |
CategoryTheory.OplaxFunctor.mapComp'.congr_simp | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.OplaxFunctor B C) {b₀ b₁ b₂ : B} (f : b₀ ⟶ b₁) (g : b₁ ⟶ b₂) (fg : b₀ ⟶ b₂)
(h : CategoryTheory.CategoryStruct.comp f g = fg), F.mapComp' f g fg h = F.mapComp' f g fg h | null | true |
BooleanSubalgebra.instBotCoe | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} → [inst : BooleanAlgebra α] → {L : BooleanSubalgebra α} → Bot ↥L | A Boolean subalgebra of a lattice inherits a bottom element. | true |
FreeNonUnitalNonAssocAlgebra.of_comp_lift | Mathlib.Algebra.FreeNonUnitalNonAssocAlgebra | ∀ (R : Type u_1) {X : Type u_2} {A : Type u_3} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (f : X → A),
⇑((FreeNonUnitalNonAssocAlgebra.lift R) f) ∘ FreeNonUnitalNonAssocAlgebra.of R = f | null | true |
Std.Do.SVal.GetTy.mk | Std.Do.SPred.SVal | {σ : Type u} → {σs : List (Type u)} → Std.Do.SVal σs σ → Std.Do.SVal.GetTy σ σs | null | true |
CategoryTheory.ShortComplex.HomologyData.ofIsLimitKernelFork_right | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (c : CategoryTheory.Limits.KernelFork S.g)
(hc : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.ShortComplex.HomologyData.ofIsLimitKernelFork S hf c hc... | null | true |
CategoryTheory.Functor.CommShift₂.mk | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] →
[inst_2 : CategoryTheory.Category.{v_5, u_5} D] →
{M : Type u_6} →
[inst_3 : AddCommMonoid M] →
... | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.processPrevious._sparseCasesOn_1 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.... | null | false |
HomologicalComplex.HomologySequence.composableArrows₂.eq_1 | Mathlib.Algebra.Homology.HomologySequenceLemmas | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} (S : CategoryTheory.ShortComplex (HomologicalComplex C c)) (i : ι),
HomologicalComplex.HomologySequence.composableArrows₂ S i =
CategoryTheory.ComposableArrows.mk₂ (HomologicalC... | null | true |
Ordinal.veblen_eq_self_of_le | Mathlib.SetTheory.Ordinal.Veblen | ∀ {o₁ o₂ a : Ordinal.{u}}, o₁ ≤ o₂ → Ordinal.veblen o₂ a = a → Ordinal.veblen o₁ a = a | null | true |
HomologicalComplex.singleObjCyclesSelfIso_hom_naturality_assoc | Mathlib.Algebra.Homology.SingleHomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι) (j : ι)
{A B : C} (f : A ⟶ B) {Z : C} (h : B ⟶ Z),
CategoryTheory.CategoryStruct.comp (Homologi... | null | true |
not_exists_mem | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {p : α → Prop} {P : (x : α) → p x → Prop}, (¬∃ x, ∃ (h : p x), P x h) ↔ ∀ (x : α) (h : p x), ¬P x h | null | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnSeries.instIsCancelMulZeroOfIsCancelAdd._simp_3 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
Module.Basis.norm_isNonarchimedean | Mathlib.Analysis.Normed.Unbundled.FiniteExtension | ∀ {K : Type u_1} {L : Type u_2} [inst : NormedField K] [inst_1 : Ring L] [inst_2 : Algebra K L] {ι : Type u_3}
[inst_3 : Fintype ι] [inst_4 : Nonempty ι] {B : Module.Basis ι K L}, IsNonarchimedean norm → IsNonarchimedean B.norm | For any `K`-basis of `L`, if the norm on `K` is nonarchimedean, then so is `B.norm`. | true |
Std.DTreeMap.Internal.Const.RioSliceData.mk.inj | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : Type v} {inst : Ord α} {treeMap : Std.DTreeMap.Internal.Impl α fun x => β} {range : Std.Rio α}
{treeMap_1 : Std.DTreeMap.Internal.Impl α fun x => β} {range_1 : Std.Rio α},
{ treeMap := treeMap, range := range } = { treeMap := treeMap_1, range := range_1 } →
treeMap = treeMap_1 ∧ range = rang... | null | true |
Std.HashSet.Raw.isEmpty_inter_comm | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → (m₁ ∩ m₂).isEmpty = (m₂ ∩ m₁).isEmpty | null | true |
LinearIndepOn.subset_extend | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{v : ι → V} {s t : Set ι} (hs : LinearIndepOn K v s) (hst : s ⊆ t), s ⊆ hs.extend hst | null | true |
Vector.mul_smul | Init.Data.Vector.Algebra | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {d : α} [inst : Mul α] [inst_1 : SMul α β],
(∀ (c d : α) (x : β), (c * d) • x = c • d • x) → ∀ (c : α) (xs : Vector β n), (c * d) • xs = c • d • xs | null | true |
PolynomialLaw.π.match_1 | Mathlib.RingTheory.PolynomialLaw.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(M : Type u_3) →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
(S : Type u_2) →
(motive : PolynomialLaw.lifts R M S → Sort u_4) →
(x : PolynomialLaw.lifts R M S) →
((s : Finset S) → (p : TensorProdu... | null | false |
Finset.forall_mem_insertNone | Mathlib.Data.Finset.Option | ∀ {α : Type u_1} {s : Finset α} {p : Option α → Prop}, (∀ a ∈ Finset.insertNone s, p a) ↔ p none ∧ ∀ a ∈ s, p (some a) | null | true |
toZ_iterate_pred_of_not_isMin | Mathlib.Order.SuccPred.LinearLocallyFinite | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : IsSuccArchimedean ι] [inst_3 : PredOrder ι]
{i0 : ι} (n : ℕ), ¬IsMin (Order.pred^[n] i0) → toZ i0 (Order.pred^[n] i0) = -↑n | null | true |
CategoryTheory.Limits.Cocone.precomposeEquivalence._proof_8 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F G : CategoryTheory.Functor J C} (α : F ≅ G)
{X Y : CategoryTheory.Limits.Cocone G} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Cocone.ext
(Cat... | null | false |
tateComplexFunctor | Mathlib.RepresentationTheory.Homological.TateCohomology.Basic | (R G : Type u) →
[inst : CommRing R] →
[inst_1 : Group G] → [Fintype G] → CategoryTheory.Functor (Rep.{u, u, u} R G) (CochainComplex (ModuleCat R) ℤ) | The functor taking a representation of `G` to its Tate complex. | true |
Lean.Lsp.PrepareRenameParams._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.PrepareRenameParams | null | false |
Mathlib.Tactic.ComputeDegree.splitApply | Mathlib.Tactic.ComputeDegree | List Lean.MVarId → List Lean.MVarId → Lean.MetaM (List Lean.MVarId × List Lean.MVarId) | `splitApply mvs static` takes two lists of `MVarId`s. The first list, `mvs`,
corresponds to goals that are potentially within the scope of `compute_degree`:
namely, goals of the form
`natDegree f ≤ d`, `degree f ≤ d`, `natDegree f = d`, `degree f = d`, `coeff f d = r`.
`splitApply` determines which of these goals are... | true |
Lean.Order.bot_himp | Std.Internal.Order.Heyting | ∀ {l : Type u} [inst : Lean.Order.CompleteLattice l] {P : l} [Lean.Order.Heyting l],
Lean.Order.himp Lean.Order.bot P = Lean.Order.top | null | true |
GroupNorm.groupNormClass | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E], GroupNormClass (GroupNorm E) E ℝ | null | true |
IsPrimitiveRoot.nthRootsFinset_pairwise_associated_sub_one_sub_of_prime | Mathlib.RingTheory.RootsOfUnity.CyclotomicUnits | ∀ {p : ℕ} {A : Type u_1} {ζ : A} [inst : CommRing A] [inst_1 : IsDomain A],
IsPrimitiveRoot ζ p →
Nat.Prime p → (↑(Polynomial.nthRootsFinset p 1)).Pairwise fun η₁ η₂ => Associated (ζ - 1) (η₁ - η₂) | If `p` is prime and `ζ` is a `p`-th primitive root of unity, then `ζ - 1` and `η₁ - η₂` are
associated for all distinct `p`-th roots of unity `η₁` and `η₂`. | true |
IsSepClosed.isCyclotomicExtension | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (S : Set ℕ) (K : Type w) [inst : Field K] [IsSepClosed K], (∀ a ∈ S, a ≠ 0 → NeZero ↑a) → IsCyclotomicExtension S K K | Separably closed fields are `S`-cyclotomic extensions over themselves if
`NeZero ((a : ℕ) : K)` for all nonzero `a ∈ S`. | true |
Set.ordConnectedSection | Mathlib.Order.Interval.Set.OrdConnectedComponent | {α : Type u_1} → [LinearOrder α] → Set α → Set α | A set that intersects each order connected component of a set by a single point. Defined as the
range of `Set.ordConnectedProj s`. | true |
Finset.HasMulAntidiagonal.instMultiplicative | Mathlib.Algebra.Order.Antidiag.Prod | {A : Type u_2} → [inst : Add A] → [Finset.HasAntidiagonal A] → Finset.HasMulAntidiagonal (Multiplicative A) | null | true |
Subring.toSubsemiring_inj | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s t : Subring R}, s.toSubsemiring = t.toSubsemiring ↔ s = t | null | true |
sdiff_le_sdiff_of_sup_le_sup_right._to_dual_1 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b c : α}, b ⊓ c ≤ a ⊓ c → c ⇨ b ≤ c ⇨ a | null | false |
CategoryTheory.InjectiveResolution.Hom.hom | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
{Z : C} →
{I : CategoryTheory.InjectiveResolution Z} →
{Z' : C} →
{I' : CategoryTheory.InjectiveReso... | A morphism between the cocomplexes | true |
UInt16.ofNat_and | Init.Data.UInt.Bitwise | ∀ (a b : ℕ), UInt16.ofNat (a &&& b) = UInt16.ofNat a &&& UInt16.ofNat b | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.toList_rco_add_succ_right_eq_append._proof_1_4 | Init.Data.Range.Polymorphic.NatLemmas | ∀ (n : ℕ) {m : ℕ}, ¬m + 1 + n = m + (n + 1) → False | null | false |
AlgebraicGeometry.RingedSpace.basicOpen_mul | Mathlib.Geometry.RingedSpace.Basic | ∀ (X : AlgebraicGeometry.RingedSpace) {U : TopologicalSpace.Opens ↑↑X.toPresheafedSpace}
(f g : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen (f * g) = X.basicOpen f ⊓ X.basicOpen g | null | true |
Associates.out_eq_zero_iff | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : MonoidWithZero α] [inst_1 : NormalizationMonoid α] {a : Associates α}, a.out = 0 ↔ a = 0 | null | true |
Turing.PointedMap._sizeOf_inst | Mathlib.Computability.TuringMachine.Tape | (Γ : Type u) →
(Γ' : Type v) →
{inst : Inhabited Γ} → {inst_1 : Inhabited Γ'} → [SizeOf Γ] → [SizeOf Γ'] → SizeOf (Turing.PointedMap Γ Γ') | null | false |
Subalgebra.linearEquivOp._proof_2 | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
AddSubmonoidClass (Subalgebra R A) A | null | false |
CategoryTheory.IsSplitEqualizer.asFork_ι | Mathlib.CategoryTheory.Limits.Shapes.SplitEqualizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y} {W : C} {h : W ⟶ X}
(t : CategoryTheory.IsSplitEqualizer f g h), t.asFork.ι = h | null | true |
WithVal.instFaithfulSMul_1 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
{S : Type u_3} [inst_2 : SMul S R] [FaithfulSMul S R], FaithfulSMul S (WithVal v) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.