name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.numbering.go | Lean.DocString.Parser | List Lean.Doc.Parser.OrderedListType → Lean.Parser.ParserFn | null | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.get.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] (a : α) (x : Std.DHashMap.Internal.AssocList α fun x => β)
(x_1 : Std.DHashMap.Internal.AssocList.contains a x = true),
Std.DHashMap.Internal.AssocList.get a x x_1 =
match x, x_1 with
| Std.DHashMap.Internal.AssocList.cons k v es, h =>
if hka : (k == a) = tru... | null | true |
OpenPartialHomeomorph.lift_openEmbedding_trans_apply | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_7} {X' : Type u_8} {Z : Type u_9} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace X']
[inst_2 : TopologicalSpace Z] [inst_3 : Nonempty Z] {f : X → X'} (e e' : OpenPartialHomeomorph X Z)
(hf : Topology.IsOpenEmbedding f) (z : Z),
↑((e.lift_openEmbedding hf).symm.trans (e'.lift_openEmbedding hf... | null | true |
Lean.Lsp.ClientInfo.mk._flat_ctor | Lean.Data.Lsp.InitShutdown | String → Option String → Lean.Lsp.ClientInfo | null | false |
Orientation.inner_rightAngleRotation_right | Mathlib.Analysis.InnerProductSpace.TwoDim | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : Fact (Module.finrank ℝ E = 2)]
(o : Orientation ℝ E (Fin 2)) (x y : E), inner ℝ x (o.rightAngleRotation y) = -(o.areaForm x) y | null | true |
AlgebraicGeometry.Scheme.Pullback.t'_fst_fst_snd_assoc | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j k : 𝒰.I₀) {Z_1 : AlgebraicGeometry.Scheme} (h : Y ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.P... | null | true |
mem_generatePiSystem_iUnion_elim' | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_3} {β : Type u_4} {g : β → Set (Set α)} {s : Set β},
(∀ b ∈ s, IsPiSystem (g b)) →
∀ t ∈ generatePiSystem (⋃ b ∈ s, g b), ∃ T f, ↑T ⊆ s ∧ t = ⋂ b ∈ T, f b ∧ ∀ b ∈ T, f b ∈ g b | Every element of the π-system generated by an indexed union of a family of π-systems
is a finite intersection of elements from the π-systems.
For a total union version, see `mem_generatePiSystem_iUnion_elim`. | true |
_private.Mathlib.RingTheory.Valuation.LocalSubring.0.LocalSubring.exists_le_valuationSubring_of_isIntegrallyClosedIn.match_1_1 | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_1} [inst : Field K] {x : K} {R : LocalSubring K} (this : Invertible x)
(motive : (∃ p, p.leadingCoeff - 1 ∈ IsLocalRing.maximalIdeal ↥R.toSubring ∧ (Polynomial.aeval ⅟x⁻¹) p = 0) → Prop)
(x_1 : ∃ p, p.leadingCoeff - 1 ∈ IsLocalRing.maximalIdeal ↥R.toSubring ∧ (Polynomial.aeval ⅟x⁻¹) p = 0),
(∀ (p : ... | null | false |
CategoryTheory.Localization.lift₄NatIso._proof_4 | Mathlib.CategoryTheory.Localization.Quadrifunctor | ∀ {C₁ : Type u_12} {C₂ : Type u_14} {C₃ : Type u_16} {C₄ : Type u_18} {D₁ : Type u_1} {D₂ : Type u_2} {D₃ : Type u_3}
{D₄ : Type u_4} {E : Type u_6} [inst : CategoryTheory.Category.{u_11, u_12} C₁]
[inst_1 : CategoryTheory.Category.{u_13, u_14} C₂] [inst_2 : CategoryTheory.Category.{u_15, u_16} C₃]
[inst_3 : Cate... | null | false |
_private.Mathlib.Data.Set.Image.0.Set.Nonempty.preimage.match_1_3 | Mathlib.Data.Set.Image | ∀ {β : Type u_1} {s : Set β} (motive : s.Nonempty → Prop) (hs : s.Nonempty),
(∀ (y : β) (hy : y ∈ s), motive ⋯) → motive hs | null | false |
Fin.hIterateFrom.congr_simp | Init.Data.Fin.Iterate | ∀ (P : ℕ → Sort u_1) {n : ℕ} (f f_1 : (i : Fin n) → P ↑i → P (↑i + 1)),
f = f_1 →
∀ (i : ℕ) (ubnd : i ≤ n) (a a_1 : P i), a = a_1 → Fin.hIterateFrom P f i ubnd a = Fin.hIterateFrom P f_1 i ubnd a_1 | null | true |
MonoidAlgebra.coeff_mul_single_eq_coeff_mul | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {x : MonoidAlgebra R M} {r : R} {m m₁ : M} [inst_1 : Mul M]
(m₂ : M), (∀ m' ∈ x.coeff.support, m' * m = m₁ ↔ m' = m₂) → (x * MonoidAlgebra.single m r).coeff m₁ = x.coeff m₂ * r | null | true |
MeasureTheory.Measure.InnerRegularWRT.measure_eq_iSup | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop} {U : Set α},
μ.InnerRegularWRT p q → q U → μ U = ⨆ K, ⨆ (_ : K ⊆ U), ⨆ (_ : p K), μ K | null | true |
AffineSubspace.subtypeₐᵢ | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{P : Type u_7} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : NormedAddTorsor V P] → (s : AffineSubspace 𝕜 P) → [inst_5 : Nonempty ↥s] →... | `AffineSubspace.subtype` as an `AffineIsometry`. | true |
QuotientAddGroup.equivIocMod | Mathlib.Algebra.Order.ToIntervalMod | {α : Type u_1} →
[inst : AddCommGroup α] →
[inst_1 : LinearOrder α] →
[IsOrderedAddMonoid α] →
[hα : Archimedean α] → {p : α} → 0 < p → (a : α) → α ⧸ AddSubgroup.zmultiples p ≃ ↑(Set.Ioc a (a + p)) | `toIocMod` as an equiv from the quotient. | true |
CategoryTheory.ChosenPullbacksAlong.hasPullbacks | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.ChosenPullbacks C],
CategoryTheory.Limits.HasPullbacks C | null | true |
PNat.XgcdType.flip_a | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.a = u.b | null | true |
Lean.Meta.Grind.EMatch.State.thms | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.EMatch.State → Lean.PArray Lean.Meta.Grind.EMatchTheorem | Active theorems that we have performed ematching at least once. | true |
mfderivWithin_projIcc_one | Mathlib.Geometry.Manifold.Instances.Icc | ∀ {x y : ℝ} [h : Fact (x < y)] {z : ℝ}, z ∈ Set.Icc x y → (mfderiv[Set.Icc x y] (Set.projIcc x y ⋯) z) 1 = 1 | null | true |
Homotopy.ofEq | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} → {C D : HomologicalComplex V c} → {f g : C ⟶ D} → f = g → Homotopy f g | Equal chain maps are homotopic. | true |
Lean.Lsp.Range.mk.inj | Lean.Data.Lsp.BasicAux | ∀ {start «end» start_1 end_1 : Lean.Lsp.Position},
{ start := start, «end» := «end» } = { start := start_1, «end» := end_1 } → start = start_1 ∧ «end» = end_1 | null | true |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.ascFactorial_le._proof_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), n + k ≤ m + k | null | false |
ContinuousLinearEquiv.arrowCongrSL._proof_2 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_7} {𝕜₃ : Type u_8} {𝕜₄ : Type u_2} {E : Type u_3} {F : Type u_6} {G : Type u_5}
{H : Type u_4} [inst : AddCommGroup E] [inst_1 : AddCommGroup F] [inst_2 : AddCommGroup G] [inst_3 : AddCommGroup H]
[inst_4 : NormedField 𝕜] [inst_5 : NormedField 𝕜₂] [inst_6 : NormedField 𝕜₃] [inst... | null | false |
T25Space.t2Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T25Space X], T2Space X | null | true |
Lean.Lsp.WorkDoneProgressParams.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.WorkDoneProgressParams → Sort u} →
(t : Lean.Lsp.WorkDoneProgressParams) →
((workDoneToken? : Option Lean.Lsp.ProgressToken) → motive { workDoneToken? := workDoneToken? }) → motive t | null | false |
Std.Http.URI.Path.join | Std.Http.Data.URI.Basic | Std.Http.URI.Path → Std.Http.URI.Path → Std.Http.URI.Path | Joins two paths. If the second path is absolute, it is returned as-is. Otherwise, the second path's
segments are appended to the first path.
| true |
Bool.toBitVec_toUInt8 | Init.Data.UInt.Bitwise | ∀ {b : Bool}, b.toUInt8.toBitVec = BitVec.setWidth 8 (BitVec.ofBool b) | null | true |
ProbabilityTheory.iIndepFun.indepFun_add_right₀ | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10}
{m : MeasurableSpace β} [inst : Add β] [MeasurableAdd₂ β] {f : ι → Ω → β},
ProbabilityTheory.iIndepFun f μ →
(∀ (i : ι), AEMeasurable (f i) μ) → ∀ (i j k : ι), i ≠ j → i ≠ k → ProbabilityTheory.IndepFun (f i)... | null | true |
Mathlib.Meta.Positivity.Strictness.positive.noConfusion | Mathlib.Tactic.Positivity.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{e : Q(«$α»)} →
{P : Sort u} →
{pα : Q(PartialOrder «$α»)} →
{pf : Q(0 < «$e»)} →
{pα' : Q(PartialOrder «$α»)} →
{pf' : Q(0 < «$e»)} →
some pα = some pα' →
... | null | false |
map_comap_subtype_coe | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {s : Set α},
MeasurableSet s →
∀ (μ : MeasureTheory.Measure α),
MeasureTheory.Measure.map Subtype.val (MeasureTheory.Measure.comap Subtype.val μ) = μ.restrict s | null | true |
IsCompact.measurableSet | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {s : Set α} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α]
[T2Space α], IsCompact s → MeasurableSet s | null | true |
HomotopicalAlgebra.FibrantObject.mk_surjective | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_2 : CategoryTheory.Limits.HasTerminal C] (X : HomotopicalAlgebra.FibrantObject C),
∃ Y, ∃ (x : HomotopicalAlgebra.IsFibrant Y), X = HomotopicalAlgebra.FibrantObject.mk Y | null | true |
Mathlib.Meta.NormNum.jacobiSymNat.qr₁_mod | Mathlib.Tactic.NormNum.LegendreSymbol | ∀ (a b ab : ℕ) (r : ℤ),
a % 4 = 1 →
b % 2 = 1 → b % a = ab → Mathlib.Meta.NormNum.jacobiSymNat ab a = r → Mathlib.Meta.NormNum.jacobiSymNat a b = r | null | true |
_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE.0.CategoryTheory.Triangulated.TStructure.TruncAux.triangleMapOfLE.eq_1 | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
Std.TreeSet.Raw.contains_of_contains_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k a : α}, (t.insert k).contains a = true → cmp k a ≠ Ordering.eq → t.contains a = true | null | true |
Thunk.ext_iff | Init.Ext | ∀ {α : Type u_1} {a b : Thunk α}, a = b ↔ a.get = b.get | null | true |
Fintype.decidableEqMulEquivFintype.eq_1 | Mathlib.Algebra.Group.Equiv.Finite | ∀ {α : Type u_3} {β : Type u_4} [inst : DecidableEq β] [inst_1 : Fintype α] [inst_2 : Mul α] [inst_3 : Mul β]
(a b : α ≃* β), Fintype.decidableEqMulEquivFintype a b = decidable_of_iff (⇑a = ⇑b) ⋯ | null | true |
Std.ExtTreeMap.getElem?_eq_some_iff_exists_compare_eq_eq_and_mem_toList | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, t[k]? = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ t.toList | null | true |
Commute.geom_sum₂_mul_add | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Semiring R] {x y : R},
Commute x y → ∀ (n : ℕ), (∑ i ∈ Finset.range n, (x + y) ^ i * y ^ (n - 1 - i)) * x + y ^ n = (x + y) ^ n | $x^n-y^n = (x-y) \sum x^ky^{n-1-k}$ reformulated without `-` signs. | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiff_succ_iff_fderiv._simp_1_3 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F}, fderiv 𝕜 f = fderivWithin 𝕜 f Set.univ | null | false |
CategoryTheory.Groupoid.invEquivalence_unitIso | Mathlib.CategoryTheory.Groupoid | ∀ (C : Type u) [inst : CategoryTheory.Groupoid C],
(CategoryTheory.Groupoid.invEquivalence C).unitIso =
CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).obj x)) ⋯ | null | true |
CategoryTheory.ShortComplex.SnakeInput.Hom._sizeOf_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{S₁ S₂ : CategoryTheory.ShortComplex.SnakeInput C} → [SizeOf C] → S₁.Hom S₂ → ℕ | null | false |
MulOpposite.instRightCancelSemigroup.eq_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : LeftCancelSemigroup α],
MulOpposite.instRightCancelSemigroup = { toSemigroup := MulOpposite.instSemigroup, toIsRightCancelMul := ⋯ } | null | true |
_private.Init.Data.SInt.Package.0.instLinearOrderPackageISize._proof_4 | Init.Data.SInt.Package | ∀ (x x_1 x_2 : ISize), x ≤ x_1 → x_1 ≤ x_2 → x ≤ x_2 | null | false |
_private.Init.Data.List.Lemmas.0.List.length_pos_iff_exists_cons.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (motive : (∃ h t, l = h :: t) → Prop) (x : ∃ h t, l = h :: t),
(∀ (w : α) (w_1 : List α) (eq : l = w :: w_1), motive ⋯) → motive x | null | false |
Ideal.mem_minimalPrimes_of_ne_bot | Mathlib.RingTheory.DedekindDomain.Basic | ∀ {R : Type u_4} [inst : CommRing R] [Ring.DimensionLEOne R] {p q : Ideal R} [q.IsPrime],
p ≠ ⊥ → p ≤ q → q ∈ p.minimalPrimes | null | true |
Std.IterM.IsPlausibleIndirectSuccessorOf.rec | Init.Data.Iterators.Basic | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] {a : Std.IterM m β}
{motive : (a_1 : Std.IterM m β) → a.IsPlausibleIndirectSuccessorOf a_1 → Prop},
motive a ⋯ →
(∀ {it' it : Std.IterM m β} (h' : a.IsPlausibleIndirectSuccessorOf it') (h : it'.IsPlausibleSuccessorOf it),
motive it' h' ... | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.Const.minEntryD.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : Type u_2} (motive : (Std.DTreeMap.Internal.Impl α fun x => β) → α × β → Sort u_3)
(fallback : α × β) (h_1 : (fallback : α × β) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β) →
(r : Std.DTreeMap.Internal.Impl α fun x => β) →
... | null | true |
Finset.smul_finset_sdiff | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] [IsLeftCancelSMul α β] [inst_2 : DecidableEq β] {s t : Finset β}
{a : α}, a • (s \ t) = a • s \ a • t | null | true |
LinearOrderedAddCommGroup.zmultiplesOrderAddMonoidIso.match_3 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : AddCommGroup G] (x : G) (motive : ↥(AddSubgroup.zmultiples x) → Prop)
(h : ↥(AddSubgroup.zmultiples x)), (∀ (a : G) (ha : a ∈ AddSubgroup.zmultiples x), motive ⟨a, ha⟩) → motive h | null | false |
Matrix.transposeᵣ._sunfold | Mathlib.Data.Matrix.Reflection | {α : Type u_1} → {m n : ℕ} → Matrix (Fin m) (Fin n) α → Matrix (Fin n) (Fin m) α | null | false |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.WithZero.instLinearOrderedCommMonoidWithZero._simp_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Mul α] (a b : α), ↑a * ↑b = ↑(a * b) | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.genWrapper.build._unary._proof_1 | Lean.Elab.DocString | ∀ (argSpec : Array Lean.Doc.ArgSpec✝) (i : ℕ) (args : Array Lean.Expr),
i < argSpec.size →
∀ (v : Lean.Expr),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i args => argSpec.size - i) ⟨i + 1, args.push v⟩
⟨i, args⟩ | null | false |
Field.Emb.Cardinal.equivLim._proof_5 | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u_2} {E : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E]
{i : WithTop (Module.rank F E).ord.ToType} (hi : Order.IsSuccPrelimit i)
(f : ↥(Field.Emb.Cardinal.filtration i) →ₐ[F] AlgebraicClosur... | null | false |
PrimeSpectrum.discreteTopology_iff_toPiLocalization_bijective | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u_1} [inst : CommSemiring R],
DiscreteTopology (PrimeSpectrum R) ↔ Function.Bijective ⇑(PrimeSpectrum.toPiLocalization R) | null | true |
Std.Packages.PreorderOfLEArgs.lt._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | null | false |
Lean.Compiler.LCNF.FindUsed.State | Lean.Compiler.LCNF.ReduceArity | Type | null | true |
SSet.Truncated.instMonoidalTruncation._proof_8 | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ (n : ℕ),
autoParam
(∀ (X : SSet),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor ((SSet.truncation n).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (SSet.Truncated.instMonoidalTruncation._aux_1 n)
((SSet.truncation n).... | null | false |
_private.Init.GrindInstances.Ring.Nat.0.Lean.Grind.instOrderedRingNat._proof_1 | Init.GrindInstances.Ring.Nat | ∀ {a b : ℕ} (c : ℕ), ¬(a ≤ b ↔ a + c ≤ b + c) → False | null | false |
CategoryTheory.MorphismProperty.instIsMultiplicativeDiagonalOfIsStableUnderBaseChange | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{P : CategoryTheory.MorphismProperty C} [P.IsMultiplicative] [P.IsStableUnderBaseChange], P.diagonal.IsMultiplicative | null | true |
CommGroup.card_restrictHom_ker | Mathlib.GroupTheory.FiniteAbelian.Duality | ∀ {G : Type u_1} (M : Type u_2) [inst : CommGroup G] [Finite G] [inst_2 : CommMonoid M]
[hM : HasEnoughRootsOfUnity M (Monoid.exponent G)] (H : Subgroup G),
Nat.card ↥(MonoidHom.domRestrictHom H Mˣ).ker = Nat.card (G ⧸ H) | **Alias** of `CommGroup.card_domRestrictHom_ker`. | true |
CategoryTheory.RegularEpi.W | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → {f : X ⟶ Y} → CategoryTheory.RegularEpi f → C | An object from `C` | true |
CategoryTheory.StructuredArrow.pre_obj_left | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (S : D) (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S)... | null | true |
_private.Mathlib.Topology.UniformSpace.UniformEmbedding.0.IsUniformInducing.cauchy_map_iff._simp_1_1 | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) {F : Filter α}, (Filter.map f F).NeBot = F.NeBot | null | false |
Complex.re_eq_neg_norm | Mathlib.Analysis.Complex.Order | ∀ {z : ℂ}, z.re = -‖z‖ ↔ z ≤ 0 | null | true |
CategoryTheory.Limits.instInhabitedWalkingPair.default | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | CategoryTheory.Limits.WalkingPair | null | true |
_private.Lean.Elab.PreDefinition.Structural.Eqns.0.Lean.Elab.Structural.getUnfoldFor?.match_1 | Lean.Elab.PreDefinition.Structural.Eqns | (motive : Option Lean.Elab.Structural.EqnInfo → Sort u_1) →
(x : Option Lean.Elab.Structural.EqnInfo) →
((info : Lean.Elab.Structural.EqnInfo) → motive (some info)) →
((x : Option Lean.Elab.Structural.EqnInfo) → motive x) → motive x | null | false |
Std.Http.Header.ContentLength.serialize | Std.Http.Data.Headers.Basic | Std.Http.Header.ContentLength → Std.Http.Header.Name × Std.Http.Header.Value | Serializes a content length header back to a name-value pair.
| true |
Stream'.tail_interleave | Mathlib.Data.Stream.Init | ∀ {α : Type u} (s₁ s₂ : Stream' α), (s₁ ⋈ s₂).tail = s₂ ⋈ s₁.tail | null | true |
CategoryTheory.Limits.BinaryBicone.toCocone | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} → CategoryTheory.Limits.BinaryBicone P Q → CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair P Q) | Extract the cocone from a binary bicone. | true |
MvPolynomial.isEmptyAlgEquiv.congr_simp | Mathlib.RingTheory.Polynomial.Basic | ∀ (R : Type u) (σ : Type u_1) [inst : CommSemiring R] [inst_1 : IsEmpty σ],
MvPolynomial.isEmptyAlgEquiv R σ = MvPolynomial.isEmptyAlgEquiv R σ | null | true |
Std.DHashMap.Internal.Raw.Const.insertManyIfNewUnit_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {ρ : Type w} [inst : ForIn Id ρ α] [inst_1 : BEq α] [inst_2 : Hashable α]
{m : Std.DHashMap.Raw α fun x => Unit} {l : ρ} (h : m.WF),
Std.DHashMap.Raw.Const.insertManyIfNewUnit m l = ↑↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit ⟨m, ⋯⟩ l) | null | true |
Float.Model.ofInt8 | Init.Data.Float.Model.Float | Int8 → Float.Model | Converts an `Int8` to a `Float.Model`, returning positive zero on zero. | true |
CategoryTheory.ShortComplex.rightHomologyι_naturality'_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData) {Z : C}
(h : h₂.Q ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.r... | null | true |
ProbabilityTheory.hasGaussianLaw_iff_charFunDual_map_eq | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E] [MeasureTheory.IsFiniteMeasure P],
AEMeasurable X P →
(ProbabilityTheory.HasGaussianLaw X P ↔
∀ (L : Stron... | null | true |
VitaliFamily.eventually_filterAt_iff | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
(v : VitaliFamily μ) {x : X} {P : Set X → Prop},
(∀ᶠ (t : Set X) in v.filterAt x, P t) ↔ ∃ ε > 0, ∀ t ∈ v.setsAt x, t ⊆ Metric.closedBall x ε → P t | null | true |
Std.DHashMap.Internal.Raw₀.foldRevM_eq_foldrM_keys | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) {δ : Type w} {m' : Type w → Type w'}
[inst : Monad m'] [LawfulMonad m'] {f : δ → α → m' δ} {init : δ},
Std.DHashMap.Raw.Internal.foldRevM (fun d a x => f d a) init ↑m = List.foldrM (fun a b => f b a) init (↑m).keys | null | true |
metricSpaceOfNormedAddCommGroupOfAddTorsor._proof_6 | Mathlib.Analysis.Normed.Group.AddTorsor | ∀ (V : Type u_2) (P : Type u_1) [inst : NormedAddCommGroup V] [inst_1 : AddTorsor V P],
(Bornology.cobounded P).sets = {s | ∃ C, ∀ x ∈ sᶜ, ∀ y ∈ sᶜ, ‖x -ᵥ y‖ ≤ C} | null | false |
_private.Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots.0.instFieldAdjoinPthRoots._aux_52 | Mathlib.FieldTheory.PurelyInseparable.AdjoinPthRoots | (k : Type u_1) → [Field k] → ZPow (AdjoinPthRoots k) | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Orthogonal.0.Submodule.isOrtho_span._simp_1_6 | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
NumberField.IdeleGroup.unitEmbedding | Mathlib.NumberTheory.NumberField.AdeleRing | (R : Type u_1) →
(K : Type u_2) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
[inst_2 : Field K] → [inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → Kˣ →* NumberField.IdeleGroup R K | The map from `Kˣ` to the idele group of `K`. The image is the subgroup of principal ideles. | true |
MeasureTheory.Measure.measure_image_eq_zero_of_comap_eq_zero | Mathlib.MeasureTheory.Measure.Comap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (f : α → β)
(μ : MeasureTheory.Measure β),
Function.Injective f →
(∀ (s : Set α), MeasurableSet s → MeasureTheory.NullMeasurableSet (f '' s) μ) →
∀ {s : Set α}, (MeasureTheory.Measure.comap f μ) s = 0 → μ (f '' s) = 0 | null | true |
CategoryTheory.Mod_.mod | Mathlib.CategoryTheory.Monoidal.Mod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
{A : C} →
[inst_4 : Cat... | **Alias** of `CategoryTheory.Mod.mod`. | true |
MulAut.congr._proof_4 | Mathlib.Algebra.Group.End | ∀ {G : Type u_1} [inst : Group G] {H : Type u_2} [inst_1 : Group H] (ϕ : G ≃* H) (x y : MulAut G),
ϕ.symm.trans (MulEquiv.trans (x * y) ϕ) = ϕ.symm.trans (MulEquiv.trans x ϕ) * ϕ.symm.trans (MulEquiv.trans y ϕ) | null | false |
ContDiffAt.contDiffBump | Mathlib.Analysis.Calculus.BumpFunction.Basic | ∀ {E : Type u_1} {X : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup X]
[inst_3 : NormedSpace ℝ X] [inst_4 : HasContDiffBump E] {n : ℕ∞} {c g : X → E} {f : (x : X) → ContDiffBump (c x)}
{x : X},
ContDiffAt ℝ (↑n) c x →
ContDiffAt ℝ (↑n) (fun x => (f x).rIn) x →... | `ContDiffBump` is `𝒞ⁿ` in all its arguments. | true |
seqClosure_subset_closure | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, seqClosure s ⊆ closure s | The sequential closure of a set is contained in the closure of that set.
The converse is not true. | true |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.dispatchPendingRequest | Std.Http.Server.Connection | {σ : Type} →
[inst : Std.Http.Server.Handler σ] →
σ →
Std.Http.Extensions →
Std.CancellationContext →
Std.Http.Server.Connection.ConnectionState✝ (Std.Http.Server.Handler.ResponseBody σ) →
Std.Async.Async (Std.Http.Server.Connection.ConnectionState✝ (Std.Http.Server.Handler.Res... | Dispatches a pending request head to the handler if one is waiting.
Spawns the handler as an async task and routes its result back through `state.response`.
Returns the updated state with `pendingHead` cleared and `handlerDispatched` set.
| true |
Con.lift_comp_mk' | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass P] {c : Con M} {f : M →* P}
(H : c ≤ Con.ker f), (c.lift f H).comp c.mk' = f | The diagram describing the universal property for quotients of monoids commutes. | true |
Filter.EventuallyEmptyOrUniv.mulIndicator_const_iff_of_ne | Mathlib.Order.Filter.EventuallyConst | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} [inst : One β] {s : Set α} {c : β},
c ≠ 1 → (Filter.EventuallyConst (s.mulIndicator fun x => c) l ↔ Filter.EventuallyEmptyOrUniv s l) | null | true |
QuadraticMap.tensorDistrib._proof_12 | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct | ∀ (R : Type u_6) (A : Type u_1) {M₁ : Type u_4} {M₂ : Type u_5} {N₁ : Type u_2} {N₂ : Type u_3} [inst : CommRing R]
[inst_1 : CommRing A] [inst_2 : AddCommGroup M₁] [inst_3 : AddCommGroup M₂] [inst_4 : AddCommGroup N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Algebra R A] [inst_7 : Module R M₁] [inst_8 : Module A M₁] [... | null | false |
CategoryTheory.Monad.FreeCoequalizer.topMap | Mathlib.CategoryTheory.Monad.Coequalizer | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} → (X : T.Algebra) → T.free.obj (T.obj X.A) ⟶ T.free.obj X.A | The top map in the coequalizer diagram we will construct. | true |
CategoryTheory.MorphismProperty.under_eq_inverseImage | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{v_3, u_3} T] (W : CategoryTheory.MorphismProperty T) (X : T),
W.under = W.inverseImage (CategoryTheory.Under.forget X) | null | true |
ModuleCat.endRingEquiv._proof_4 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] (M : ModuleCat R) (x x_1 : CategoryTheory.End M),
ModuleCat.Hom.hom (x + x_1).asHom = ModuleCat.Hom.hom (x + x_1).asHom | null | false |
Fin.prod_congr' | Mathlib.Algebra.BigOperators.Fin | ∀ {M : Type u_2} [inst : CommMonoid M] {a b : ℕ} (f : Fin b → M) (h : a = b), ∏ i, f (Fin.cast h i) = ∏ i, f i | null | true |
_private.Mathlib.CategoryTheory.Galois.Basic.0.CategoryTheory.PreGaloisCategory.lt_card_fiber_of_mono_of_notIso._simp_1_1 | Mathlib.CategoryTheory.Galois.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
Convex.second_derivative_within_at_symmetric | Mathlib.Analysis.Calculus.FDeriv.Symmetric | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {s : Set E},
Convex ℝ s →
(interior s).Nonempty →
∀ {f : E → F} {f' : E → E →L[ℝ] F} {f'' : E →L[ℝ] E →L[ℝ] F},
(∀ x ∈ interior s, HasFDerivAt f (f' x... | If a function is differentiable inside a convex set with nonempty interior, and has a second
derivative at a point of this convex set, then this second derivative is symmetric. | true |
_private.Init.Data.List.Nat.Erase.0.List.getElem?_eraseIdx._proof_1_4 | Init.Data.List.Nat.Erase | ∀ {α : Type u_1} {l : List α} {i j : ℕ}, l.length < i → ¬l.length ≤ i + 1 + (j - min i l.length) → False | null | false |
Subtype.coind_coe | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Sort u_5} (f : α → β) {p : β → Prop} (h : ∀ (a : α), p (f a)) (a : α),
↑(Subtype.coind f h a) = f a | null | true |
_private.Mathlib.Tactic.Linarith.Frontend.0.Mathlib.Tactic.minimize._unsafe_rec | Mathlib.Tactic.Linarith.Frontend | Mathlib.Tactic.Linarith.LinarithConfig →
Lean.Elab.Tactic.SavedState → Lean.MVarId → List Lean.Expr → ℕ → Lean.Elab.Tactic.TacticM (List Lean.Expr) | null | false |
FreeAddGroupBasis.instFunLike.eq_1 | Mathlib.GroupTheory.FreeGroup.IsFreeGroup | ∀ {ι : Type u_1} {G : Type u_3} [inst : AddGroup G],
FreeAddGroupBasis.instFunLike = { coe := fun b i => b.repr.symm (FreeAddGroup.of i), coe_injective := ⋯ } | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.