name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
DiscreteMeasurableSpace.rec | Mathlib.MeasureTheory.MeasurableSpace.Defs | {α : Type u_6} →
[inst : MeasurableSpace α] →
{motive : DiscreteMeasurableSpace α → Sort u} →
((forall_measurableSet : ∀ (s : Set α), MeasurableSet s) → motive ⋯) → (t : DiscreteMeasurableSpace α) → motive t | null | false |
Lean.Grind.Nat.xor_congr | Init.Grind.Lemmas | ∀ {a b k₁ k₂ k : ℕ}, a = k₁ → b = k₂ → (k == k₁ ^^^ k₂) = true → a ^^^ b = k | null | true |
Ideal.Cotangent.lift.congr_simp | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u} [inst : CommRing R] {S : Type u_3} [inst_1 : CommRing S] [inst_2 : Algebra R S] {I : Ideal S}
{M : Type u_4} [inst_3 : AddCommGroup M] [inst_4 : Module R M] (f f_1 : ↥I →ₗ[R] M) (e_f : f = f_1)
(hf : ∀ (x y : ↥I), f (x * y) = 0), Ideal.Cotangent.lift f hf = Ideal.Cotangent.lift f_1 ⋯ | null | true |
ClosedSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [Group G] → [TopologicalSpace G] → Type u | The type of closed subgroups of a topological group. | true |
instHashableUInt8 | Init.Data.Hashable | Hashable UInt8 | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_278 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
CochainComplex.Plus.quasiIso.congr_simp | Mathlib.Algebra.Homology.CochainComplexPlus | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.CategoryWithHomology C] ⦃X Y : CochainComplex.Plus C⦄ (x x_1 : X ⟶ Y),
x = x_1 → CochainComplex.Plus.quasiIso C x = CochainComplex.Plus.quasiIso C x_1 | null | true |
Std.WP.WP.wp_econs_bot | Std.WP.Basic | ∀ {Pred : Type u_1} {EPred : Type u_2} {Prog : Type u} {Value : Type v} [inst : Std.WP.Assertion Pred]
[inst_1 : Std.WP.Assertion EPred] [inst_2 : Std.WP.WP Prog Value Pred EPred] (x : Prog) (post : Value → Pred)
(epost : EPred), Lean.Order.PartialOrder.rel (Std.WP.wp x post Lean.Order.bot) (Std.WP.wp x post epost) | null | true |
Aesop.RulePatternCache.noConfusion | Aesop.RulePattern.Cache | {P : Sort u} → {t t' : Aesop.RulePatternCache} → t = t' → Aesop.RulePatternCache.noConfusionType P t t' | null | false |
String.Slice.Pos.offset | Init.Data.String.Defs | {s : String.Slice} → s.Pos → String.Pos.Raw | The underlying byte offset of the `Slice.Pos`. | true |
AddMonoidAlgebra.coeff_toMultiplicative_apply | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_3) (M : Type u_6) [inst : Semiring R] [inst_1 : Add M] (x : AddMonoidAlgebra R M),
((AddMonoidAlgebra.toMultiplicative R M) x).coeff = Finsupp.mapDomain (⇑Multiplicative.ofAdd) x.coeff | null | true |
Fin2.toFin_fs | Mathlib.Data.Fin.Fin2 | ∀ {n : ℕ} (i : Fin2 n), i.fs.toFin = i.toFin.succ | null | true |
MonCat.Hom._mkInternal | Mathlib.Algebra.Category.MonCat.Basic | {A B : MonCat} → (↑A →* ↑B) → A.Hom B | null | false |
Lean.Grind._simp_5 | Init.Grind.Norm | ∀ {n : ℤ}, (0 ∣ n) = (n = 0) | null | false |
Finsupp.mapDomain_injOn | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (S : Set α) {f : α → β},
Set.InjOn f S → Set.InjOn (Finsupp.mapDomain f) {w | ↑w.support ⊆ S} | null | true |
CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding_obj | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] (P : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C)),
(CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C).obj P =
CategoryTheory.Idempotents.KaroubiFunctorC... | null | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.termS_ | Mathlib.GroupTheory.Coxeter.Inversion | Lean.ParserDescr | null | true |
MvPolynomial.weightedHomogeneousComponent._proof_1 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
Lean.Linter.CodeQuality.Value.noConfusion | Lean.Linter.CodeQuality.Basic | {P : Sort u} → {t t' : Lean.Linter.CodeQuality.Value} → t = t' → Lean.Linter.CodeQuality.Value.noConfusionType P t t' | null | false |
CategoryTheory.AddMon.trivial_addMon_add | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMonObj.add =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom | null | true |
Lean.Elab.InfoTree._sizeOf_6_eq | Lean.Elab.InfoTree.Types | ∀ (x : List Lean.Elab.InfoTree), Lean.Elab.InfoTree._sizeOf_6 x = sizeOf x | null | false |
groupHomology.mapCycles₂_comp_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u} [inst : CommRing k] {G H K : Type u} [inst_1 : Group G] [inst_2 : Group H] [inst_3 : Group K]
{A : Rep.{u, u, u} k G} {B : Rep.{u, u, u} k H} {C : Rep.{u, u, u} k K} (f : G →* H) (g : H →* K)
(φ : A ⟶ Rep.res f B) (ψ : B ⟶ Rep.res g C) (x : ↥(groupHomology.cycles₂ A)),
(CategoryTheory.ConcreteCateg... | null | true |
Field.isSeparable_sub | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {x y : E},
IsSeparable F x → IsSeparable F y → IsSeparable F (x - y) | If `x` and `y` are both separable elements, then `x - y` is also a separable element. | true |
WithZero.instGroupWithZero._proof_5 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Group α] (n : ℕ) (a : WithZero α), a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹ | null | false |
WellFounded.prod_gameAdd | Mathlib.Order.GameAdd | ∀ {α : Type u_1} {β : Type u_2} {rα : α → α → Prop} {rβ : β → β → Prop},
WellFounded rα → WellFounded rβ → WellFounded (Prod.GameAdd rα rβ) | The `Prod.GameAdd` relation on well-founded inputs is well-founded.
In particular, the sum of two well-founded games is well-founded. | true |
Units.mul_inv' | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] (u : G₀ˣ), ↑u * (↑u)⁻¹ = 1 | null | true |
Lean.Elab.Tactic.Grind.Cache.dsimpState._default | Lean.Elab.Tactic.Grind.Basic | Std.HashMap Lean.Elab.Tactic.Grind.DSimpCacheKey Lean.Meta.Sym.DSimp.State | null | false |
Lean.Doc.Block.ctorElimType | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
ℕ → Sort (max 1 u_1 (imax (u + 1) u_1) (imax (v + 1) (max (u + 1) (v + 1)) u_1) (imax (max (u + 1) (v + 1)) u_1)) | null | false |
sSupIndep.disjoint_sSup | Mathlib.Order.SupIndep | ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α},
sSupIndep s → ∀ {x : α} {y : Set α}, x ∈ s → y ⊆ s → x ∉ y → Disjoint x (sSup y) | If the elements of a set are independent, then any element is disjoint from the `sSup` of some
subset of the rest. | true |
Lean.getPPProofsThreshold | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → ℕ | null | true |
CategoryTheory.DifferentialObject.hasZeroMorphisms._proof_4 | Mathlib.CategoryTheory.DifferentialObject | ∀ {S : Type u_3} [inst : AddMonoidWithOne S] {C : Type u_2} [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.HasShift C S]
[inst_4 : (CategoryTheory.shiftFunctor C 1).PreservesZeroMorphisms] (X : CategoryTheory.DifferentialObject S C)
{Y ... | null | false |
Module.End.instDivisionRing._proof_7 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Module.End R M)] [inst_4 : IsSimpleModule R M] (q : ℚ), ↑q = ↑q.num / ↑q.den | null | false |
Lean.Meta.Rewrite.Config.transparency | Init.Meta.Defs | Lean.Meta.Rewrite.Config → Lean.Meta.TransparencyMode | The transparency mode to use for unfolding | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Independent.0.AffineIndependent.vectorSpan_image_ne_of_mem_of_notMem_of_not_subsingleton._proof_1_4 | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {ι : Type u_1} {s₂ : Set ι} {i : ι} (j : ι) (fs : Finset ↑s₂),
j ∈ insert i (insert j (Finset.map (Function.Embedding.subtype fun x => x ∈ s₂) fs)) | null | false |
Set.countable_isTop | Mathlib.Data.Set.Countable | ∀ (α : Type u_1) [inst : PartialOrder α], {x | IsTop x}.Countable | null | true |
HomogeneousLocalization.Away.val_mk._proof_1 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {A : Type u_1} [inst : CommRing A] {f : A} (n : ℕ), f ^ n ∈ Submonoid.powers f | null | false |
CategoryTheory.Limits.BinaryBiconeMorphism.mk.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} {A B : CategoryTheory.Limits.BinaryBicone P Q} (hom hom_1 : A.pt ⟶ B.pt) (e_hom : hom = hom_1)
(wfst : CategoryTheory.CategoryStruct.comp hom B.fst = A.fst)
(wsnd : CategoryTheory.CategoryStr... | null | true |
CategoryTheory.Limits.DiagramOfCones.noConfusion | Mathlib.CategoryTheory.Limits.Fubini | {P : Sort u} →
{J : Type u_1} →
{K : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} J} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} K} →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
{F : CategoryTheory.Functor J (CategoryTheory.Func... | null | false |
RootPairing.Hom.mk._flat_ctor | Mathlib.LinearAlgebra.RootSystem.Hom | {ι : 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] →
{ι₂ : Type u_5} →
... | null | false |
Set.Finite.iSup_biInf_of_monotone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsDirectedOrder ι']
[inst_3 : Order.Frame α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Monotone (f i)) → ⨆ j, ⨅ i ∈ s, f i j = ⨅ i ∈ s, ⨆ j, f i j | null | true |
Std.DTreeMap.Internal.Impl.insertMax!._f | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
(k : α) →
β k → (t : Std.DTreeMap.Internal.Impl α β) → Std.DTreeMap.Internal.Impl.below t → Std.DTreeMap.Internal.Impl α β | null | false |
Lean.Parser.errorAtSavedPos | Lean.Parser.Basic | String → Bool → Lean.Parser.Parser | Generate an error at the position saved with the `withPosition` combinator.
If `delta == true`, then it reports at saved position+1.
This useful to make sure a parser consumed at least one character. | true |
Std.ExtDHashMap.Const.get_map' | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : α → β → γ} {k : α} {h' : k ∈ Std.ExtDHashMap.map f m},
Std.ExtDHashMap.Const.get (Std.ExtDHashMap.map f m) k h' = f (m.getKey k ⋯) (Std.ExtDHashMap.Const.ge... | Variant of `get_map` that holds with `EquivBEq` (i.e. without `LawfulBEq`). | true |
emultiplicity_zero_eq_zero_of_ne_zero | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : MonoidWithZero α] (a : α), a ≠ 0 → emultiplicity 0 a = 0 | null | true |
AEMeasurable.add' | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : MeasurableSpace M] [inst_1 : Add M] {m : MeasurableSpace α} {f g : α → M}
{μ : MeasureTheory.Measure α} [MeasurableAdd₂ M], AEMeasurable f μ → AEMeasurable g μ → AEMeasurable (f + g) μ | **Alias** of `AEMeasurable.add`. | true |
MeasurableEq.recOn | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {α : Type u_1} →
[inst : MeasurableSpace α] →
{motive : MeasurableEq α → Sort u} →
(t : MeasurableEq α) → ((measurableSet_diagonal : MeasurableSet (Set.diagonal α)) → motive ⋯) → motive t | null | false |
Lex.instNonUnitalSemiring._proof_1 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (a b c : Lex R), a * b * c = a * (b * c) | null | false |
_private.Lean.Util.CollectAxioms.0.Lean.ExportedAxiomsState.importedModuleEntries._default | Lean.Util.CollectAxioms | Array (Array (Lean.Name × Array Lean.Name)) | null | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Add.0.differentiableWithinAt_comp_sub._simp_1_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {s : Set E} (a : E),
HasFDerivWithinAt (fun x => f (x - a)) f' s x = Has... | null | false |
lt_or_eq_or_gt_or_incompRel | Mathlib.Order.Comparable | ∀ {α : Type u_1} [inst : PartialOrder α] (a b : α), a < b ∨ a = b ∨ b < a ∨ IncompRel (fun x1 x2 => x1 ≤ x2) a b | Exactly one of the following is true. | true |
_private.Lean.Environment.0.Lean.Environment.hasUnsafe.match_1 | Lean.Environment | (motive : Option Lean.AsyncConstantInfo → Sort u_1) →
(x : Option Lean.AsyncConstantInfo) →
((cinfo : Lean.AsyncConstantInfo) → motive (some cinfo)) → (Unit → motive none) → motive x | null | false |
Nat.toArray_rcc_eq_singleton_append_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {xs : Array ℕ} {m n a : ℕ}, (m...=n).toArray = #[a] ++ xs ↔ m = a ∧ m ≤ n ∧ (m + 1...=n).toArray = xs | null | true |
QuadraticForm.equivalent_weightedSumSquares | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {K : Type u_3} {V : Type u_8} [inst : Field K] [Invertible 2] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[FiniteDimensional K V] (Q : QuadraticForm K V), ∃ w, QuadraticMap.Equivalent Q (QuadraticMap.weightedSumSquares K w) | null | true |
List.mapAccumr_eq_foldr._f | Mathlib.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} (f : α → σ → σ × β) (x : List α)
(f_1 :
List.below (motive := fun x =>
∀ (x_1 : σ),
List.mapAccumr f x x_1 =
List.foldr
(fun a s =>
have r := f a s.1;
(r.1, r.2 :: s.2))
(x_1, []) x)
x)... | null | false |
EuclideanGeometry.angle_le_pi_div_three_of_le_of_le | Mathlib.Geometry.Euclidean.Triangle | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {p₁ p₂ p₃ : P},
EuclideanGeometry.angle p₁ p₂ p₃ ≤ EuclideanGeometry.angle p₂ p₃ p₁ →
EuclideanGeometry.angle p₁ p₂ p₃ ≤ EuclideanGeometry.angle p₃ p₁ p₂ →
... | The least angle of a possibly degenerate triangle is at most `π / 3`, unless all three vertices
are equal. | true |
Module.nonempty_linearEquiv_of_finrank_eq_one | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M]
[StrongRankCondition R], Module.finrank R M = 1 → Nonempty (R ≃ₗ[R] M) | **Alias** of the reverse direction of `Module.nonempty_linearEquiv_iff_finrank_eq_one`.
---
See also `finrank_eq_one_iff` | true |
infIooOrderIsoIooSup._proof_4 | Mathlib.Order.ModularLattice | ∀ {α : Type u_1} [inst : Lattice α] [IsModularLattice α] (a b : α) (c : ↑(Set.Ioo b (a ⊔ b))),
a ⊓ b < a ⊓ ↑c ∧ a ⊓ ↑c < a | null | false |
FractionalIdeal.spanSingleton_eq_spanSingleton | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] [IsDomain R] [Module.IsTorsionFree R P] {x y : P},
(FractionalIdeal.spanSingleton S) x = (FractionalIdeal.spanSingleton S) y ↔ ∃ z, z • x = y | null | true |
Nat.card_image_of_injective | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → ∀ (s : Set α), Nat.card ↑(f '' s) = Nat.card ↑s | null | true |
Polynomial.normUnit_content | Mathlib.RingTheory.Polynomial.Content | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] {p : Polynomial R}, normUnit p.content = 1 | null | true |
SubAddAction.val_vadd_of_tower._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {S : Type u'} {R : Type u} {M : Type v} [inst : AddMonoid R] [inst_1 : AddAction R M] [inst_2 : VAdd S R]
[inst_3 : VAdd S M] [inst_4 : VAddAssocClass S R M] (p : SubAddAction R M) (s : S) (x : ↥p), s +ᵥ ↑x = ↑(s +ᵥ x) | null | false |
Lean.Lsp.OpenNamespace.renamed.noConfusion | Lean.Data.Lsp.Internal | {P : Sort u} →
{«from» «to» from' to' : Lean.Name} →
Lean.Lsp.OpenNamespace.renamed «from» «to» = Lean.Lsp.OpenNamespace.renamed from' to' →
(«from» = from' → «to» = to' → P) → P | null | false |
ISize.cast_toNatClampNeg | Init.Data.SInt.Lemmas | ∀ (x : ISize), 0 ≤ x → ↑x.toNatClampNeg = x.toInt | null | true |
Equiv.constSMul | Mathlib.Algebra.Torsor.Defs | {G : Type u_1} → (P : Type u_2) → [inst : Group G] → [Torsor G P] → G → Equiv.Perm P | The permutation given by `p ↦ v • p`. | true |
Int.negOnePow_def | Mathlib.Algebra.Ring.NegOnePow | ∀ (n : ℤ), n.negOnePow = (-1) ^ n | null | true |
Lean.Elab.Command.Context.currRecDepth | Lean.Elab.Command | Lean.Elab.Command.Context → ℕ | null | true |
pi_norm_lt_iff' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_5} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedGroup (G i)] {x : (i : ι) → G i}
{r : ℝ}, 0 < r → (‖x‖ < r ↔ ∀ (i : ι), ‖x i‖ < r) | The seminorm of an element in a product space is `< r` if and only if the norm of each
component is. | true |
CategoryTheory.Limits.Types.binaryProductCone_pt | Mathlib.CategoryTheory.Limits.Types.Products | ∀ (X Y : Type u), (CategoryTheory.Limits.Types.binaryProductCone X Y).pt = (X × Y) | null | true |
_private.Mathlib.Util.Delaborators.0.exists_delab.match_5 | Mathlib.Util.Delaborators | (motive : Array Lean.Expr → Sort u_1) →
(x : Array Lean.Expr) → ((ι f : Lean.Expr) → motive #[ι, f]) → ((x : Array Lean.Expr) → motive x) → motive x | null | false |
CategoryTheory.Limits.Pi.map'_comp_π_assoc | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f : α → C} {g : β → C}
[inst_1 : CategoryTheory.Limits.HasProduct f] [inst_2 : CategoryTheory.Limits.HasProduct g] (p : β → α)
(q : (b : β) → f (p b) ⟶ g b) (b : β) {Z : C} (h : g b ⟶ Z),
CategoryTheory.CategoryStruct.comp (Categ... | null | true |
IsUnit.div_self | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : DivisionMonoid α] {a : α}, IsUnit a → a / a = 1 | null | true |
MulOpposite.opHomeomorph_symm_apply | Mathlib.Topology.Algebra.Constructions | ∀ {M : Type u_1} [inst : TopologicalSpace M] (a : Mᵐᵒᵖ), MulOpposite.opHomeomorph.symm a = MulOpposite.unop a | null | true |
UniformFun.instMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : MetricSpace β] [inst_1 : BoundedSpace β], T0Space (UniformFun α β) | null | false |
PFunctor.Approx.CofixA.intro | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → {n : ℕ} → (a : F.A) → (F.B a → PFunctor.Approx.CofixA F n) → PFunctor.Approx.CofixA F n.succ | null | true |
Dyadic.instOrderedRing | Init.Data.Dyadic.Instances | Lean.Grind.OrderedRing Dyadic | null | true |
Std.Http.Server.serveConnection | Std.Http.Server.Connection | {t σ : Type} →
[Std.Http.Transport t] →
[Std.Http.Server.Handler σ] →
t → σ → Std.Http.Config → optParam Std.Http.Extensions Std.Http.Extensions.empty → Std.Async.ContextAsync Unit | Handles request/response processing for a single connection using an `Async` handler.
The library-level entry point for running a server is `Server.serve`.
This function can be used with a `TCP.Socket` or any other type that implements
`Transport` to build custom server loops.
# Example
```lean
-- Create a TCP socket... | true |
oneLePart_inf_leOnePart_eq_one | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] [MulLeftMono α] [MulRightMono α] (a : α), a⁺ᵐ ⊓ a⁻ᵐ = 1 | null | true |
Submodule.Quotient.seminormedAddCommGroup | Mathlib.Analysis.Normed.Group.Quotient | {M : Type u_1} →
[inst : SeminormedAddCommGroup M] →
{R : Type u_3} → [inst_1 : Ring R] → [inst_2 : Module R M] → (S : Submodule R M) → SeminormedAddCommGroup (M ⧸ S) | null | true |
Polynomial.Chebyshev.iterate_derivative_T_eval_zero_recurrence | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {R : Type u_1} [inst : CommRing R] (n : ℤ) (k : ℕ),
Polynomial.eval 0 ((⇑Polynomial.derivative)^[k + 2] (Polynomial.Chebyshev.T R n)) =
-(↑n ^ 2 - ↑k ^ 2) * Polynomial.eval 0 ((⇑Polynomial.derivative)^[k] (Polynomial.Chebyshev.T R n)) | null | true |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality.0.groupCohomology.cocyclesMap_comp._simp_1_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {K L M : HomologicalComplex C c} (φ : K ⟶ L) (ψ : L ⟶ M) (i : ι)
[inst_2 : K.HasHomology i] [inst_3 : L.HasHomology i] [inst_4 : M.HasHomology i],
CategoryTheory.C... | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin._proof_26 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (l : ℕ) (r r' a : ℤ) (a' : ℕ) (isLt : a' < l) (b : ℤ) (b' : ℕ) (isLt_1 : b' < l),
(a, ⟨a', isLt⟩).1 + (r, 1 - r).1 = (b, ⟨b', isLt_1⟩).1 →
↑↑(a, ⟨a', isLt⟩).2 + (r, 1 - r).2 = ↑↑(b, ⟨b', isLt_1⟩).2 →
autoParam (r + 1 = r') CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_47 →
m... | null | false |
CategoryTheory.CanonicallyOverClass.mk | Mathlib.CategoryTheory.Comma.Over.OverClass | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
{S : semiOutParam C} → [toOverClass : CategoryTheory.OverClass X S] → CategoryTheory.CanonicallyOverClass X S | null | true |
MeasureTheory.instIsAddRightInvariantHausdorffMeasureOfIsIsometricVAddAddOpposite | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {d : ℝ}
[inst_3 : AddGroup X] [IsIsometricVAdd Xᵃᵒᵖ X], (MeasureTheory.Measure.hausdorffMeasure d).IsAddRightInvariant | null | true |
Lean.Grind.CommRing.Poly.addConst_k_eq_addConst | Init.Grind.Ring.CommSolver | ∀ (p : Lean.Grind.CommRing.Poly) (k : ℤ), p.addConst_k k = p.addConst k | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache_Inv_of_Inv._mutual | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment}
(x :
(aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) ×'
(w : ℕ) ×'
(cache : Std.Tactic.BVDecide.BVExpr.Cache aig) ×'
(_ : Std.Tactic.BVDecide.BVExpr.Cache.Inv assign aig cache) ×' Std.Tactic.BVDecide.BVExpr w ⊕'
(w : ℕ) ×'
... | null | false |
_private.Lean.Meta.Tactic.LibrarySearch.0.Lean.Meta.LibrarySearch.ext | Lean.Meta.Tactic.LibrarySearch | IO.Ref (Option (Lean.Meta.LazyDiscrTree (Lean.Name × Lean.Meta.LibrarySearch.DeclMod))) | Process-global cache for the imported-declarations discrimination tree. This must *not* live in
an environment extension: the snapshot used by `--incr-load` compacts the whole environment object
(including non-persistent extension state), and a mutable `IO.Ref` baked into the read-only mapped
region is unsound to read ... | true |
Fin.map_valEmbedding_univ | Mathlib.Data.Fintype.Fin | ∀ {n : ℕ}, Finset.map Fin.valEmbedding Finset.univ = Finset.Iio n | null | true |
Nat.ascFactorialBinary._unary | Mathlib.Data.Nat.Factorial.Basic | (_ : ℕ) ×' ℕ → ℕ | `ascFactorial` implemented using binary splitting.
While this still performs the same number of multiplications,
the big-integer operands to each are much smaller. | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.evalComp.match_1.splitter | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (motive : Mathlib.Tactic.BicategoryLike.Eval.Result → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.Eval.Result) →
((ι : Mathlib.Tactic.BicategoryLike.NormalExpr) → (e_ι : Lean.Expr) → motive { expr := ι, proof := e_ι }) → motive x | null | true |
_private.Lean.Environment.0.Lean.EnvExtension.ensureExtensionsArraySize.loop | Lean.Environment | ℕ → Array Lean.EnvExtensionState → IO (Array Lean.EnvExtensionState) | null | true |
Real.differentiableAt_mulExpNegMulSq | Mathlib.Analysis.SpecialFunctions.MulExpNegMulSq | ∀ {ε : ℝ} (y : ℝ), DifferentiableAt ℝ ε.mulExpNegMulSq y | null | true |
Lean.Meta.Simp.ConfigCtx.etaStruct._inherited_default | Init.MetaTypes | Lean.Meta.EtaStructMode | null | false |
_private.Mathlib.RingTheory.Perfectoid.BDeRham.0.term𝕎_ | Mathlib.RingTheory.Perfectoid.BDeRham | Lean.ParserDescr | null | true |
CoxeterMatrix.Group | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} → CoxeterMatrix B → Type u_1 | The Coxeter group associated to a Coxeter matrix $M$; that is, the group
$$\langle \{s_i\}_{i \in B} \vert \{(s_i s_{i'})^{M_{i, i'}}\}_{i, i' \in B} \rangle.$$ | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.boundedSpace_iff_edist._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α], BoundedSpace α = ∃ C, ∀ (a b : α), nndist a b ≤ C | null | false |
CategoryTheory.Sheaf.H.longSequence_exact₂'._proof_5 | Mathlib.CategoryTheory.Sites.SheafCohomology.ExactSequences | 0 + 2 ≤ 5 | null | false |
FractionalIdeal.coe_inv_of_ne_zero | Mathlib.RingTheory.FractionalIdeal.Inverse | ∀ (K : Type u_1) [inst : Field K] {R₁ : Type u_2} [inst_1 : CommRing R₁] [inst_2 : IsDomain R₁] [inst_3 : Algebra R₁ K]
[inst_4 : IsFractionRing R₁ K] {J : FractionalIdeal (nonZeroDivisors R₁) K},
J ≠ 0 → ↑J⁻¹ = IsLocalization.coeSubmodule K ⊤ / ↑J | null | true |
RootPairing.Equiv.weightEquiv_comp_toLin | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : 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} (x y : P.Equiv P),
(x.comp y).weightEquiv = y.weightEquiv ≪≫ₗ x.weightEquiv | null | true |
SchwartzMap.convolution._proof_5 | Mathlib.Analysis.Fourier.Convolution | ∀ {𝕜 : Type u_1} {F₃ : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F₃] [inst_2 : NormedSpace 𝕜 F₃],
SMulCommClass 𝕜 𝕜 F₃ | null | false |
Finset.aestronglyMeasurable_prod | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {M : Type u_5} [inst : CommMonoid M]
[inst_1 : TopologicalSpace M] [ContinuousMul M] {ι : Type u_6} {f : ι → α → M} (s : Finset ι),
(∀ i ∈ s, MeasureTheory.AEStronglyMeasurable (f i) μ) → MeasureTheory.AEStronglyMeasurable (∏ i ∈ s, f i) μ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.