name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Holor.CPRankMax1 | Mathlib.Data.Holor | {α : Type} → [Mul α] → {ds : List ℕ} → Holor α ds → Prop | `CPRankMax1 x` means `x` has CP rank at most 1, that is,
it is the tensor product of 1-dimensional holors. | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.compileToSimpleGroundExpr.compileFinalLet._sparseCasesOn_14 | Lean.Compiler.LCNF.SimpleGroundExpr | {motive : Lean.Compiler.LCNF.SimpleGroundArg → Sort u} →
(t : Lean.Compiler.LCNF.SimpleGroundArg) →
((n : Lean.Name) → motive (Lean.Compiler.LCNF.SimpleGroundArg.reference n)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
LieIdeal.map_comap_eq | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {J : LieIdeal R L'},
f.IsIdealMorphism → LieIdeal.map f (LieIdeal.comap f J) = f.idealRange ⊓ J | null | true |
MeasureTheory.IsFundamentalDomain.projection_respects_measure | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α]
{ν : MeasureTheory.Measure α} (μ : MeasureTheory.Measure (Quotient (MulAction.orbitRel G α)))
[i : MeasureTheory.QuotientMeasureEqMeasurePreimage ν μ] {t : Set α},
MeasureTheory.IsFundamentalDomain G t ν →
μ... | null | true |
CategoryTheory.WithTerminal._sizeOf_1 | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} → [SizeOf C] → CategoryTheory.WithTerminal C → ℕ | null | false |
Batteries.HashMap.findD | Batteries.Data.HashMap.Basic | {α : Type u_1} → {x : BEq α} → {x_1 : Hashable α} → {β : Type u_2} → Batteries.HashMap α β → α → β → β | Looks up an element in the map with key `a`. Returns `b₀` if the element is not found.
```
def hashMap := ofList [("one", 1), ("two", 2)]
hashMap.findD "one" 0 = 1
hashMap.findD "three" 0 = 0
```
| true |
ContinuousLinearMapWOT.instStarModuleId | Mathlib.Analysis.InnerProductSpace.WeakOperatorTopology | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F], StarModule 𝕜 (F →WOT[𝕜] F) | null | true |
PrespectralSpace.opensEquiv._proof_2 | Mathlib.Topology.Spectral.Prespectral | ∀ {X : Type u_1} [inst : TopologicalSpace X] (U : TopologicalSpace.Opens X) (U₁ U₂ : TopologicalSpace.CompactOpens X),
U₂ ≤ U₁ → U₁ ∈ {V | ↑V ⊆ ↑U} → ↑U₂ ⊆ ↑U | null | false |
TopologicalSpace.IsCompletelyMetrizableSpace.toIsCompletelyPseudoMetrizableSpace | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_1} [inst : TopologicalSpace X] [TopologicalSpace.IsCompletelyMetrizableSpace X],
TopologicalSpace.IsCompletelyPseudoMetrizableSpace X | A completely metrizable space is completely pseudometrizable. | true |
Std.Iterators.Types.Flatten.IsPlausibleStep.innerSkip_flatMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α β α₂ γ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m]
[inst_3 : Std.Iterator α m β] [inst_4 : Std.Iterator α₂ m γ] {f : β → m (Std.IterM m γ)} {it₁ : Std.IterM m β}
{it₂ it₂' : Std.IterM m γ},
it₂.IsPlausibleStep (Std.IterStep.skip it₂') →
(Std.IterM.flatMapAft... | null | true |
AddSubgroup.addCommutator_pi_pi_le | Mathlib.GroupTheory.Commutator.Basic | ∀ {η : Type u_4} {Gs : η → Type u_5} [inst : (i : η) → AddGroup (Gs i)] (H K : (i : η) → AddSubgroup (Gs i)),
⁅AddSubgroup.pi Set.univ H, AddSubgroup.pi Set.univ K⁆ ≤ AddSubgroup.pi Set.univ fun i => ⁅H i, K i⁆ | The commutator of direct product is contained in the direct product of the
commutators. See `commutator_pi_pi_of_finite` for equality given `Fintype η`. | true |
_private.Mathlib.Data.Set.Function.0.Set.InjOn.imageFactorization_injective.match_1_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} (x : α) (hx : x ∈ s)
(motive : (x_1 : ↑s) → Set.imageFactorization f s ⟨x, hx⟩ = Set.imageFactorization f s x_1 → Prop) (x_1 : ↑s)
(h' : Set.imageFactorization f s ⟨x, hx⟩ = Set.imageFactorization f s x_1),
(∀ (y : α) (hy : y ∈ s) (h' : Set.imageFactorizatio... | null | false |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.isBlock_iff_disjoint_smul_of_ne._simp_1_2 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_3} {α : Type u_5} [inst : Group G] [inst_1 : MulAction G α] {g : G} {a b : α}, (a = g • b) = (g⁻¹ • a = b) | null | false |
ModularFormClass.exp_decay_sub_atImInfty' | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {Γ : Subgroup (GL (Fin 2) ℝ)} (f : F)
[ModularFormClass F Γ k] [Γ.HasDetPlusMinusOne] [DiscreteTopology ↥Γ] [Fact (IsCusp OnePoint.infty Γ)],
∃ c > 0, (fun τ => f τ - UpperHalfPlane.valueAtInfty ⇑f) =O[UpperHalfPlane.atImInfty] fun τ => Real.exp (-c * τ.i... | Version of `exp_decay_sub_atImInfty` stating a less precise result but easier to apply in
practice (not specifying the growth rate precisely).
Note that the `Fact` hypothesis is automatically synthesized for arithmetic subgroups.
The discreteness hypothesis may be unnecessary, but it is satisfied in the cases of inter... | true |
Std.DTreeMap.Internal.Impl.BalancedAtRoot.eq_1 | Std.Data.DTreeMap.Internal.Balanced | ∀ (left right : ℕ),
Std.DTreeMap.Internal.Impl.BalancedAtRoot left right =
(left + right ≤ 1 ∨ left ≤ Std.DTreeMap.Internal.delta * right ∧ right ≤ Std.DTreeMap.Internal.delta * left) | null | true |
fderivWithin_mul | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {s : Set E} {𝔸' : Type u_5} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {c d : E → 𝔸'},
UniqueDiffWithinAt 𝕜 s x →
DifferentiableWithinAt 𝕜 c s x →
... | null | true |
lt_norm_sub_of_not_sameRay | Mathlib.Analysis.Convex.StrictConvexSpace | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [StrictConvexSpace ℝ E] {x y : E},
¬SameRay ℝ x y → ‖x‖ - ‖y‖ < ‖x - y‖ | null | true |
AddValuation.map_le_sub | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{x y : R} {g : Γ₀}, g ≤ v x → g ≤ v y → g ≤ v (x - y) | null | true |
CategoryTheory.Limits.preservesFiniteLimits_of_preservesEqualizers_and_finiteProducts | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.Limits.HasEqualizers C] [CategoryTheory.Limits.HasFiniteProducts C] (G : CategoryTheory.Functor C D)
[CategoryTheory.Limits.PreservesLimitsOfShape CategoryTheory.Limits.WalkingParalle... | If G preserves equalizers and finite products, it preserves finite limits. | true |
FormalMultilinearSeries.leftInv.eq_def | Mathlib.Analysis.Analytic.Inverse | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
(p : FormalMultilinearSeries 𝕜 E F) (i : E ≃L[𝕜] F) (x : E) (x_1 : ℕ),
p.leftInv i x x_1 =
match x_1 wit... | null | true |
CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_unitIso_inv_naturality_assoc | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (n : ℤ)
{X Y : Cᵒᵖ} (f : X ⟶ Y) {Z : Cᵒᵖ} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.shiftFunctor C n).map ((CategoryTheory.shiftFunctor Cᵒᵖ n).map f).unop).op
(CategoryTheory.Cate... | null | true |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_11 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Lean.Server.Ilean.version | Lean.Server.References | Lean.Server.Ilean → ℕ | Version number of the ilean format. | true |
Nat.mul_sub_left_distrib | Init.Data.Nat.Basic | ∀ (n m k : ℕ), n * (m - k) = n * m - n * k | null | true |
Action.ofMulActionLimitCone._proof_3 | Mathlib.CategoryTheory.Action.Concrete | ∀ {ι : Type u_2} (G : Type (max u_2 u_1)) [inst : Monoid G] (F : ι → Type (max u_2 u_1))
[inst_1 : (i : ι) → MulAction G (F i)] (i : CategoryTheory.Discrete ι) (x : G),
CategoryTheory.CategoryStruct.comp
((((CategoryTheory.Functor.const (CategoryTheory.Discrete ι)).obj (Action.ofMulAction G ((i : ι) → F i))).... | null | false |
_private.Batteries.Data.Char.Basic.0.Char.toNat_not_surrogate._proof_1_3 | Batteries.Data.Char.Basic | ∀ (c : Char), c.toNat < 55296 → ¬(55296 ≤ c.toNat ∧ c.toNat ≤ 57343) | null | false |
AddGroup.addRight_bijective | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G), Function.Bijective fun x => x + a | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.elabTermAux | Lean.Elab.Term.TermElabM | Option Lean.Expr → Bool → Bool → Lean.Syntax → Lean.Elab.TermElabM Lean.Expr | Main loop for `elabTerm` | true |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_atBot._proof_1_1 | Mathlib.Analysis.Calculus.LHopital | ContinuousSMul ℝ ℝ | null | false |
UInt32.toBitVec_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt32), (a ^^^ b).toBitVec = a.toBitVec ^^^ b.toBitVec | null | true |
CategoryTheory.Bicategory.Adjunction | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u₁} → [inst : CategoryTheory.Bicategory B] → {a b : B} → (a ⟶ b) → (b ⟶ a) → Type w₁ | Adjunction between two 1-morphisms. | true |
_private.Lean.Compiler.LCNF.AlphaEqv.0.Lean.Compiler.LCNF.AlphaEqv.eqvType._sparseCasesOn_4 | Lean.Compiler.LCNF.AlphaEqv | {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)) →
(Nat.hasNotBit 128 t.ctorIdx → motive t) → motive t | null | false |
MeasureTheory.aecover_Ioc_of_Icc | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {α : Type u_1} {ι : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {l : Filter ι}
[inst_1 : LinearOrder α] [inst_2 : TopologicalSpace α] [OrderClosedTopology α] [OpensMeasurableSpace α] {a b : ι → α}
{A B : α} [MeasureTheory.NullSingletonClass μ],
Filter.Tendsto a l (nhds A) →
Filter.Ten... | null | true |
WithBot.decidableLT.eq_3 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] [inst_1 : DecidableLT α] (a b : α),
WithBot.decidableLT (some a) (some b) = decidable_of_iff' (a < b) ⋯ | null | true |
CategoryTheory.Limits.IsZero.iso | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → CategoryTheory.Limits.IsZero X → CategoryTheory.Limits.IsZero Y → (X ≅ Y) | Any two zero objects are isomorphic. | true |
MeasureTheory.unifTight_iff_real | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : NormedAddCommGroup β] {x : MeasurableSpace α} (f : ι → α → β)
(p : ENNReal) (μ : MeasureTheory.Measure α),
MeasureTheory.UnifTight f p μ ↔
∀ (ε : ℝ), 0 < ε → ∃ s, μ s ≠ ⊤ ∧ ∀ (i : ι), MeasureTheory.eLpNorm (sᶜ.indicator (f i)) p μ ≤ ENNReal.ofReal ε | null | true |
Module.End.eq_zero_of_isNilpotent_isSemisimple | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{f : Module.End R M}, IsNilpotent f → f.IsSemisimple → f = 0 | null | true |
CategoryTheory.InitialModel | Mathlib.CategoryTheory.Limits.FinallySmall | (J : Type u) → [inst : CategoryTheory.Category.{v, u} J] → [CategoryTheory.InitiallySmall J] → Type w | An arbitrarily chosen small model for an initially small category. | true |
_private.Lean.Meta.Tactic.FunIndCollect.0.Lean.Meta.FunInd.Collector.visit._sparseCasesOn_4 | Lean.Meta.Tactic.FunIndCollect | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body... | null | false |
Stream'.Seq.take.eq_def | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (x : ℕ) (x_1 : Stream'.Seq α),
Stream'.Seq.take x x_1 =
match x, x_1 with
| 0, x => []
| n.succ, s =>
match s.destruct with
| none => []
| some (x, r) => x :: Stream'.Seq.take n r | null | true |
PartOrd.uliftFunctor._proof_2 | Mathlib.Order.Category.PartOrd | ∀ {X Y Z : PartOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
PartOrd.ofHom
{
toFun := fun x =>
{ down := (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g)) x.down },
monotone' := ⋯ } =
CategoryTheory.CategoryStruct.comp
(PartOrd.ofHom { toFun := fun x => { down :=... | null | false |
BoundedContinuousFunction.instIntCast | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
[inst : TopologicalSpace α] →
{β : Type u_2} → [inst_1 : PseudoMetricSpace β] → [IntCast β] → IntCast (BoundedContinuousFunction α β) | null | true |
_private.Mathlib.AlgebraicGeometry.OpenImmersion.0.AlgebraicGeometry.IsOpenImmersion.of_isIso_stalkMap._proof_1_1 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y)
[∀ (x : ↥X), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap f x)] (x : ↥X),
CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.Hom.stalkMap f.toShHom.hom x) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_of_not_smulOverflow._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
x.toInt * y.toInt < 2 ^ w ∧ -2 ^ w ≤ x.toInt * y.toInt → ¬-(2 ^ (w + 1) / 2) ≤ x.toInt * y.toInt → False | null | false |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence.0.groupCohomology.map_cochainsFunctor_shortExact._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LongExactSequence | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)),
S.Exact = ((ModuleCat.Hom.hom S.f).range = (ModuleCat.Hom.hom S.g).ker) | null | false |
Std.Internal.List.getValueD_insertListConst_of_mem | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l : List ((_ : α) × β)} {toInsert : List (α × β)} {k k' : α}
{v fallback : β},
Std.Internal.List.DistinctKeys l →
(k == k') = true →
List.Pairwise (fun a b => (a.1 == b.1) = false) toInsert →
(k, v) ∈ toInsert → Std.Internal.List.getValueD k... | null | true |
CategoryTheory.SimplicialObject.Augmented.rightOp_left | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C),
X.rightOp.left = Opposite.op X.right | null | true |
FreeSimplexQuiver.homRel.rec | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {motive : ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ → (a a_1 : X ⟶ Y) → FreeSimplexQuiver.homRel a a_1 → Prop},
(∀ {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheo... | null | false |
IsStarProjection.add | Mathlib.Algebra.Star.StarProjection | ∀ {R : Type u_1} {p q : R} [inst : NonUnitalNonAssocSemiring R] [inst_1 : StarRing R],
IsStarProjection p → IsStarProjection q → p * q = 0 → IsStarProjection (p + q) | The sum of star projections is a star projection if their product is `0`. | true |
NonUnitalAlgHom.equalizer._proof_3 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : NonUnitalNonAssocSemiring B] [inst_4 : Module R B] (ϕ ψ : A →ₙₐ[R] B) {x y : A},
ϕ x = ψ x → ϕ y = ψ y → x * y ∈ {a | ϕ a = ψ a} | null | false |
Lean.PrettyPrinter.Formatter.checkTailWs.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.Analysis.InnerProductSpace.LinearMap.0._aux_Mathlib_Analysis_InnerProductSpace_LinearMap___unexpand_Inner_inner_2 | Mathlib.Analysis.InnerProductSpace.LinearMap | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Data.Seq.Defs.0.Stream'.Seq.«_aux_Mathlib_Data_Seq_Defs___macroRules__private_Mathlib_Data_Seq_Defs_0_Stream'_Seq_term_~__1» | Mathlib.Data.Seq.Defs | Lean.Macro | null | false |
MeasureTheory.lintegral_add_left | Mathlib.MeasureTheory.Integral.Lebesgue.Add | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
Measurable f → ∀ (g : α → ENNReal), ∫⁻ (a : α), f a + g a ∂μ = ∫⁻ (a : α), f a ∂μ + ∫⁻ (a : α), g a ∂μ | If `f g : α → ℝ≥0∞` are two functions and one of them is (a.e.) measurable, then the Lebesgue
integral of `f + g` equals the sum of integrals. This lemma assumes that `f` is integrable, see also
`MeasureTheory.lintegral_add_right` and primed versions of these lemmas. | true |
CategoryTheory.Enriched.HasConicalProducts.hasConicalLimitsOfShape | Mathlib.CategoryTheory.Enriched.Limits.HasConicalProducts | ∀ {V : outParam (Type u')} {inst : CategoryTheory.Category.{v', u'} V} {inst_1 : CategoryTheory.MonoidalCategory V}
{C : Type u} {inst_2 : CategoryTheory.Category.{v, u} C} {inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C}
[self : CategoryTheory.Enriched.HasConicalProducts V C] (J : Type w),
CategoryTheory.E... | A family of objects (parametrized by any `J : Type w`) has a conical product. | true |
MulActionHom.fst | Mathlib.GroupTheory.GroupAction.Hom | (M : Type u_1) → (α : Type u_2) → (β : Type u_3) → [inst : SMul M α] → [inst_1 : SMul M β] → α × β →ₑ[id] α | `Prod.fst` as a bundled `MulActionHom`. | true |
Lean.Elab.Term.LValResolution.noConfusion | Lean.Elab.App | {P : Sort u} → {t t' : Lean.Elab.Term.LValResolution} → t = t' → Lean.Elab.Term.LValResolution.noConfusionType P t t' | null | false |
HomotopyCategory.Plus.instCommShiftPlusIntUpHomFunctorQuotientCompιIso | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C],
CategoryTheory.NatTrans.CommShift (HomotopyCategory.Plus.quotientCompιIso C).hom ℤ | null | true |
Lean.Grind.CommRing.Poly.powC_nc._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → ℕ → Lean.Grind.CommRing.Poly | null | false |
Std.Net.SocketAddressV6.mk._flat_ctor | Std.Net.Addr | Std.Net.IPv6Addr → UInt16 → Std.Net.SocketAddressV6 | null | false |
vectorSpan_eq_span_vsub_set_right_ne | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : Set P} {p : P},
p ∈ s → vectorSpan k s = Submodule.span k ((fun x => x -ᵥ p) '' (s \ {p})) | The `vectorSpan` is the span of the pairwise subtractions with a given point on the right,
excluding the subtraction of that point from itself. | true |
Set.inter_preimage_subset | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β) (f : α → β), s ∩ f ⁻¹' t ⊆ f ⁻¹' (f '' s ∩ t) | null | true |
HomogeneousLocalization.awayMapₐ_apply | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] (𝒜 : ι → σ)
[inst_5 : GradedRing 𝒜] {e : ι} {f g : A} (hg : g ∈ 𝒜 e) {x : A} (hx : x = f * g)
(a : HomogeneousLocalization.Away 𝒜 f),
... | null | true |
SimpleGraph.isClique_iff_induce_eq | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) {s : Set α}, G.IsClique s ↔ SimpleGraph.induce s G = ⊤ | A clique is a set of vertices whose induced graph is complete. | true |
Set.subset_sInter_iff | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {S : Set (Set α)} {t : Set α}, t ⊆ ⋂₀ S ↔ ∀ t' ∈ S, t ⊆ t' | null | true |
Lean.Order.instMonoBindOption | Init.Internal.Order.Basic | Lean.Order.MonoBind Option | null | true |
List.length_permutations | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} (l : List α), l.permutations.length = l.length.factorial | null | true |
_private.Aesop.Search.Main.0.Aesop.search.match_1 | Aesop.Search.Main | (motive : Option Aesop.LocalRuleSet → Sort u_1) →
(ruleSet? : Option Aesop.LocalRuleSet) →
(Unit → motive none) → ((ruleSet : Aesop.LocalRuleSet) → motive (some ruleSet)) → motive ruleSet? | null | false |
Multiset.ndinsert_le | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s t : Multiset α}, Multiset.ndinsert a s ≤ t ↔ s ≤ t ∧ a ∈ t | null | true |
_private.Mathlib.GroupTheory.Archimedean.0.Subgroup.exists_isLeast_one_lt._simp_1_1 | Mathlib.GroupTheory.Archimedean | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [MulRightMono α] {a b c : α}, (a / c ≤ b) = (a ≤ b * c) | null | false |
Sylow.mapSurjective | Mathlib.GroupTheory.Sylow | {p : ℕ} →
{G : Type u_1} →
[inst : Group G] →
[Finite G] →
{G' : Type u_2} →
[inst_2 : Group G'] → {f : G →* G'} → Function.Surjective ⇑f → [Fact (Nat.Prime p)] → Sylow p G → Sylow p G' | Surjective group homomorphisms map Sylow subgroups to Sylow subgroups. | true |
Nat.toList_roo_eq_cons_iff._simp_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {xs : List ℕ} {m n a : ℕ}, ((m<...n).toList = a :: xs) = (m + 1 = a ∧ m + 1 < n ∧ (m + 1<...n).toList = xs) | null | false |
DistLat.Hom.rec | Mathlib.Order.Category.DistLat | {X Y : DistLat} →
{motive : X.Hom Y → Sort u_1} → ((hom' : LatticeHom ↑X ↑Y) → motive { hom' := hom' }) → (t : X.Hom Y) → motive t | null | false |
Lean.Compiler.LCNF.withPhase | Lean.Compiler.LCNF.CompilerM | {α : Type} → Lean.Compiler.LCNF.Phase → Lean.Compiler.LCNF.CompilerM α → Lean.Compiler.LCNF.CompilerM α | null | true |
Polynomial.SplittingField.instCommRing._proof_23 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (a : f.SplittingField), a * 0 = 0 | null | false |
Std.Rxi.Iterator.ctorIdx | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} → Std.Rxi.Iterator α → ℕ | null | false |
_private.Std.Http.Protocol.H1.Writer.0.Std.Http.Protocol.H1.Writer.determineTransferMode.match_1 | Std.Http.Protocol.H1.Writer | (motive : Option Std.Http.Body.Length → Sort u_1) →
(x : Option Std.Http.Body.Length) →
((mode : Std.Http.Body.Length) → motive (some mode)) → ((x : Option Std.Http.Body.Length) → motive x) → motive x | null | false |
Std.Tactic.BVDecide.BVUnOp.eval_reverse | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ}, Std.Tactic.BVDecide.BVUnOp.reverse.eval = BitVec.reverse | null | true |
Aesop.RuleTacInput._sizeOf_1 | Aesop.RuleTac.Basic | Aesop.RuleTacInput → ℕ | null | false |
UInt32.toUInt8_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), a < 256 → b < 256 → (a % b).toUInt8 = a.toUInt8 % b.toUInt8 | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceSMTSDiv._regBuiltin.BitVec.reduceSMTSDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.3312069005._hygCtx._hyg.29 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | null | false |
aestronglyMeasurable_derivWithin_Ici | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] (f : ℝ → F) [CompleteSpace F]
(μ : MeasureTheory.Measure ℝ), MeasureTheory.AEStronglyMeasurable (fun x => derivWithin f (Set.Ici x) x) μ | null | true |
Lean.Widget.GetWidgetSourceParams.mk.sizeOf_spec | Lean.Widget.UserWidget | ∀ (hash : UInt64) (pos : Lean.Lsp.Position), sizeOf { hash := hash, pos := pos } = 1 + sizeOf hash + sizeOf pos | null | true |
CategoryTheory.ParametrizedAdjunction.liftStructEquiv._proof_8 | Mathlib.CategoryTheory.LiftingProperties.ParametrizedAdjunction | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)}
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor... | null | false |
Nat.mem_factoredNumbers_iff_primeFactors_subset | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ}, m ∈ Nat.factoredNumbers s ↔ m ≠ 0 ∧ m.primeFactors ⊆ s | `m` is `s`-factored if and only if `m ≠ 0` and its `Finset` of prime factors
is contained in `s`. | true |
SimplyConnectedSpace.mk._flat_ctor | Mathlib.AlgebraicTopology.FundamentalGroupoid.SimplyConnected | ∀ {X : Type u_3} [inst : TopologicalSpace X],
Nonempty (FundamentalGroupoid X ≌ CategoryTheory.Discrete Unit) → SimplyConnectedSpace X | null | false |
LieAlgebra.SemiDirectSum.toProd._proof_2 | Mathlib.Algebra.Lie.SemiDirect | ∀ {R : Type u_3} [inst : CommRing R] {K : Type u_1} [inst_1 : LieRing K] [inst_2 : LieAlgebra R K] {L : Type u_2}
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] {ψ : L →ₗ⁅R⁆ LieDerivation R K K} (x : K × L),
({ left := x.1, right := x.2 }.left, { left := x.1, right := x.2 }.right) =
({ left := x.1, right := x.2... | null | false |
Std.Time.TimeZone.ZoneRules.findLocalTimeTypeForWallTime | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.ZoneRules → Std.Time.WallTime → Std.Time.TimeZone.LocalTimeType | Finds the `LocalTimeType` for a given wall-clock time (seconds since 1970-01-01T00:00:00 in local time).
Unlike `findLocalTimeTypeForTimestamp`, this compares each transition's UTC time adjusted by the
previous offset — necessary when converting local time to UTC.
When the wall time falls beyond all stored transitions... | true |
MonCat.Hom.casesOn | Mathlib.Algebra.Category.MonCat.Basic | {A B : MonCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →* ↑B) → motive { hom' := hom' }) → motive t | null | false |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.piCongrLeft_sumInl._proof_1_1 | Mathlib.Logic.Equiv.Basic | ∀ {ι : Type u_4} {ι' : Type u_3} {ι'' : Sort u_2} (π : ι'' → Type u_1) (e : ι ⊕ ι' ≃ ι'')
(f : (i : ι) → π (e (Sum.inl i))) (g : (i : ι') → π (e (Sum.inr i))) (i : ι),
(Equiv.piCongrLeft π e) ((Equiv.sumPiEquivProdPi fun x => π (e x)).symm (f, g)) (e (Sum.inl i)) = f i | null | false |
SimplexCategory.Truncated.δ₂_one_comp_σ₂_one._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | Lean.Syntax | null | false |
Subgroup.topologicalClosure._proof_3 | Mathlib.Topology.Algebra.Group.Subgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G] (s : Subgroup G)
{a b : G}, a ∈ s.topologicalClosure.carrier → b ∈ s.topologicalClosure.carrier → a * b ∈ s.topologicalClosure.carrier | null | false |
FourierInvSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | ∀ {R : Type u_5} {E : Type u_6} {F : outParam (Type u_7)} [inst : SMul R E] [inst_1 : SMul R F]
[inst_2 : FourierTransformInv E F],
(∀ (r : R) (f : E), FourierTransformInv.fourierInv (r • f) = r • FourierTransformInv.fourierInv f) →
FourierInvSMul R E F | null | false |
_private.Init.Data.String.Basic.0.String.Pos.sliceFrom._proof_1 | Init.Data.String.Basic | ∀ {s : String} (p₀ pos : s.Pos),
p₀ ≤ pos → String.Pos.Raw.IsValidForSlice (s.sliceFrom p₀) (pos.offset.unoffsetBy p₀.offset) | null | false |
Subfield.topologicalClosure.congr_simp | Mathlib.Topology.Instances.Complex | ∀ {α : Type u_2} [inst : Field α] [inst_1 : TopologicalSpace α] [inst_2 : IsTopologicalDivisionRing α]
(K K_1 : Subfield α), K = K_1 → K.topologicalClosure = K_1.topologicalClosure | null | true |
WithLp.neg_snd | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : AddCommGroup β] (x : WithLp p (α × β)),
(-x).snd = -x.snd | null | true |
MeasureTheory.AEStronglyMeasurable.real_toNNReal | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
MeasureTheory.AEStronglyMeasurable f μ → MeasureTheory.AEStronglyMeasurable (fun x => (f x).toNNReal) μ | null | true |
Descriptive.Tree.drop_coe | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} (T : ↥(Descriptive.tree A)) (n : ℕ) (x : ↥T), ↑(Descriptive.Tree.drop T n x) = List.drop n ↑x | null | true |
Metric.unitClosedBall.coe_mul | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (x y : ↑(Metric.closedBall 0 1)), ↑(x * y) = ↑x * ↑y | null | true |
Lean.Language.Lean.CommandElaboratingSnapshot.noConfusion | Lean.Language.Lean.Types | {P : Sort u} →
{t t' : Lean.Language.Lean.CommandElaboratingSnapshot} →
t = t' → Lean.Language.Lean.CommandElaboratingSnapshot.noConfusionType P t t' | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.