name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Complex.real_lt_real._simp_1 | Mathlib.Analysis.Complex.Order | ∀ {x y : ℝ}, (↑x < ↑y) = (x < y) | false |
SubStarSemigroup.toSubsemigroup | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} → [inst : Mul M] → [inst_1 : Star M] → SubStarSemigroup M → Subsemigroup M | true |
CategoryTheory.AB5OfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w', v, u} C] →
{motive : CategoryTheory.AB5OfSize.{w, w', v, u} C → Sort u_1} →
((ofShape :
∀ (J : Type w') [inst_2 : CategoryTheory.Category.{w, w'} J] [inst_3 : CategoryTheory.IsFiltered J],
CategoryTheory.HasExactColimitsOfShape J C) →
motive ⋯) →
(t : CategoryTheory.AB5OfSize.{w, w', v, u} C) → motive t | false |
Ordnode.findLtAux._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → α → α | false |
SetLike.isCoatom_iff | Mathlib.Order.Atoms | ∀ {A : Type u_4} {B : Type u_5} [inst : PartialOrder A] [inst_1 : SetLike A B] [IsConcreteLE A B] [inst_3 : OrderTop A]
{K : A}, IsCoatom K ↔ K ≠ ⊤ ∧ ∀ (H : A) (g : B), K ≤ H → g ∉ K → g ∈ H → H = ⊤ | true |
_private.Init.Data.String.Extra.0.String.findLeadingSpacesSize.consumeSpaces._mutual._proof_3 | Init.Data.String.Extra | ∀ {s : String} (it : s.Pos) (curr min : ℕ) (h : ¬it.IsAtEnd),
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun it curr => PSigma.casesOn curr fun curr min => it) fun _x =>
PSigma.casesOn _x fun it min => it)
String.Pos.instWellFoundedRelation).1
(PSum.inr ⟨it.next h, min⟩) (PSum.inl ⟨it, ⟨curr, min⟩⟩) | false |
ListSlice | Init.Data.Slice.List.Basic | Type u → Type u | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_4 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u} [inst : Monoid α] {a b : αˣ}, (a = b) = (↑a = ↑b) | false |
Std.DTreeMap.Internal.Impl.ExplorationStep.noConfusionType | Std.Data.DTreeMap.Internal.Model | Sort u_1 →
{α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{k : α → Ordering} →
Std.DTreeMap.Internal.Impl.ExplorationStep α β k →
{α' : Type u} →
{β' : α' → Type v} →
[inst' : Ord α'] → {k' : α' → Ordering} → Std.DTreeMap.Internal.Impl.ExplorationStep α' β' k' → Sort u_1 | false |
FreeAddMagmaAssocQuotientEquiv.eq_1 | Mathlib.Algebra.Free | ∀ (α : Type u),
FreeAddMagmaAssocQuotientEquiv α =
(AddMagma.FreeAddSemigroup.lift FreeAddMagma.toFreeAddSemigroup).toAddEquiv
(FreeAddSemigroup.lift (⇑AddMagma.FreeAddSemigroup.of ∘ FreeAddMagma.of)) ⋯ ⋯ | true |
Std.Tactic.BVDecide.BVBinOp.mul.elim | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVBinOp → Sort u} →
(t : Std.Tactic.BVDecide.BVBinOp) → t.ctorIdx = 4 → motive Std.Tactic.BVDecide.BVBinOp.mul → motive t | false |
Lean.Elab.Command.State.traceState | Lean.Elab.Command | Lean.Elab.Command.State → Lean.TraceState | true |
Std.DTreeMap.Raw.contains_modify | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {k k' : α} {f : β k → β k}, (t.modify k f).contains k' = t.contains k' | true |
IsGreatest.nnnorm_cfcₙ_nnreal._auto_5 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | false |
Bundle.Trivialization.restrictPreimage'._proof_7 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e : Bundle.Trivialization F proj) (s : Set B)
[inst_3 : Nonempty (↑s → F → ↑(proj ⁻¹' s))], IsOpen (e.toPretrivialization.restrictPreimage' s).baseSet | false |
UInt8.toUInt32_toUInt16 | Init.Data.UInt.Lemmas | ∀ (n : UInt8), n.toUInt16.toUInt32 = n.toUInt32 | true |
_private.Mathlib.Algebra.Star.Unitary.0.Unitary.instNegSubtypeMemSubmonoidUnitary._simp_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] {U : R}, (U ∈ unitary R) = (star U * U = 1 ∧ U * star U = 1) | false |
CategoryTheory.Localization.Monoidal.functorCoreMonoidalOfComp._simp_4 | Mathlib.CategoryTheory.Localization.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Triangle.sSameSide_affineSpan_pair_point_excenter_singleton._proof_1_1 | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ → i₁ ≠ i₃ → i₂ ≠ i₃ → {t.points i₂, t.points i₃} = t.points '' {i₁}ᶜ | false |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.isExpensiveConstantValueBoxing._sparseCasesOn_8 | Lean.Compiler.LCNF.ExplicitBoxing | {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 | false |
EquivLike.surjective | Mathlib.Data.FunLike.Equiv | ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [inst : EquivLike E α β] (e : E), Function.Surjective ⇑e | true |
Set.Nonempty.intrinsicClosure | Mathlib.Analysis.Convex.Intrinsic | ∀ {𝕜 : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] {s : Set P}, s.Nonempty → (intrinsicClosure 𝕜 s).Nonempty | true |
Std.Rii.toList_eq_nil_iff | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rii α} [inst : LT α] [DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α] [inst : Std.Rxi.IsAlwaysFinite α],
r.toList = [] ↔ ¬Nonempty α | true |
Lean.Grind.instModUInt32UintOfNatNat | Init.GrindInstances.ToInt | Lean.Grind.ToInt.Mod UInt32 (Lean.Grind.IntInterval.uint 32) | true |
VitaliFamily.measure_le_mul_of_subset_limRatioMeas_lt | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}
(v : VitaliFamily μ) [inst_1 : SecondCountableTopology α] [inst_2 : BorelSpace α]
[inst_3 : MeasureTheory.IsLocallyFiniteMeasure μ] {ρ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsLocallyFiniteMeasure ρ] (hρ : ρ.AbsolutelyContinuous μ) {p : NNReal} {s : Set α},
s ⊆ {x | v.limRatioMeas hρ x < ↑p} → ρ s ≤ ↑p * μ s | true |
Finset.left_mem_Icc | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α], a ∈ Finset.Icc a b ↔ a ≤ b | true |
MonadSaveCtx.mk._flat_ctor | ProofWidgets.Util | {m : Type → Type} → {n : outParam (Type → Type)} → ({α : Type} → m α → m (n α)) → MonadSaveCtx m n | false |
MeasureTheory.MemLp.enorm_rpow | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} {ε : Type u_6}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] {f : α → ε},
MeasureTheory.MemLp f p μ → p ≠ 0 → p ≠ ⊤ → MeasureTheory.MemLp (fun x => ‖f x‖ₑ ^ p.toReal) 1 μ | true |
Equiv.trans_refl | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} (e : α ≃ β), e.trans (Equiv.refl β) = e | true |
CategoryTheory.Limits.MultispanIndex.inj_sndSigmaMapOfIsColimit | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left}
(d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c) (i : J.L),
CategoryTheory.CategoryStruct.comp (c.inj i) (I.sndSigmaMapOfIsColimit d hc) =
CategoryTheory.CategoryStruct.comp (I.snd i) (d.inj (J.snd i)) | true |
Rack.PreEnvelGroupRel'.trans.injEq | Mathlib.Algebra.Quandle | ∀ {R : Type u} [inst : Rack R] {a b c : Rack.PreEnvelGroup R} (hab : Rack.PreEnvelGroupRel' R a b)
(hbc : Rack.PreEnvelGroupRel' R b c) (b_1 : Rack.PreEnvelGroup R) (hab_1 : Rack.PreEnvelGroupRel' R a b_1)
(hbc_1 : Rack.PreEnvelGroupRel' R b_1 c), (hab.trans hbc = hab_1.trans hbc_1) = (b = b_1 ∧ hab ≍ hab_1 ∧ hbc ≍ hbc_1) | true |
CategoryTheory.Limits.IsLimit.mk | 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} →
{t : CategoryTheory.Limits.Cone F} →
(lift : (s : CategoryTheory.Limits.Cone F) → s.pt ⟶ t.pt) →
autoParam
(∀ (s : CategoryTheory.Limits.Cone F) (j : J),
CategoryTheory.CategoryStruct.comp (lift s) (t.π.app j) = s.π.app j)
CategoryTheory.Limits.IsLimit.fac._autoParam →
autoParam
(∀ (s : CategoryTheory.Limits.Cone F) (m : s.pt ⟶ t.pt),
(∀ (j : J), CategoryTheory.CategoryStruct.comp m (t.π.app j) = s.π.app j) → m = lift s)
CategoryTheory.Limits.IsLimit.uniq._autoParam →
CategoryTheory.Limits.IsLimit t | true |
TopHom.mk.sizeOf_spec | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_6} {β : Type u_7} [inst : Top α] [inst_1 : Top β] [inst_2 : SizeOf α] [inst_3 : SizeOf β] (toFun : α → β)
(map_top' : toFun ⊤ = ⊤), sizeOf { toFun := toFun, map_top' := map_top' } = 1 + sizeOf map_top' | true |
CochainComplex.HomComplex.Cocycle.diff | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → (K : CochainComplex C ℤ) → CochainComplex.HomComplex.Cocycle K K 1 | true |
AlgebraicGeometry.Scheme.AffineZariskiSite.isColimitCocone._proof_2 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ (X : AlgebraicGeometry.Scheme),
CategoryTheory.Limits.HasColimit (AlgebraicGeometry.Scheme.AffineZariskiSite.relativeGluingData ⋯).functor | false |
AddSubgroup.fg_iff | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : AddGroup G] (P : AddSubgroup G), P.FG ↔ ∃ S, AddSubgroup.closure S = P ∧ S.Finite | true |
ProbabilityTheory.charFunDual_map_add_prod_eq_mul | Mathlib.Probability.Independence.CharacteristicFunction | ∀ {E : Type u_2} {mE : MeasurableSpace E} [inst : NormedAddCommGroup E] [BorelSpace E] [SecondCountableTopology E]
[inst_3 : NormedSpace ℝ E] {μ ν : MeasureTheory.Measure E} [MeasureTheory.IsProbabilityMeasure μ]
[MeasureTheory.IsProbabilityMeasure ν],
MeasureTheory.charFunDual (MeasureTheory.Measure.map (fun p => p.1 + p.2) (μ.prod ν)) =
MeasureTheory.charFunDual μ * MeasureTheory.charFunDual ν | true |
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator.mk | Lean.PrettyPrinter.Delaborator.SubExpr | ℕ → ℕ → Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator | true |
Lean.Parser.Term.subst._regBuiltin.Lean.Parser.Term.subst.parenthesizer_13 | Lean.Parser.Term | IO Unit | false |
_private.Init.Data.Slice.List.Lemmas.0.List.toArray_mkSlice_roc._simp_1_1 | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, Std.Slice.toArray xs = (Std.Slice.toList xs).toArray | false |
Topology.IsScott.isUpperSet_of_isOpen | Mathlib.Topology.Order.ScottTopology | ∀ {α : Type u_1} {D : Set (Set α)} [inst : Preorder α] [inst_1 : TopologicalSpace α] {s : Set α} [Topology.IsScott α D],
IsOpen s → IsUpperSet s | true |
Polynomial.coeff_modByMonic_mem_pow_natDegree_mul | Mathlib.Algebra.Polynomial.CoeffMem | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (p q : Polynomial S)
(Mp : Submodule R S),
(∀ (i : ℕ), p.coeff i ∈ Mp) →
1 ∈ Mp →
∀ (Mq : Submodule R S), (∀ (i : ℕ), q.coeff i ∈ Mq) → 1 ∈ Mq → ∀ (i : ℕ), (p %ₘ q).coeff i ∈ Mq ^ p.natDegree * Mp | true |
MDifferentiableWithinAt.sum | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {s : Set M} {z : M} {ι : Type} {t : Finset ι} {f : ι → M → E'},
(∀ i ∈ t, MDiffAt[s] (f i) z) → MDiffAt[s] (∑ i ∈ t, f i) z | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Basic.0.iteratedFDeriv_const_of_ne._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : ℕ}, iteratedFDeriv 𝕜 n f = iteratedFDerivWithin 𝕜 n f Set.univ | false |
Dynamics.IsDynNetIn.monotone_subset | Mathlib.Dynamics.TopologicalEntropy.Subset | ∀ {X : Type u_1} {T : X → X} {F G s : Set X} {U : SetRel X X} {n : ℕ},
F ⊆ G → Dynamics.IsDynNetIn T F U n s → Dynamics.IsDynNetIn T G U n s | true |
Batteries.BinomialHeap.Imp.HeapNode.foldTreeM | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.BinomialHeap.Imp.HeapNode α → m β | true |
String.Pos.Raw.instLinearOrderPackage._proof_4 | Init.Data.String.OrderInstances | ∀ (a b : String.Pos.Raw), a ≤ b ∨ b ≤ a | false |
_private.Mathlib.Topology.Baire.Lemmas.0.IsGδ.baireSpace_of_dense._proof_1_3 | Mathlib.Topology.Baire.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (f : ℕ → Set ↑s) (V : ℕ → Set X)
(hV : (∀ (n : ℕ), IsOpen (V n)) ∧ s = ⋂ n, V n) (g : ℕ → Set X) (x : X),
(∀ (n : ℕ), Subtype.val ⁻¹' g n = f n) →
((∀ (i : ℕ), x ∈ g i ∧ x ∈ V i) ↔ ∃ (x_1 : ∀ (i : ℕ), x ∈ V i), ∀ (i : ℕ), ⟨x, ⋯⟩ ∈ f i) | false |
WittVector._sizeOf_1 | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} → {R : Type u_1} → [SizeOf R] → WittVector p R → ℕ | false |
String.Legacy.instSizeOfIterator | Init.Data.String.Iterator | SizeOf String.Legacy.Iterator | true |
InfTopHom.dual.eq_1 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Top α] [inst_2 : Min β] [inst_3 : Top β],
InfTopHom.dual =
{ toFun := fun f => { toSupHom := InfHom.dual f.toInfHom, map_bot' := ⋯ },
invFun := fun f => { toInfHom := InfHom.dual.symm f.toSupHom, map_top' := ⋯ }, left_inv := ⋯, right_inv := ⋯ } | true |
CategoryTheory.Pseudofunctor.ObjectProperty.fullsubcategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(P : F.ObjectProperty) [inst_1 : P.IsClosedUnderMapObj] {a b : B} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
{ toNatTrans := P.map₂ (CategoryTheory.CategoryStruct.comp η θ) } =
CategoryTheory.CategoryStruct.comp { toNatTrans := P.map₂ η } { toNatTrans := P.map₂ θ } | false |
mdifferentiableWithinAt_of_isInvertible_mfderivWithin | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {x : M} {s : Set M},
(mfderivWithin I I' f s x).IsInvertible → MDiffAt[s] f x | true |
Lean.Elab.Structural.addSmartUnfoldingDef | Lean.Elab.PreDefinition.Structural.SmartUnfolding | Lean.LocalContext × Lean.LocalInstances → Lean.Elab.PreDefinition → ℕ → Lean.Elab.TermElabM Unit | true |
Turing.TM1.eval | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
[Inhabited Λ] →
[inst : Inhabited Γ] → [Inhabited σ] → (Λ → Turing.TM1.Stmt Γ Λ σ) → List Γ → Part (Turing.ListBlank Γ) | true |
MvPowerSeries.coeff_mul | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (n : σ →₀ ℕ) (φ ψ : MvPowerSeries σ R) [inst_1 : DecidableEq σ],
(MvPowerSeries.coeff n) (φ * ψ) =
∑ p ∈ Finset.antidiagonal n, (MvPowerSeries.coeff p.1) φ * (MvPowerSeries.coeff p.2) ψ | true |
CategoryTheory.Bicategory.LeftExtension.IsAbsKan.hasAbsLeftKanExtension | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : a ⟶ b} {g : a ⟶ c}
{t : CategoryTheory.Bicategory.LeftExtension f g} (H : t.IsAbsKan),
CategoryTheory.Bicategory.HasAbsLeftKanExtension f g | true |
_private.Plausible.Gen.0.Plausible.Gen.arrayOf.match_1 | Plausible.Gen | (motive : ULift.{u_1, 0} ℕ → Sort u_2) →
(__discr : ULift.{u_1, 0} ℕ) → ((sz : ℕ) → motive { down := sz }) → motive __discr | false |
OrderMonoidHom.coe_mk | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : MulOneClass α]
[inst_3 : MulOneClass β] (f : α →* β) (h : Monotone (↑f).toFun), ⇑{ toMonoidHom := f, monotone' := h } = ⇑f | true |
MeasureTheory.integrableOn_univ | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε],
MeasureTheory.IntegrableOn f Set.univ μ ↔ MeasureTheory.Integrable f μ | true |
AlgebraicGeometry.Proj.lift_awayMapₐ_awayMapₐ_surjective | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {σ : Type u_1} {A : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {d e : ℕ} {f : A} (hf : f ∈ 𝒜 d) {g : A} (hg : g ∈ 𝒜 e) {x : A} (hx : x = f * g),
0 < d →
Function.Surjective
⇑(Algebra.TensorProduct.lift (HomogeneousLocalization.awayMapₐ 𝒜 hg hx) (HomogeneousLocalization.awayMapₐ 𝒜 hf ⋯)
⋯) | true |
Equiv.subtypeInjectiveEquivEmbedding | Mathlib.Logic.Embedding.Basic | (α : Sort u_1) → (β : Sort u_2) → { f // Function.Injective f } ≃ (α ↪ β) | true |
Infinite.casesOn | Mathlib.Data.Finite.Defs | {α : Sort u_3} → {motive : Infinite α → Sort u} → (t : Infinite α) → ((not_finite : ¬Finite α) → motive ⋯) → motive t | false |
Nat.sub_succ' | Init.Data.Nat.Lemmas | ∀ (m n : ℕ), m - n.succ = m - n - 1 | true |
AddSubgroup.centerCongr.eq_1 | Mathlib.GroupTheory.Subgroup.Center | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H] (e : G ≃+ H),
AddSubgroup.centerCongr e = AddSubmonoid.centerCongr e | true |
CategoryTheory.GrothendieckTopology.instIsIsoFunctorOppositeToPresheafFiberNatTransPointBotCoeEquivHomUnopOpObjTypeShrinkYonedaSymmShrinkYonedaObjObjEquivId | Mathlib.CategoryTheory.Sites.Point.Presheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] (X : C)
(A : Type u_1) [inst_2 : CategoryTheory.Category.{u_2, u_1} A]
[inst_3 : CategoryTheory.Limits.HasColimitsOfSize.{w, w, u_2, u_1} A],
CategoryTheory.IsIso
((CategoryTheory.GrothendieckTopology.pointBot X).toPresheafFiberNatTrans X
(CategoryTheory.shrinkYonedaObjObjEquiv.symm (CategoryTheory.CategoryStruct.id X))) | true |
Lean.Meta.ACLt.ReduceMode.ctorElimType | Lean.Meta.ACLt | {motive : Lean.Meta.ACLt.ReduceMode → Sort u} → ℕ → Sort (max 1 u) | false |
totallyBounded_iff_subset_finite_iUnion_nhds_one | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : Group α] [IsUniformGroup α] {s : Set α},
TotallyBounded s ↔ ∀ U ∈ nhds 1, ∃ t, t.Finite ∧ s ⊆ ⋃ y ∈ t, y • U | true |
_private.Lean.LibrarySuggestions.SineQuaNon.0.Lean.LibrarySuggestions.SineQuaNon.sineQuaNonExt.match_1 | Lean.LibrarySuggestions.SineQuaNon | (motive : Array (Array (Lean.NameMap (List (Lean.Name × Float)))) → Empty → Sort u_1) →
(a : Array (Array (Lean.NameMap (List (Lean.Name × Float))))) → (a_1 : Empty) → motive a a_1 | false |
PseudoEpimorphismClass.exists_map_eq_of_map_le | Mathlib.Topology.Order.Hom.Esakia | ∀ {F : Type u_6} {α : outParam (Type u_7)} {β : outParam (Type u_8)} {inst : Preorder α} {inst_1 : Preorder β}
{inst_2 : FunLike F α β} [self : PseudoEpimorphismClass F α β] (f : F) ⦃a : α⦄ ⦃b : β⦄, f a ≤ b → ∃ c, a ≤ c ∧ f c = b | true |
PEmpty.rec._@.Mathlib.Util.CompileInductive.1077078790._hygCtx._hyg.3 | Mathlib.Util.CompileInductive | (motive : PEmpty.{u} → Sort u_1) → (t : PEmpty.{u}) → motive t | false |
CategoryTheory.Limits.prod.inl | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) → [inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y] → X ⟶ X ⨯ Y | true |
Subfield.relrank_mul_rank_top | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B : Subfield E}, A ≤ B → A.relrank B * Module.rank (↥B) E = Module.rank (↥A) E | true |
groupHomology.cyclesMap_comp_cyclesIso₀_hom | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
CategoryTheory.CategoryStruct.comp (groupHomology.cyclesMap f φ 0) (groupHomology.cyclesIso₀ B).hom =
CategoryTheory.CategoryStruct.comp (groupHomology.cyclesIso₀ A).hom (Rep.Hom.toModuleCatHom φ) | true |
ContinuousMap.instNonUnitalNonAssocSemiringOfIsTopologicalSemiring._proof_4 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : NonUnitalNonAssocSemiring β] [inst_3 : IsTopologicalSemiring β] (f g : C(α, β)), ⇑(f * g) = ⇑f * ⇑g | false |
IsometryEquiv.toEquiv_injective | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β],
Function.Injective IsometryEquiv.toEquiv | true |
CochainComplex.HomComplex.Cochain.fromSingleMk._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | IsRightCancelAdd ℤ | false |
Set.nonempty_uIoo._simp_1 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α} [DenselyOrdered α], (Set.uIoo a b).Nonempty = (a ≠ b) | false |
Submodule.hasDistribPointwiseNeg._proof_1 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A], IsScalarTower R A A | false |
Filter.mem_principal | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {s t : Set α}, s ∈ Filter.principal t ↔ t ⊆ s | true |
HomologicalComplex₂.flipEquivalenceCounitIso._proof_1 | Mathlib.Algebra.Homology.HomologicalBicomplex | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_1} {I₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂) (K : HomologicalComplex₂ C c₂ c₁)
(i₂ : I₂) (i j : I₁),
c₁.Rel i j →
CategoryTheory.CategoryStruct.comp
((fun x =>
CategoryTheory.Iso.refl
(((((HomologicalComplex₂.flipFunctor C c₂ c₁).comp (HomologicalComplex₂.flipFunctor C c₁ c₂)).obj K).X
i₂).X
x))
i).hom
((((CategoryTheory.Functor.id (HomologicalComplex₂ C c₂ c₁)).obj K).X i₂).d i j) =
CategoryTheory.CategoryStruct.comp
(((((HomologicalComplex₂.flipFunctor C c₂ c₁).comp (HomologicalComplex₂.flipFunctor C c₁ c₂)).obj K).X i₂).d i
j)
((fun x =>
CategoryTheory.Iso.refl
(((((HomologicalComplex₂.flipFunctor C c₂ c₁).comp (HomologicalComplex₂.flipFunctor C c₁ c₂)).obj K).X
i₂).X
x))
j).hom | false |
HMul.ctorIdx | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → HMul α β γ → ℕ | false |
LinOrd.instCategory._proof_3 | Mathlib.Order.Category.LinOrd | ∀ {W X Y Z : LinOrd} (f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ hom' := h.hom'.comp { hom' := g.hom'.comp f.hom' }.hom' } =
{ hom' := { hom' := h.hom'.comp g.hom' }.hom'.comp f.hom' } | false |
Lean.Server.Watchdog.ServerContext.logData | Lean.Server.Watchdog | Lean.Server.Watchdog.ServerContext → Lean.Server.Watchdog.LogData | true |
Std.Sat.AIG.Fanin.ofRaw._flat_ctor | Std.Sat.AIG.Basic | ℕ → Std.Sat.AIG.Fanin | false |
Representation.LinearizeMonoidal.μ_apply_single_single | Mathlib.RepresentationTheory.Action | ∀ {G : Type v} [inst : Monoid G] {X Y : Action (Type w) G} {k : Type u} [inst_1 : CommSemiring k] (x : X.V) (y : Y.V)
(r s : k), (Representation.LinearizeMonoidal.μ X Y) ((fun₀ | x => r) ⊗ₜ[k] fun₀ | y => s) = fun₀ | (x, y) => r * s | true |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.Key._sizeOf_1 | Lean.Meta.Tactic.Grind.MBTC | Lean.Meta.Grind.Key✝ → ℕ | false |
CategoryTheory.ShortComplex.exact_of_iso | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂), S₁.Exact → S₂.Exact | true |
Int.erdos_ginzburg_ziv | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {n : ℕ} {s : Finset ι} (a : ι → ℤ), 2 * n - 1 ≤ s.card → ∃ t ⊆ s, t.card = n ∧ ↑n ∣ ∑ i ∈ t, a i | true |
_private.Lean.Meta.Tactic.Grind.ForallProp.0.Lean.Meta.Grind.propagateForallPropUp.propagateImpliesUp | Lean.Meta.Tactic.Grind.ForallProp | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Unit | true |
IO.Process.SpawnArgs.env._default | Init.System.IO | Array (String × Option String) | false |
TwoSidedIdeal.ker._proof_4 | Mathlib.RingTheory.TwoSidedIdeal.Kernel | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : FunLike F R S] (f : F), Equivalence fun x y => f x = f y | false |
Set.monotone_powerset | Mathlib.Data.Set.Basic | ∀ {α : Type u}, Monotone Set.powerset | true |
TopologicalSpace.Opens.map_comp_map | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) {U V : TopologicalSpace.Opens ↑Z} (i : U ⟶ V),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp f g)).map i =
(TopologicalSpace.Opens.map f).map ((TopologicalSpace.Opens.map g).map i) | true |
TrivSqZeroExt.addGroupWithOne._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddGroupWithOne R] [inst_1 : AddGroup M] (a : TrivSqZeroExt R M),
SubNegMonoid.zsmul 0 a = 0 | false |
HahnEmbedding.Seed.baseEmbedding._proof_4 | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K], RingHomInvPair (RingHom.id K) (RingHom.id K) | false |
Ideal.span_range_eq_iSup | Mathlib.RingTheory.Ideal.Span | ∀ {α : Type u} [inst : Semiring α] {ι : Type u_1} (x : ι → α), Ideal.span (Set.range x) = ⨆ i, Ideal.span {x i} | true |
Complementeds.coe_inj._simp_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] {a b : Complementeds α}, (↑a = ↑b) = (a = b) | false |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.optionNameAndVal.match_6 | Lean.Elab.DocString.Builtin | (motive : Option String → Sort u_1) →
(x : Option String) → ((s : String) → motive (some s)) → ((x : Option String) → motive x) → motive x | false |
Continuous.matrix_elem | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace R]
{A : X → Matrix m n R}, Continuous A → ∀ (i : m) (j : n), Continuous fun x => A x i j | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.