name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ProbabilityTheory.Kernel.iIndepFun.indepFun_add_left₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β} [inst : Add β]
[MeasurableAdd₂ β] {f : ι → Ω → β},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ι), AEM... | null | true |
IsEllipticNet.atomRel_neg₁ | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} [inst : CommRing R] {W : ℤ → R},
Function.Odd W → ∀ (a b c d : ℤ), IsEllipticNet.atomRel W (-a) b c d = IsEllipticNet.atomRel W a b c d | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.card_badVertices_le | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} (G : SimpleGraph α) [inst : DecidableRel G.Adj] {ε : ℝ} {s t : Finset α},
2 * ε ≤ ↑(G.edgeDensity s t) → G.IsUniform ε s t → ↑(SimpleGraph.badVertices✝ G ε s t).card ≤ ↑s.card * ε | null | true |
AlgebraicGeometry.instGeometricallyReducedSndScheme | Mathlib.AlgebraicGeometry.Geometrically.Reduced | ∀ {X Y S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) [AlgebraicGeometry.GeometricallyReduced f],
AlgebraicGeometry.GeometricallyReduced (CategoryTheory.Limits.pullback.snd f g) | null | true |
CongruenceSubgroup.strictWidthInfty_Gamma | Mathlib.NumberTheory.ModularForms.Cusps | ∀ (N : ℕ) [NeZero N],
(Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N)).strictWidthInfty = ↑N | null | true |
FinVec.exists_iff._f | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_1} (x : ℕ)
(f : Nat.below (motive := fun x => ∀ (x_1 : (Fin x → α) → Prop), FinVec.Exists x_1 ↔ ∃ x, x_1 x) x)
(x_1 : (Fin x → α) → Prop), FinVec.Exists x_1 ↔ ∃ x, x_1 x | null | false |
Lean.Omega.IntList.dot_mod_gcd_left | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList), xs.dot ys % ↑xs.gcd = 0 | null | true |
Set.Ico_disjoint_Ico._simp_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Disjoint (Set.Ico a₁ a₂) (Set.Ico b₁ b₂) = (min a₂ b₂ ≤ max a₁ b₁) | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁.mid | Mathlib.Algebra.Homology.Factorizations.CM5a | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
CochainComplex C ℤ → CochainComplex C ℤ → [CategoryTheory.EnoughInjectives C] → ℤ → CochainComplex C ℤ | The intermediate object in the factorization. | true |
Multiset.sum.eq_1 | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_2} [inst : AddCommMonoid M], Multiset.sum = Multiset.foldr (fun x1 x2 => x1 + x2) 0 | null | true |
_private.Mathlib.CategoryTheory.FiberedCategory.Cartesian.0.CategoryTheory.Functor.IsStronglyCartesian.comp.match_1 | Mathlib.CategoryTheory.FiberedCategory.Cartesian | ∀ {𝒮 : Type u_1} {𝒳 : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} 𝒮]
[inst_1 : CategoryTheory.Category.{u_2, u_3} 𝒳] (p : CategoryTheory.Functor 𝒳 𝒮) {R : 𝒮} {a b c : 𝒳} {φ : a ⟶ b}
{ψ : b ⟶ c} {a' : 𝒳} (h : p.obj a' ⟶ R) (τ : a' ⟶ c) (π' : a' ⟶ a)
(motive :
p.IsHomLift h π' ∧ CategoryTheory... | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Pred.0.String.all_bool_eq._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.ForwardPattern pat] {s : String}, s.all pat = s.toSlice.all pat | null | false |
ContinuousWithinAt.fun_zpow | Mathlib.Topology.Algebra.Group.ZPow | ∀ {G : Type u_1} {α : Type u_2} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G]
[inst_3 : TopologicalSpace α] {f : α → G} {x : α} {s : Set α},
ContinuousWithinAt f s x → ∀ (z : ℤ), ContinuousWithinAt (fun i => f i ^ z) s x | Eta-expanded form of `ContinuousWithinAt.zpow` | true |
Rep.coinvariantsFunctor_map_hom | Mathlib.RepresentationTheory.Coinvariants | ∀ (k : Type u) (G : Type v) [inst : CommRing k] [inst_1 : Monoid G] {X Y : Rep.{w, u, v} k G} (f : X ⟶ Y),
ModuleCat.Hom.hom ((Rep.coinvariantsFunctor k G).map f) = Representation.Coinvariants.map X.ρ Y.ρ (Rep.Hom.hom f) | null | true |
_private.Init.Data.Iterators.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_1.eq_3 | Init.Data.Iterators.Producers.Monadic.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} (motive : Std.IterStep (Std.IterM m α) α → Sort u_3)
(h_1 : (it' : Std.IterM m α) → (out : α) → motive (Std.IterStep.yield it' out))
(h_2 : (it : Std.IterM m α) → motive (Std.IterStep.skip it)) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
| ... | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.monomialRpow | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | (basis : Tactic.ComputeAsymptotics.Basis) → ℕ → ℝ → Tactic.ComputeAsymptotics.MultiseriesExpansion basis | Multiseries representing `basis[n] ^ r`. | true |
CategoryTheory.Functor.Final.preservesColimitsOfShape_of_final | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.Final] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_4 : CategoryTheory.Category.{v₄, u₄} B] (H : CategoryTheory.Functor E B)
... | null | true |
Tactic.ComputeAsymptotics.UnitMonomial.mul_length | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ {m1 m2 : Tactic.ComputeAsymptotics.UnitMonomial},
List.length m1 = List.length m2 → List.length (m1.mul m2) = List.length m1 | null | true |
DFinsupp.support_update | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (f : Π₀ (i : ι), β i) (i : ι) (b : β i)
[inst_3 : Decidable (b = 0)],
(f.update i b).support = if b = 0 then (DFinsupp.erase i f).support else insert i f.support | null | true |
AlgebraicGeometry.IsIntegral.mk._flat_ctor | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (Nonempty ↥X) AlgebraicGeometry.IsIntegral.nonempty._autoParam →
autoParam (∀ (U : X.Opens) [Nonempty ↥↑U], IsDomain ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsIntegral.component_integral._autoParam →
AlgebraicGeometry.IsIntegral X | null | false |
DualNumber.lift._proof_6 | Mathlib.Algebra.DualNumber | ∀ {R : Type u_3} {B : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B]
(fg :
{ fg //
(∀ (x y : A), fg.2 x * fg.2 y = 0) ∧
(∀ (r x : A), fg.2 (r • x) = fg.1 r * fg.2 x) ∧ ∀ (r x : A), fg.2 (MulOpposite.op r • ... | null | false |
_private.Mathlib.Data.Set.Insert.0.Set.subset_singleton_iff_eq._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {x : α}, s ⊆ {x} ↔ s = ∅ ∨ s = {x} | null | false |
dist_anti_left | Mathlib.Analysis.Normed.Order.UpperLower | ∀ {α : Type u_1} [inst : NormedAddCommGroup α] [inst_1 : Lattice α] [IsOrderedAddMonoid α] [HasSolidNorm α] {y : α},
AntitoneOn (fun x => dist x y) (Set.Iic y) | null | true |
Ordnode.Any.decidable._proof_1 | Mathlib.Data.Ordmap.Ordnode | ∀ {α : Type u_1} {P : α → Prop} [inst : DecidablePred P] (size : ℕ) (l : Ordnode α) (m : α) (r : Ordnode α)
(this : Decidable (Ordnode.Any P l)) (this_1 : Decidable (Ordnode.Any P r)),
(decide (Ordnode.Any P l) || decide (P m ∨ Ordnode.Any P r)).Reflects (Ordnode.Any P (Ordnode.node size l m r)) | null | false |
Array.Matcher.Iterator.mk.sizeOf_spec | Batteries.Data.Array.Match | ∀ {σ : Type u_1} {n : Type u_1 → Type u_2} {α : Type u_1} [inst : BEq α] {m : Array.Matcher α}
[inst_1 : Std.Iterator σ n α] [inst_2 : SizeOf σ] [inst_3 : (a : Type u_1) → SizeOf (n a)] [inst_4 : SizeOf α]
(inner : Std.IterM n α) (state : Fin (m.table.size + 1)),
sizeOf { inner := inner, state := state } = 1 + si... | null | true |
ModuleCon.instAddGroupQuotient._proof_10 | Mathlib.Algebra.Module.Congruence.Defs | ∀ {S : Type u_1} (M : Type u_2) [inst : SMul S M] [inst_1 : AddGroup M] (c : ModuleCon S M),
autoParam (∀ (n : ℕ) (a : ModuleCon.Quotient M c), Int.negSucc n • a = -(↑n.succ • a))
SubNegMonoid.zsmul_neg'._autoParam | null | false |
Std.IO.Process.availableMemory | Std.Async.Process | IO UInt64 | Returns the available memory for allocation in bytes.
| true |
Int.max_self | Init.Data.Int.Order | ∀ (a : ℤ), max a a = a | null | true |
AlgebraicGeometry.AffineTargetMorphismProperty.diagonal_respectsIso | Mathlib.AlgebraicGeometry.Morphisms.Constructors | ∀ (P : AlgebraicGeometry.AffineTargetMorphismProperty) [P.toProperty.RespectsIso], P.diagonal.toProperty.RespectsIso | null | true |
Units.mulRight.eq_1 | Mathlib.Algebra.Group.Units.Equiv | ∀ {M : Type u_3} [inst : Monoid M] (u : Mˣ),
u.mulRight = { toFun := fun x => x * ↑u, invFun := fun x => x * ↑u⁻¹, left_inv := ⋯, right_inv := ⋯ } | null | true |
Ordnode.splitMax'._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → α → Ordnode α → Ordnode α × α | null | false |
IsUnifLocDoublingMeasure.one_le_scalingConstantOf._simp_1 | Mathlib.MeasureTheory.Measure.Doubling | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α)
[inst_2 : IsUnifLocDoublingMeasure μ] (K : ℝ), (1 ≤ IsUnifLocDoublingMeasure.scalingConstantOf μ K) = True | null | false |
_private.Init.Meta.Defs.0.Lean.instQuoteNameMkStr1.match_1 | Init.Meta.Defs | (motive : Option (List String) → Sort u_1) →
(x : Option (List String)) → ((ss : List String) → motive (some ss)) → (Unit → motive none) → motive x | null | false |
directedOn_pair' | Mathlib.Order.Directed | ∀ {α : Type u_1} {r : α → α → Prop} [Std.Refl r] {a b : α}, r a b → DirectedOn r {b, a} | null | true |
MulArchimedeanClass.forall | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M]
{p : MulArchimedeanClass M → Prop}, (∀ (A : MulArchimedeanClass M), p A) ↔ ∀ (a : M), p (MulArchimedeanClass.mk a) | null | true |
_private.Init.Data.Slice.Lemmas.0.Std.Slice.foldlM_toList._simp_1_1 | Init.Data.Slice.Lemmas | ∀ {γ : Type u} {α β : Type v} {m : Type u_1 → Type u_2} {δ : Type u_1} [inst : Monad m]
[inst_1 : Std.ToIterator (Std.Slice γ) Id α β] [inst_2 : Std.Iterator α Id β] [inst_3 : Std.IteratorLoop α Id m]
{s : Std.Slice γ} {init : δ} {f : δ → β → m δ},
Std.Slice.foldlM f init s = Std.Iter.foldM f init (Std.Slice.Inte... | null | false |
LinearIsometryEquiv.conjStarAlgEquiv_apply | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] {K : Type u_6} [inst_4 : NormedAddCommGroup K] [inst_5 : InnerProductSpace 𝕜 K]
[inst_6 : CompleteSpace K] (e : H ≃ₗᵢ[𝕜] K) (x : H →L[𝕜] H), e.conjStarAlgEquiv x = ↑↑e ... | null | true |
CategoryTheory.uliftYoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁))) | Variant of the Yoneda embedding which allows a raise in the universe level
for the category of types. | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntryD.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → (a : α) × β a → Sort u_3)
(fallback : (a : α) × β a) (h_1 : (fallback : (a : α) × β a) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Internal.Im... | null | true |
_private.Mathlib.Analysis.Normed.Operator.Banach.0.ContinuousLinearMap.isUnit_iff_bijective._simp_1_2 | Mathlib.Analysis.Normed.Operator.Banach | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂}, (f.ker = ⊥) = Function.Injective ⇑f | null | false |
Metric.hausdorffEDist_le_of_mem_edist | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {s t : Set α} {r : ENNReal},
(∀ x ∈ s, ∃ y ∈ t, edist x y ≤ r) → (∀ x ∈ t, ∃ y ∈ s, edist x y ≤ r) → Metric.hausdorffEDist s t ≤ r | Bounding the Hausdorff edistance by exhibiting, for any point in each set,
another point in the other set at controlled distance | true |
MapClusterPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → {ι : Type u_3} → X → Filter ι → (ι → X) → Prop | A point `x` is a cluster point of a sequence `u` along a filter `F` if it is a cluster point
of `map u F`. | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing.inj | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ {h : Lean.Expr} {x : Int.Internal.Linear.Var} {e' : Int.Internal.Linear.Expr} {p : Int.Internal.Linear.Poly}
{re : Lean.Meta.Grind.Arith.CommRing.RingExpr} {rp : Lean.Grind.CommRing.Poly} {p' : Int.Internal.Linear.Poly}
{h_1 : Lean.Expr} {x_1 : Int.Internal.Linear.Var} {e'_1 : Int.Internal.Linear.Expr} {p_1 : Int... | null | true |
_private.Mathlib.Tactic.FinCases.0.Lean.Elab.Tactic.getMemType._sparseCasesOn_2 | Mathlib.Tactic.FinCases | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Limits.comp_preservesFiniteLimits | Mathlib.CategoryTheory.Limits.Preserves.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
(G : CategoryTheory.Functor D E) [CategoryTheory.Limits.PreservesFiniteLimits F]
[CategoryTheory.Limi... | The composition of two left exact functors is left exact. | true |
_private.Mathlib.Basic.ENNReal.Inv.0.ENNReal.zpow_neg._simp_1_3 | Mathlib.Basic.ENNReal.Inv | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a < b → (b < a) = False | null | false |
Equiv.Perm.sameCycle_apply_right._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, f.SameCycle x (f y) = f.SameCycle x y | null | false |
intervalIntegral.integrableOn_Ioo_cpow_iff | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {s : ℂ} {t : ℝ}, 0 < t → (MeasureTheory.IntegrableOn (fun x => ↑x ^ s) (Set.Ioo 0 t) MeasureTheory.volume ↔ -1 < s.re) | The complex power function `x ↦ x^s` is integrable on `(0, t)` iff `-1 < s.re`. | true |
RBTree.RBNode.Path.insertNew.eq_1 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} (path : RBTree.RBNode.Path α) (v : α),
path.insertNew v = path.ins (RBTree.RBNode.node RBTree.RBColor.red RBTree.RBNode.nil v RBTree.RBNode.nil) | null | true |
FiniteMultiplicity.not_of_one_left | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Monoid α] (b : α), ¬FiniteMultiplicity 1 b | null | true |
Std.Time.Day.instOrdOrdinal | Std.Time.Date.Unit.Day | Ord Std.Time.Day.Ordinal | null | true |
AlgebraicGeometry.affineLocally | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) →
CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme | For `P` a property of ring homomorphisms, `affineLocally P` holds for `f : X ⟶ Y` if for each
affine open `U = Spec A ⊆ Y` and `V = Spec B ⊆ f ⁻¹' U`, the ring hom `A ⟶ B` satisfies `P`.
Also see `affineLocally_iff_affineOpens_le`. | true |
_private.Mathlib.SetTheory.Cardinal.ENat.0.Cardinal.toENatAux_eq_nat._simp_1_1 | Mathlib.SetTheory.Cardinal.ENat | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | null | false |
add_neg_of_nonpos_of_neg | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b c : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftStrictMono α],
b ≤ c → a < 0 → b + a < c | **Alias** of `Left.add_neg_of_nonpos_of_neg`.
---
Assumes left covariance.
The lemma assuming right covariance is `Right.add_neg_of_nonpos_of_neg`. | true |
SimpleGraph.Walk.darts_dropUntil_subset | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v w u : V} [inst : DecidableEq V] (p : G.Walk v w) (h : u ∈ p.support),
(p.dropUntil u h).darts ⊆ p.darts | **Alias** of `SimpleGraph.Walk.darts_dropUntil_subset_darts`. | true |
IsCusp.smul | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {c : OnePoint ℝ} {𝒢 : Subgroup (GL (Fin 2) ℝ)},
IsCusp c 𝒢 → ∀ (g : GL (Fin 2) ℝ), IsCusp (g • c) (ConjAct.toConjAct g • 𝒢) | null | true |
WeakDual.extendRCLikeL._proof_5 | Mathlib.Analysis.Normed.Module.WeakDual | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], ContinuousConstSMul 𝕜 𝕜 | null | false |
FP.nextUpPos | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → (e : ℤ) → (m : ℕ) → FP.ValidFinite e m → FP.Float | null | true |
CategoryTheory.IsGrothendieckAbelian.mono_of_isColimit_monoOver | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.Subobject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] {X : C} {J : Type w} [inst_3 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J (CategoryTheory.MonoOver X)) [CategoryTheory.IsFiltered J]
{c : CategoryTheor... | If `C` is a Grothendieck abelian category, `X : C`, if `F : J ⥤ MonoOver X` is a
functor from a filtered category `J`, `c` is a colimit cocone for the corresponding
functor `J ⥤ C`, and `f : c.pt ⟶ X` is induced by the inclusions,
then `f` is a monomorphism. | true |
Lean.LLVM.Target.casesOn | Lean.Compiler.IR.LLVMBindings | {ctx : Lean.LLVM.Context} →
{motive : Lean.LLVM.Target ctx → Sort u} →
(t : Lean.LLVM.Target ctx) → ((ptr : USize) → motive { ptr := ptr }) → motive t | null | false |
toMul_list_sum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {M : Type u_3} [inst : Monoid M] (s : List (Additive M)), Additive.toMul s.sum = (List.map (⇑Additive.toMul) s).prod | null | true |
CategoryTheory.Dial.whiskerLeft_f | Mathlib.CategoryTheory.Dialectica.Monoidal | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasPullbacks C] (X x x_1 : CategoryTheory.Dial C) (f : x ⟶ x_1),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f).f =
CategoryTheory.Limits.prod.map (CategoryTheor... | null | true |
star_nsmul | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : AddMonoid R] [inst_1 : StarAddMonoid R] (n : ℕ) (x : R), star (n • x) = n • star x | null | true |
mem_coclosed_Lindelof' | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
s ∈ Filter.coclosedLindelof X ↔ ∃ t, IsClosed t ∧ IsLindelof t ∧ sᶜ ⊆ t | null | true |
BoundedContinuousFunction.const | Mathlib.Topology.ContinuousMap.Bounded.Basic | (α : Type u) →
{β : Type v} → [inst : TopologicalSpace α] → [inst_1 : PseudoMetricSpace β] → β → BoundedContinuousFunction α β | Constant as a continuous bounded function. | true |
Bool.cond_not_self_left | Init.Data.Bool | ∀ (c b : Bool), (bif c then !c else b) = (!c && b) | null | true |
isUpperSet_setOfPred | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : Preorder α] {p : α → Prop}, IsUpperSet {a | p a} ↔ Monotone p | null | true |
USize.upwardEnumerableLT_ofBitVec | Init.Data.Range.Polymorphic.UInt | ∀ {x y : BitVec System.Platform.numBits},
Std.PRange.UpwardEnumerable.LT { toBitVec := x } { toBitVec := y } ↔ Std.PRange.UpwardEnumerable.LT x y | null | true |
Lean.Meta.Tactic.TryThis.Suggestion.noConfusion | Lean.Meta.TryThis | {P : Sort u} →
{t t' : Lean.Meta.Tactic.TryThis.Suggestion} → t = t' → Lean.Meta.Tactic.TryThis.Suggestion.noConfusionType P t t' | null | false |
_private.Mathlib.Data.Nat.Bits.0.Nat.bit_lt_bit._proof_1_3 | Mathlib.Data.Nat.Bits | ∀ {n : ℕ}, 2 * n ≤ 2 * n | null | false |
_private.Mathlib.Util.Superscript.0.Mathlib.Tactic.Superscript.partitionPoint._unary._proof_1 | Mathlib.Util.Superscript | ∀ {α : Type u_1} (as : Array α),
WellFounded (invImage (fun x => PSigma.casesOn x fun lo hi => (hi, hi - lo)) Prod.instWellFoundedRelation).1 | null | false |
CategoryTheory.RegularEpi.unop._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : Cᵒᵖ} {f : X ⟶ Y}
(hf : CategoryTheory.RegularEpi f),
CategoryTheory.CategoryStruct.comp hf.left f = CategoryTheory.CategoryStruct.comp hf.right f | null | false |
Equiv.trans_toPartialEquiv | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (e' : β ≃ γ),
(e.trans e').toPartialEquiv = e.toPartialEquiv.trans e'.toPartialEquiv | null | true |
pi_nnnorm_const' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {E : Type u_3} [inst : Fintype ι] [inst_1 : SeminormedGroup E] [Nonempty ι] (a : E),
‖fun _i => a‖₊ = ‖a‖₊ | null | true |
Std.ExtTreeMap.ext_contains_unit | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp]
{t₁ t₂ : Std.ExtTreeMap α Unit cmp}, (∀ (k : α), t₁.contains k = t₂.contains k) → t₁ = t₂ | null | true |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_7 | Mathlib.Algebra.GroupWithZero.Range | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
MeasureTheory.AEEqFun.instAddCommGroup._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {γ : Type u_1} [inst : TopologicalSpace γ] [inst_1 : AddCommGroup γ] [IsTopologicalAddGroup γ], ContinuousAdd γ | null | false |
AlgCat.restrictScalarsEquivalenceOfRingEquiv_unitIso | Mathlib.Algebra.Category.AlgCat.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (e : R ≃+* S),
(AlgCat.restrictScalarsEquivalenceOfRingEquiv e).unitIso =
(AlgCat.restrictScalarsId' (RingHom.id S) ⋯).symm ≪≫
AlgCat.restrictScalarsComp' e.symm.toRingHom e.toRingHom (RingHom.id S) ⋯ | null | true |
AddSubgroup.normal_addSubgroupOf_of_le_normalizer | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H N : AddSubgroup G}, H ≤ AddSubgroup.normalizer ↑N → (N.addSubgroupOf H).Normal | null | true |
CategoryTheory.Arrow.LeftHomotopy.symm._proof_1 | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{u v : CategoryTheory.Arrow V} {f g : u ⟶ v} (h : CategoryTheory.Arrow.LeftHomotopy f g),
CategoryTheory.Arrow.Hom.left g - CategoryTheory.Arrow.Hom.left f = CategoryTheory.CategoryStruct.comp u.hom (-h.hom) | null | false |
StarSubalgebra.one_mem'._inherited_default | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u} {A : Type v} {inst : CommSemiring R} {inst_1 : StarRing R} {inst_2 : Semiring A} {inst_3 : StarRing A}
{inst_4 : Algebra R A} {inst_5 : StarModule R A} (carrier : Set A),
(∀ (r : R), (algebraMap R A) r ∈ carrier) → 1 ∈ carrier | null | false |
_private.Mathlib.Algebra.Lie.Basis.Prod.0.LieAlgebra.Basis.lie_snd_eq_zero_of_mem_prodCartan._proof_1_5 | Mathlib.Algebra.Lie.Basis.Prod | ∀ {ι₁ : Type u_5} {ι₂ : Type u_4} {L₁ : Type u_1} {L₂ : Type u_2} [inst : Finite ι₁] [inst_1 : Finite ι₂] (eι : ι₁ ≃ ι₂)
[inst_2 : LieRing L₁] [inst_3 : LieRing L₂] {R : Type u_3} [inst_4 : CommRing R] [inst_5 : LieAlgebra R L₁]
{H₁ : LieSubalgebra R L₁} (b₁ : LieAlgebra.Basis ι₁ H₁) [inst_6 : LieAlgebra R L₂] {H₂ ... | null | false |
Prod.instNeg | Mathlib.Algebra.Notation.Prod | {G : Type u_7} → {H : Type u_8} → [Neg G] → [Neg H] → Neg (G × H) | null | true |
AddSubsemigroup.unop_closure | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Add M] (s : Set Mᵃᵒᵖ),
(AddSubsemigroup.closure s).unop = AddSubsemigroup.closure (AddOpposite.op ⁻¹' s) | null | true |
MaxTropical.surjective_untrop | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u}, Function.Surjective MaxTropical.untrop | null | true |
asymm | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {r : α → α → Prop} {a b : α} [Std.Asymm r], r a b → ¬r b a | null | true |
CategoryTheory.Limits.Cofan.combPairIsColimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.CombinedProducts | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {ι₁ : Type u_1} {ι₂ : Type u_2} {f₁ : ι₁ → C}
{f₂ : ι₂ → C} {c₁ : CategoryTheory.Limits.Cofan f₁} {c₂ : CategoryTheory.Limits.Cofan f₂}
{bc : CategoryTheory.Limits.BinaryCofan c₁.pt c₂.pt} (h₁ : CategoryTheory.Limits.IsColimit c₁)
(h₂ : CategoryTheory... | null | false |
Std.DTreeMap.Internal.Impl.minKey?._proof_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : α → Type u_2}, WellFounded (invImage (fun x => x) sizeOfWFRel).1 | null | false |
PrimeSpectrum.closure_image_comap_zeroLocus | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (I : Ideal S),
closure (PrimeSpectrum.comap f '' PrimeSpectrum.zeroLocus ↑I) = PrimeSpectrum.zeroLocus ↑(Ideal.comap f I) | null | true |
Std.Iter.toArray_ensureTermination | Init.Data.Iterators.Lemmas.Consumers.Collect | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterators.Finite α Id] {it : Std.Iter β},
it.ensureTermination.toArray = it.toArray | null | true |
AddSubgroup.quotient_finite_of_isOpen | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [SeparatelyContinuousAdd G] [CompactSpace G]
(U : AddSubgroup G), IsOpen ↑U → Finite (G ⧸ U) | null | true |
lt_self_iff_false._simp_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False | null | false |
Option.pmap_some' | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {x : Option α} {a : α} {p : α → Prop} {f : (a : α) → p a → β} (he : x = some a)
{h : ∀ (a : α), x = some a → p a}, Option.pmap f x h = some (f a ⋯) | null | true |
DividedPowers.IsSubDPIdeal.dpow_eq_of_mem | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (hI : DividedPowers I) {J : Ideal A} (hJ : hI.IsSubDPIdeal J)
[inst_1 : (x : A) → Decidable (x ∈ J)] {n : ℕ} {a : A},
a ∈ J → (DividedPowers.IsSubDPIdeal.dividedPowers hI hJ).dpow n a = hI.dpow n a | null | true |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_2 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | null | false |
Mathlib.Meta.Positivity.PositivityExt.rec | Mathlib.Tactic.Positivity.Core | {motive : Mathlib.Meta.Positivity.PositivityExt → Sort u} →
((eval :
{u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα? : Option Q(PartialOrder «$α»)) →
(e : Q(«$α»)) → Lean.MetaM (Mathlib.Meta.Positivity.Strictness zα e pα?)) →
motive { e... | null | false |
Std.Http.Trailer.mk.inj | Std.Http.Data.Chunk | ∀ {headers headers_1 : Std.Http.Headers}, { headers := headers } = { headers := headers_1 } → headers = headers_1 | null | true |
biSup_le_eq_of_monotone | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] [inst_1 : Preorder β] {f : β → α},
Monotone f → ∀ (b : β), ⨆ b', ⨆ (_ : b' ≤ b), f b' = f b | null | true |
ProbabilityTheory.setBernoulli_ae_subset | Mathlib.Probability.Distributions.SetBernoulli | ∀ {ι : Type u_1} {u : Set ι} {p : ↑unitInterval} [Countable ι],
∀ᵐ (s : Set ι) ∂ProbabilityTheory.setBernoulli u p, s ⊆ u | null | true |
Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k a : α} {v : β k}, a ∈ (Std.DTreeMap.Internal.Impl.insertIfNew k v t ⋯).impl → compare k a ≠ Ordering.eq → a ∈ t | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.