name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TemperedDistribution.instFourierTransformInv._proof_3 | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E], ContinuousFourierInv (SchwartzMap E ℂ) (SchwartzMap E ℂ) | null | false |
MvPolynomial.monomial_eq | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} {a : R} {s : σ →₀ ℕ} [inst : CommSemiring R],
(MvPolynomial.monomial s) a = MvPolynomial.C a * s.prod fun n e => MvPolynomial.X n ^ e | null | true |
CategoryTheory.Limits.HasWeakLimit.casesOn | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{C : Type u_3} →
[inst_1 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J C} →
{motive : CategoryTheory.Limits.HasWeakLimit F → Sort u} →
(t : CategoryTheory.Limits.HasWeakLimit F) →
... | null | false |
Monotone.partialSups_eq | Mathlib.Order.PartialSups | ∀ {α : Type u_1} {ι : Type u_3} [inst : SemilatticeSup α] [inst_1 : Preorder ι] [inst_2 : LocallyFiniteOrderBot ι]
{f : ι → α}, Monotone f → ⇑(partialSups f) = f | null | true |
Vector.mapIdx_setIfInBounds | Init.Data.Vector.MapIdx | ∀ {α : Type u_1} {n : ℕ} {α_1 : Type u_2} {f : ℕ → α → α_1} {xs : Vector α n} {i : ℕ} {a : α},
Vector.mapIdx f (xs.setIfInBounds i a) = (Vector.mapIdx f xs).setIfInBounds i (f i a) | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Bisector.0.EuclideanGeometry.oangle_eq_of_dist_orthogonalProjection_eq._proof_1_3 | Mathlib.Geometry.Euclidean.Angle.Bisector | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p' : P} {s₂ : AffineSubspace ℝ P}, p' ∈ s₂ → Nonempty ↥s₂ | null | false |
Filter.vsub_mem_vsub | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : VSub α β] {f g : Filter β} {s t : Set β}, s ∈ f → t ∈ g → s -ᵥ t ∈ f -ᵥ g | null | true |
CategoryTheory.CommGrpObj.ctorIdx | Mathlib.CategoryTheory.Monoidal.Cartesian.CommGrp_ | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} → {X : C} → CategoryTheory.CommGrpObj X → ℕ | null | false |
Lean.Environment.requiredModules | ImportGraph.Imports.RequiredModules | Lean.Environment → Lean.NameSet | Return the names of the modules in which constants used in the current file were defined.
Note that this will *not* account for tactics and syntax used in the file,
so the results may not suffice as imports.
| true |
Lean.Syntax.antiquotKinds | Lean.Syntax | Lean.Syntax → List (Lean.SyntaxNodeKind × Bool) | null | true |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.RCasesPatt.parse | Lean.Elab.Tactic.RCases | Lean.Syntax → Lean.MetaM Lean.Elab.Tactic.RCases.RCasesPatt | Parses a `Syntax` into the `RCasesPatt` type used by the `RCases` tactic. | true |
Irrational.of_intCast_div | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (m : ℤ), Irrational (↑m / x) → Irrational x | null | true |
Std.Time.Internal.Bounded.LE.eq._proof_1 | Std.Time.Internal.Bounded | ∀ {n : ℤ}, n ≤ n ∧ n ≤ n | null | false |
_private.Mathlib.ModelTheory.Syntax.0.FirstOrder.Language.Term.varFinset.match_1.eq_1 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : L.Term α → Sort u_4) (i : α)
(h_1 : (i : α) → motive (FirstOrder.Language.var i))
(h_2 : (l : ℕ) → (_f : L.Functions l) → (ts : Fin l → L.Term α) → motive (FirstOrder.Language.func _f ts)),
(match FirstOrder.Language.var i with
| FirstOrder.Language.var i =... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_insertIfNew._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
MonoidHom.domRestrictHomKerEquiv._proof_8 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] (A : Type u_2) [inst_1 : CommGroup A] (H : Subgroup G) [inst_2 : H.Normal]
(x : G ⧸ H →* A),
(fun x =>
match x with
| ⟨f, hf⟩ => QuotientGroup.lift H f ⋯)
((fun f => ⟨f.comp (QuotientGroup.mk' H), ⋯⟩) x) =
x | null | false |
_private.Init.Data.UInt.Lemmas.0.UInt8.le_iff_lt_or_eq._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
Polynomial.residueFieldMapCAlgEquiv._simp_14 | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R) (x : A),
(algebraMap R A) r * x = r • x | null | false |
CategoryTheory.ShortComplex.instMonoRightHomologyι | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasRightHomology], CategoryTheory.Mono S.rightHomologyι | null | true |
Primrec.listFilter | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop} [inst_1 : DecidablePred p],
PrimrecPred p → Primrec fun L => List.filter (fun x => decide (p x)) L | Filtering a list for elements that satisfy a decidable predicate is primitive recursive. | true |
_private.Mathlib.Geometry.Convex.ConvexSpace.Defs.0.Convexity.convexCombPair_iConvexComb_iConvexComb.match_1_3.splitter | Mathlib.Geometry.Convex.ConvexSpace.Defs | {J₁ : Type u_1} →
{J₂ : Type u_2} →
(motive : (a : Fin 0) → ![ULift.{max u_1 u_2, u_1} J₁, ULift.{max u_1 u_2, u_2} J₂] a.succ.succ → Sort u_3) →
(a : Fin 0) → (a_1 : ![ULift.{max u_1 u_2, u_1} J₁, ULift.{max u_1 u_2, u_2} J₂] a.succ.succ) → motive a a_1 | null | true |
divisorsAntidiagonalFactors_eq | Mathlib.NumberTheory.TsumDivisorsAntidiagonal | ∀ {n : ℕ+} (x : ↥(↑n).divisorsAntidiagonal),
↑(divisorsAntidiagonalFactors n x).1 * ↑(divisorsAntidiagonalFactors n x).2 = ↑n | null | true |
Int64.ne_not_self | Init.Data.SInt.Bitwise | ∀ {a : Int64}, a ≠ ~~~a | null | true |
Std.DHashMap.Raw.getKeyD_alter_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} [inst_2 : LawfulBEq α]
[Inhabited α] {k fallback : α} {f : Option (β k) → Option (β k)},
m.WF → (m.alter k f).getKeyD k fallback = if (f (m.get? k)).isSome = true then k else fallback | null | true |
instDecidableEqFreeAddMagma.decEq._proof_5 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (a a_1 : FreeAddMagma α) (a_2 : α), ¬a.add a_1 = FreeAddMagma.of a_2 | null | false |
Mathlib.Tactic.ITauto.instToExprAndKind.toExpr | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.AndKind → Lean.Expr | null | true |
Substring.toString | Init.Data.String.Substring | Substring.Raw → String | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int64.reduceEq._regBuiltin.Int64.reduceEq.declare_2._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.922157756._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
_private.Init.Data.List.MinMaxOn.0.List.le_apply_maxOn_of_mem._simp_1_1 | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | null | false |
Mathlib.Tactic.Algebraize.instInhabitedConfig.default | Mathlib.Tactic.Algebraize | Mathlib.Tactic.Algebraize.Config | null | true |
instGroupObjOppositeOpensCarrierOfPresheafSmoothSheaf._aux_12 | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_3} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_4} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_5} →
... | null | false |
Lean.Parser.Tactic.mkOptConfig | Init.Meta.Defs | Lean.TSyntaxArray `Lean.Parser.Tactic.configItem → Lean.TSyntax `Lean.Parser.Tactic.optConfig | null | true |
Matrix.single_vecMul | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} [inst : Fintype m] [inst_1 : DecidableEq m]
[inst_2 : NonUnitalNonAssocSemiring R] (M : Matrix m n R) (i : m) (x : R),
Matrix.vecMul (Pi.single i x) M = x • M.row i | null | true |
List.foldl_min | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] [Std.IdempotentOp min] [Std.Associative min] {l : List α} {a : α},
List.foldl min a l = a ⊓ l.min?.getD a | This lemma is also applicable given the following instances:
```
[LE α] [Min α] [IsLinearOrder α] [LawfulOrderMin α]
```
| true |
gaugeSeminorm_ball_one | Mathlib.Analysis.Convex.Gauge | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module ℝ E] {s : Set E} [inst_2 : RCLike 𝕜]
[inst_3 : Module 𝕜 E] [inst_4 : IsScalarTower ℝ 𝕜 E] {hs₀ : Balanced 𝕜 s} {hs₁ : Convex ℝ s} {hs₂ : Absorbent ℝ s}
[inst_5 : TopologicalSpace E] [ContinuousSMul ℝ E], IsOpen s → (gaugeSeminorm hs₀ hs₁ ... | null | true |
_private.Mathlib.Analysis.SpecificLimits.Basic.0.ENNReal.tendsto_pow_atTop_nhds_top_iff._simp_1_4 | Mathlib.Analysis.SpecificLimits.Basic | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | null | false |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.LinearIndependent.pair_add_smul_add_smul_iff_aux._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M},
LinearIndependent R ![x, y] = ∀ (s t : R), s • x + t • y = 0 → s = 0 ∧ t = 0 | null | false |
Std.Internal.ComputableSmall.mk | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
(Target : Type u) →
(deflate : α → Target) →
(inflate : Target → α) →
(∀ {a : Target}, deflate (inflate a) = a) →
(∀ {a : α}, inflate (deflate a) = a) → Std.Internal.ComputableSmall α | null | true |
NonnegSpectrumClass | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | (𝕜 : Type u_3) →
(A : Type u_4) →
[inst : CommSemiring 𝕜] → [PartialOrder 𝕜] → [inst_2 : NonUnitalRing A] → [PartialOrder A] → [Module 𝕜 A] → Prop | A class for `𝕜`-algebras with a partial order where the ordering is compatible with the
(quasi)spectrum. | true |
AddGroup.ofRightAxioms._proof_6 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Add G] [inst_1 : Neg G] [inst_2 : Zero G],
(∀ (a b c : G), a + b + c = a + (b + c)) → (∀ (a : G), a + 0 = a) → (∀ (a : G), a + -a = 0) → ∀ (a : G), -a + a = 0 | null | false |
Array.contains_flatten | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] {xs : Array (Array α)} {x : α}, xs.flatten.contains x = xs.any fun xs => xs.contains x | null | true |
RingCon.coe_one | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : MulOneClass R] (c : RingCon R), ↑1 = 1 | null | true |
Std.DHashMap.toListRev_keysIter | Std.Data.DHashMap.IteratorLemmas | ∀ {α : Type u} {β : α → Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α], m.keysIter.toListRev = m.keys.reverse | null | true |
CategoryTheory.Limits.pullbackRightPullbackFstIso_hom_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z) (f' : W ⟶ X)
[inst_1 : CategoryTheory.Limits.HasPullback f g]
[inst_2 : CategoryTheory.Limits.HasPullback f' (CategoryTheory.Limits.pullback.fst f g)],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullbackR... | null | true |
_private.Mathlib.CategoryTheory.Sites.Descent.DescentData.0.CategoryTheory.Pseudofunctor.DescentData.ofObj._proof_4 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} (Y' Y : C) (g : Y' ⟶ Y) (q : Y ⟶ S) (q' : Y' ⟶ S),
CategoryTheory.CategoryStruct.comp g q = q' →
∀ (i₁ : ι) (f₁ : Y ⟶ X i₁),
CategoryTheory.CategoryStruct.comp f₁ (f i₁) = q →
... | null | false |
_private.Mathlib.Probability.Process.LimitProcess.0.MeasureTheory.Filtration.memLp_limitProcess_of_eLpNorm_bdd._simp_1_4 | Mathlib.Probability.Process.LimitProcess | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
Matroid.loopyOn_ground | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} (E : Set α), (Matroid.loopyOn E).E = E | null | true |
Set.preimage_subtype_val_Icc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} [inst : Preorder α] {p : α → Prop} (a b : { x // p x }), Subtype.val ⁻¹' Set.Icc ↑a ↑b = Set.Icc a b | null | true |
LSeries.convolution_def | Mathlib.NumberTheory.LSeries.Convolution | ∀ {R : Type u_1} [inst : Semiring R] (f g : ℕ → R),
LSeries.convolution f g = fun n => ∑ p ∈ n.divisorsAntidiagonal, f p.1 * g p.2 | null | true |
Std.Http.Server.mk.sizeOf_spec | Std.Http.Server | ∀ (context : Std.CancellationContext) (activeConnections : Std.Mutex ℕ) (connectionLimit : Option Std.Semaphore)
(shutdownPromise : Std.Channel Unit) (config : Std.Http.Config) (localAddr : Option Std.Net.SocketAddress),
sizeOf
{ context := context, activeConnections := activeConnections, connectionLimit := c... | null | true |
LieModuleHom.map_lie' | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : LieRingModule L M] [inst_7 : LieRingModule L N] (self : M →ₗ⁅R,L⁆ N) {x : L} {m : M},
(↑self).toFun ⁅x, m⁆ = ⁅x,... | A module of Lie algebra modules is compatible with the action of the Lie algebra on the
modules. | true |
oscillationWithin | Mathlib.Analysis.Oscillation | {E : Type u} → {F : Type v} → [PseudoEMetricSpace F] → [TopologicalSpace E] → (E → F) → Set E → E → ENNReal | The oscillation of `f : E → F` within `D` at `x`. | true |
Finset.sum_schlomilch_le' | Mathlib.Analysis.PSeries | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [IsOrderedAddMonoid M] {f : ℕ → M} {u : ℕ → ℕ},
(∀ ⦃m n : ℕ⦄, 1 < m → m ≤ n → f n ≤ f m) →
(∀ (n : ℕ), 0 < u n) →
Monotone u →
∀ (n : ℕ), ∑ k ∈ Finset.range n, (u (k + 1) - u k) • f (u (k + 1)) ≤ ∑ k ∈ Finset.Ico (u 0 + 1) (u n + 1)... | null | true |
CategoryTheory.InjectiveResolution.definition._proof_1._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.EnoughInjectives C] (Z : C) (n : ℕ),
CategoryTheory.Injective ((CategoryTheory.InjectiveResolution.ofCocomplex Z).X n) | null | false |
summable_of_summable_hasFDerivAt_of_isPreconnected | Mathlib.Analysis.Calculus.SmoothSeries | ∀ {α : Type u_1} {𝕜 : Type u_2} {E : Type u_3} {F : Type u_4} [inst : NontriviallyNormedField 𝕜] [IsRCLikeNormedField 𝕜]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedAddCommGroup F] [CompleteSpace F]
{u : α → ℝ} [inst_6 : NormedSpace 𝕜 F] {f : α → E → F} {f' : α → E → E →L[𝕜] F} ... | Consider a series of functions `∑' n, f n x` on a preconnected open set. If the series converges
at a point, and all functions in the series are differentiable with a summable bound on the
derivatives, then the series converges everywhere on the set. | true |
Multiset.zero_le | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (s : Multiset α), 0 ≤ s | null | true |
_private.Init.PropLemmas.0.exists_prop_eq.match_1_1 | Init.PropLemmas | ∀ {α : Sort u_1} {a' : α} {p : (a : α) → a = a' → Prop} (motive : (∃ a, ∃ (h : a = a'), p a h) → Prop)
(x : ∃ a, ∃ (h : a = a'), p a h), (∀ (w : α) (e : w = a') (h : p w e), motive ⋯) → motive x | null | false |
ComplexShape.instTensorSignsNatDown._proof_4 | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ (p q r : ℕ), q + 1 = p → (ComplexShape.down ℕ).Rel (r + p) (r + q) | null | false |
Metric.sphere_isEmpty_of_subsingleton | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ} [Subsingleton α] [NeZero ε], IsEmpty ↑(Metric.sphere x ε) | null | true |
TopPair.Homotopy._sizeOf_1 | Mathlib.Topology.Category.TopPair | {X Y : TopPair} → {f g : X ⟶ Y} → TopPair.Homotopy f g → ℕ | null | false |
SimpleGraph.CliqueFree.eq_1 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G : SimpleGraph α) (n : ℕ), G.CliqueFree n = ∀ (t : Finset α), ¬G.IsNClique n t | null | true |
DirectSum.instNonUnitalNonAssocSemiring._proof_1 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : Add ι] [inst_2 : (i : ι) → AddCommMonoid (A i)]
[inst_3 : DirectSum.GNonUnitalNonAssocSemiring A] (x x_1 x_2 : DirectSum ι fun i => A i),
x * (x_1 + x_2) = x * x_1 + x * x_2 | null | false |
_private.Batteries.Lean.AttributeExtra.0.Lean.TagAttributeExtra.hasTag.match_1 | Batteries.Lean.AttributeExtra | (motive : Option Lean.ModuleIdx → Sort u_1) →
(x : Option Lean.ModuleIdx) → ((modIdx : Lean.ModuleIdx) → motive (some modIdx)) → (Unit → motive none) → motive x | null | false |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.Recv.recOn | Std.Http.Server.Connection | {β : Type} →
{motive : Std.Http.Server.Connection.Recv✝ β → Sort u} →
(t : Std.Http.Server.Connection.Recv✝ β) →
((x : Option ByteArray) → motive (Std.Http.Server.Connection.Recv.bytes✝ x)) →
((x : Option Std.Http.Chunk) → motive (Std.Http.Server.Connection.Recv.responseBody✝ x)) →
((x : B... | null | false |
Array.forIn'.eq_1 | Init.Data.List.ToArray | ∀ {α : Type u} {β : Type v} {m : Type v → Type w} [inst : Monad m] (as : Array α) (b : β)
(f : (a : α) → a ∈ as → β → m (ForInStep β)), as.forIn' b f = Array.forIn'.loop as f as.size ⋯ b | null | true |
Lean.Grind.Linarith.Poly.combine.match_1.congr_eq_1 | Init.Grind.Ordered.Linarith | ∀ (motive : Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Sort u_1) (p₁ p₂ : Lean.Grind.Linarith.Poly)
(h_1 : (p₂ : Lean.Grind.Linarith.Poly) → motive Lean.Grind.Linarith.Poly.nil p₂)
(h_2 : (p₁ : Lean.Grind.Linarith.Poly) → motive p₁ Lean.Grind.Linarith.Poly.nil)
(h_3 :
(a₁ : ℤ) →
(x₁ : Lean.Gr... | null | true |
selfAdjoint.isStarNormal | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalRing R] [inst_1 : StarRing R] (x : ↥(selfAdjoint R)), IsStarNormal ↑x | null | true |
SeparationQuotient.mkRingHom._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonAssocSemiring R], SeparationQuotient.mk 1 = 1 | null | false |
LocallyConstant.constₐ | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
(R : Type u_6) →
[inst_1 : CommSemiring R] → [inst_2 : Semiring Y] → [inst_3 : Algebra R Y] → Y →ₐ[R] LocallyConstant X Y | `LocallyConstant.const` as an `AlgHom` | true |
unexpandListCons | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | null | true |
Group.rank._proof_1 | Mathlib.GroupTheory.Rank | ∀ (G : Type u_1) [inst : Group G] [h : Group.FG G], ∃ n S, S.card = n ∧ Subgroup.closure ↑S = ⊤ | null | false |
Filter.Tendsto.atBot_of_isBoundedUnder_ge_add | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelAddMonoid M]
{l : Filter α} {f g : α → M},
Filter.IsBoundedUnder (fun x1 x2 => x1 ≥ x2) l f →
Filter.Tendsto (fun x => f x + g x) l Filter.atBot → Filter.Tendsto g l Filter.atBot | null | true |
_private.Mathlib.Combinatorics.Enumerative.InclusionExclusion.0.Finset.indicator_biUnion_eq_sum_powerset._simp_1_1 | Mathlib.Combinatorics.Enumerative.InclusionExclusion | ∀ {α : Type u_1} [inst : SubtractionMonoid α] {a : α}, (-a = 0) = (a = 0) | null | false |
ContinuousInf.measurableInf | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {γ : Type u_3} [inst : TopologicalSpace γ] {mγ : MeasurableSpace γ} [BorelSpace γ] [inst_2 : Min γ] [ContinuousInf γ],
MeasurableInf γ | null | true |
RootPairing.IsIrreducible.mk._flat_ctor | Mathlib.LinearAlgebra.RootSystem.Irreducible | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N},
Nontrivial M →
Nontrivial N →
(∀ (q : Submodule R M), (∀ (i : ι), q ∈ Module.End.invtSubmodule ↑(P.re... | null | false |
CategoryTheory.Abelian.linearExtFunctorObj._proof_6 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ (R : Type u_4) [inst : CommRing R] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] [inst_4 : CategoryTheory.HasExt C] (X : C)
(n : ℕ) {X_1 Y Z : C} (f : X_1 ⟶ Y) (g : Y ⟶ Z),
ModuleCat.ofHom ((CategoryTheory.Abelian.Ext.mk₀ ... | null | false |
Float.Model.UnpackedFloat.roundToInt.match_3 | Init.Data.Float.Model.Unpacked.Operations.ToNat | (motive : ℕ × ℤ → Sort u_1) → (x : ℕ × ℤ) → ((mantissa : ℕ) → (exponent : ℤ) → motive (mantissa, exponent)) → motive x | null | false |
Mathlib.Meta.NormNum.IsNatPowT.bit0 | Mathlib.Tactic.NormNum.Pow | ∀ {a b c : ℕ}, Mathlib.Meta.NormNum.IsNatPowT (a.pow b = c) a (2 * b) (c.mul c) | null | true |
_private.Init.Data.SInt.Package.0.instLinearOrderPackageInt32._proof_5 | Init.Data.SInt.Package | ∀ (a b : Int32), a ≤ b ∨ b ≤ a | null | false |
Nat.bit_false_zero | Mathlib.Data.Nat.Bits | Nat.bit false 0 = 0 | null | true |
Pi.nonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (a : (i : I) → f i), 0 + a = a | null | false |
IO.Process.run | Init.System.IO | IO.Process.SpawnArgs → optParam (Option String) none → IO String | Runs a process to completion, blocking until it terminates.
The child process is run with a null standard input or the specified input if provided,
If the child process terminates successfully with exit code 0, its standard output is returned.
An exception is thrown if it terminates with any other exit code.
The speci... | true |
SemidirectProduct.map._proof_1 | Mathlib.GroupTheory.SemidirectProduct | ∀ {N₁ : Type u_3} {G₁ : Type u_4} {N₂ : Type u_1} {G₂ : Type u_2} [inst : Group N₁] [inst_1 : Group G₁]
[inst_2 : Group N₂] [inst_3 : Group G₂] {φ₁ : G₁ →* MulAut N₁} {φ₂ : G₂ →* MulAut N₂} (fn : N₁ →* N₂) (fg : G₁ →* G₂),
⟨fn (SemidirectProduct.left 1), fg (SemidirectProduct.right 1)⟩ = 1 | null | false |
DifferentiableOn.finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i ... | null | true |
SSet.Edge.δ_zero_yonedaEquiv_symm | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {X : SSet} {x₀ x₁ : X.obj (Opposite.op { len := 0 })} (e : SSet.Edge x₀ x₁),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) (SSet.yonedaEquiv.symm e.edge) = SSet.yonedaEquiv.symm x₁ | null | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates.0.Tactic.ComputeAsymptotics.UnitMonomial.sign.match_1.splitter | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | (motive : Tactic.ComputeAsymptotics.UnitMonomial → Sort u_1) →
(x : Tactic.ComputeAsymptotics.UnitMonomial) →
(Unit → motive []) → ((hd : ℝ) → (tl : List ℝ) → motive (hd :: tl)) → motive x | null | true |
NFA.eval_append_singleton | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) (x : List α) (a : α), M.eval (x ++ [a]) = M.stepSet (M.eval x) a | null | true |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.linkN.match_1 | Batteries.Data.UnionFind.Basic | (self : Batteries.UnionFind) →
(motive : (n : ℕ) → n = self.size → Fin n → (y : Fin n) → self.parent ↑y = ↑y → Sort u_1) →
(n : ℕ) →
(h : n = self.size) →
(x y : Fin n) →
(yroot : self.parent ↑y = ↑y) →
((x y : Fin self.size) → (yroot : self.parent ↑y = ↑y) → motive self.size ⋯... | null | false |
MeasureTheory.StronglyMeasurable.const_add | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β] [inst_1 : Add β]
[ContinuousAdd β], MeasureTheory.StronglyMeasurable f → ∀ (c : β), MeasureTheory.StronglyMeasurable fun x => c + f x | null | true |
HasFPowerSeriesWithinOnBall.r_pos | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{p : FormalMultilinearSeries 𝕜 E F} {s : Set E} {x : E} {r : ENNReal}, HasFPowerSeriesWithinOnBall ... | The radius of convergence is positive | true |
IsCompact.binary_compact_cover | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R1Space X] {K U V : Set X},
IsCompact K → IsOpen U → IsOpen V → K ⊆ U ∪ V → ∃ K₁ K₂, IsCompact K₁ ∧ IsCompact K₂ ∧ K₁ ⊆ U ∧ K₂ ⊆ V ∧ K = K₁ ∪ K₂ | If a compact set is covered by two open sets, then we can cover it by two compact subsets. | true |
_private.Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf.0.CategoryTheory.Precoverage.SmallConstruction.Witness.below | Mathlib.CategoryTheory.Sites.Precoverage.Subsheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{K : CategoryTheory.Precoverage C} →
{ι : C → Type w} →
{motive : (a : C) → CategoryTheory.Precoverage.SmallConstruction.Witness✝ K ι a → Sort u_1} →
{a : C} → CategoryTheory.Precoverage.SmallConstruction.Witness✝ K ι a → Sort (max... | null | false |
PartialHomeomorph.source_inter_preimage_inv_preimage | Mathlib.Topology.PartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : PartialHomeomorph X Y)
(s : Set X), e.source ∩ ↑e ⁻¹' ↑e.symm ⁻¹' s = e.source ∩ s | null | true |
Real.log_of_pos | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {x : ℝ} (hx : 0 < x), Real.log x = Real.expOrderIso.symm ⟨x, hx⟩ | null | true |
IsDedekindDomain.instTopologicalSpaceFiniteAdeleRing | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | (R : Type u_1) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] → TopologicalSpace (IsDedekindDomain.FiniteAdeleRing R K) | null | true |
List.splitOnP_append_cons_of_forall_mem | Init.Data.List.SplitOn.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {xs : List α},
(∀ x ∈ xs, p x = false) →
∀ (sep : α), p sep = true → ∀ (as : List α), List.splitOnP p (xs ++ sep :: as) = xs :: List.splitOnP p as | When a list of the form `[...xs, sep, ...as]` is split on `p`, the first element is `xs`,
assuming no element in `xs` satisfies `p` but `sep` does satisfy `p` | true |
Lean.PrintImportResult.noConfusionType | Lean.Elab.ParseImportsFast | Sort u → Lean.PrintImportResult → Lean.PrintImportResult → Sort u | null | false |
Std.Async.BaseAsync.lift | Std.Async.Basic | {α : Type} → BaseIO α → Std.Async.BaseAsync α | Lifts a `BaseIO` action into a `BaseAsync` computation.
| true |
_private.Init.Data.List.Lex.0.List.le_iff_exists._simp_1_3 | Init.Data.List.Lex | ∀ {α : Sort u_2} {β : Sort u_1} {p : α → β → Prop}, (∃ a b, p a b) = ∃ b a, p a b | null | false |
Real.iInf_mul_of_nonpos | Mathlib.Basic.Real.Pointwise | ∀ {ι : Sort u_1} {r : ℝ}, r ≤ 0 → ∀ (f : ι → ℝ), (⨅ i, f i) * r = ⨆ i, f i * r | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.