name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.doubling_lt_golden_ratio._simp_1_21 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
DifferentiableAt.smul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : 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] {x : E}
{𝕜' : Type u_4} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F] [IsBo... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtractAndExtend.go._unary._proof_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {w : ℕ} (idx : ℕ), w * (idx + 1) = w * idx + w → w * idx + w = w * (idx + 1) | null | false |
InitialSeg.mem_range_of_rel' | Mathlib.Order.InitialSeg | ∀ {α : Type u_4} {β : Type u_5} {r : α → α → Prop} {s : β → β → Prop} (self : InitialSeg r s) (a : α) (b : β),
s b (self.toRelEmbedding a) → b ∈ Set.range ⇑self.toRelEmbedding | The order embedding is an initial segment | true |
Std.DHashMap.Internal.List.HashesTo.mk | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List ((a : α) × β a)} {i size : ℕ},
(∀ (h : 0 < size), ∀ p ∈ l, (↑(Std.DHashMap.Internal.mkIdx size h (hash p.fst))).toNat = i) →
Std.DHashMap.Internal.List.HashesTo l i size | null | true |
MonCat.instConcreteCategoryMonoidHomCarrier._proof_1 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y : MonCat} (f : ↑X →* ↑Y), { hom' := f }.hom' = f | null | false |
_private.Mathlib.RingTheory.Polynomial.SmallDegreeVieta.0.Polynomial.eq_quadratic_of_degree_le_two._abel_1_1 | Mathlib.RingTheory.Polynomial.SmallDegreeVieta | ∀ {R : Type u_1} [inst : Semiring R] {p : Polynomial R},
Polynomial.C (p.coeff 0) + Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 2) * Polynomial.X ^ 2 =
Polynomial.C (p.coeff 2) * Polynomial.X ^ 2 + Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 0) | null | false |
CategoryTheory.PullbackShift.adjunction_counit | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B) {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
{F : CategoryTheory.F... | null | true |
CategoryTheory.SmallObject.FunctorObjIndex.comm_assoc | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I : Type w} {A B : I → C} (f : (i : I) → A i ⟶ B i) {S X : C}
(πX : X ⟶ S)
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete (CategoryTheory.SmallObject.FunctorObjIndex f πX))
C]
[inst_2 :
CategoryTheory.Limits.HasPu... | null | true |
ContinuousLinearMap.IsIdempotentElem.ext | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Idempotent | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : M →L[R] M},
IsIdempotentElem p → IsIdempotentElem q → (↑p).range = (↑q).range ∧ (↑p).ker = (↑q).ker → p = q | **Alias** of the reverse direction of `ContinuousLinearMap.IsIdempotentElem.ext_iff`.
---
Idempotent operators are equal iff their range and kernels are. | true |
_private.Mathlib.RingTheory.MvPowerSeries.Order.0.MvPowerSeries.le_weightedOrder._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] [inst_1 : PartialOrder α] [AddLeftMono α] [ZeroLEOneClass α] [CharZero α]
{m n : ℕ}, (↑m < ↑n) = (m < n) | null | false |
Pi.cancelMonoid._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → CancelMonoid (f i)], IsRightCancelMul ((i : I) → f i) | null | false |
ULift.forall | Mathlib.Data.ULift | ∀ {α : Type u} {p : ULift.{u_1, u} α → Prop}, (∀ (x : ULift.{u_1, u} α), p x) ↔ ∀ (x : α), p { down := x } | null | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.Action.hugeNumber | Lean.Meta.Tactic.Grind.Intro | ℕ | null | true |
MonoidHom.smulOneHom | Mathlib.Algebra.Group.Action.Hom | {M : Type u_4} →
{N : Type u_5} →
[inst : Monoid M] → [inst_1 : MulOneClass N] → [inst_2 : MulAction M N] → [IsScalarTower M N N] → M →* N | If the multiplicative action of `M` on `N` is compatible with multiplication on `N`, then
`fun x ↦ x • 1` is a monoid homomorphism from `M` to `N`. | true |
Lean.Macro.State | Init.Prelude | Type | The mutable state for the `MacroM` monad. | true |
List.perm_reverse | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse ↔ l₁.Perm l₂ | null | true |
CategoryTheory.EnrichedCat.bicategory._proof_3 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c : CategoryTheory.EnrichedCat V} {f g : CategoryTheory.EnrichedFunctor V ↑a ↑b}
{h i : CategoryTheory.EnrichedFunctor V ↑b ↑c} (α : f ⟶ g) (β : h ⟶ i),
CategoryTheory.CategoryStruct.comp (CategoryTheo... | null | false |
UInt16.toUInt32_and | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a &&& b).toUInt32 = a.toUInt32 &&& b.toUInt32 | null | true |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_support_count_tail_eq_one | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.IsHamiltonianCycle ↔ p.IsCycle ∧ ∀ (a_1 : α), List.count a_1 p.support.tail = 1 | null | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.brecOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive : Lean.Meta.Grind.Arith.CommRing.PolyDerivation → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
((t : Lean.Meta.Grind.Arith.CommRing.PolyDerivation) →
Lean.Meta.Grind.Arith.CommRing.PolyDerivation.below t → motive t) →
motive t | null | false |
instCommGroupAbelianization._aux_1 | Mathlib.GroupTheory.Abelianization.Defs | (G : Type u_1) → [inst : Group G] → Abelianization G | null | false |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage._proof_1_10 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] {a b c : ι} (hbc : b ≤ c) (w : ι) (w_1 : a < w)
(w_2 : w ≤ b), w ≤ b → ↑⟨w, ⋯⟩ ∈ Finset.Ioc a b | null | false |
_private.Mathlib.Analysis.Convex.Segment.0.insert_endpoints_openSegment._simp_1_1 | Mathlib.Analysis.Convex.Segment | ∀ {α : Type u_1} [UsesSetNotationForOrder α] [inst : PartialOrder α] {a b : α}, (a = b) = (a ⊆ b ∧ b ⊆ a) | null | false |
MeasureTheory.AEStronglyMeasurable.add_const | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} [inst_1 : Add β] [ContinuousAdd β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : β), MeasureTheory.AEStronglyMeasurable (fun x => f x + c) μ | null | true |
_private.Init.Data.String.Lemmas.Basic.0.String.Slice.slice_eq_self_iff._simp_1_3 | Init.Data.String.Lemmas.Basic | ∀ {s : String} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
MeasureTheory.measure_inter_add_sdiff | Mathlib.MeasureTheory.Measure.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {t : Set α} (s : Set α),
MeasurableSet t → μ (s ∩ t) + μ (s \ t) = μ s | null | true |
Monoid.PushoutI.hom_ext_iff | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} {K : Type u_4} [inst : Monoid K] [inst_1 : (i : ι) → Monoid (G i)]
[inst_2 : Monoid H] {φ : (i : ι) → H →* G i} {f g : Monoid.PushoutI φ →* K},
f = g ↔
(∀ (i : ι), f.comp (Monoid.PushoutI.of i) = g.comp (Monoid.PushoutI.of i)) ∧
f.comp (Monoid.PushoutI.ba... | null | true |
_private.Aesop.Nanos.0.Aesop.instBEqNanos.beq.match_1 | Aesop.Nanos | (motive : Aesop.Nanos → Aesop.Nanos → Sort u_1) →
(x x_1 : Aesop.Nanos) →
((a b : ℕ) → motive { nanos := a } { nanos := b }) → ((x x_2 : Aesop.Nanos) → motive x x_2) → motive x x_1 | null | false |
HXor.mk.noConfusion | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : outParam (Type w)} →
{P : Sort u_1} → {hXor hXor' : α → β → γ} → { hXor := hXor } = { hXor := hXor' } → (hXor ≍ hXor' → P) → P | null | false |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_of_two_pow_le_and_two_pow_add_one_gt._proof_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ {n : ℕ} {i : ℕ}, ∀ i' ≥ i, ¬i = i' → ¬i + 1 ≤ i' → False | null | false |
CategoryTheory.MonObj.pow_comp | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N X : C} [inst_2 : CategoryTheory.MonObj M] [inst_3 : CategoryTheory.MonObj N] (f : X ⟶ M) (n : ℕ) (g : M ⟶ N)
[CategoryTheory.IsMonHom g], CategoryTheory.CategoryStruct.comp (f ^ n) g = CategoryThe... | null | true |
_private.Init.Data.List.Sort.Basic.0.List.merge.match_1 | Init.Data.List.Sort.Basic | {α : Type u_1} →
(motive : List α → List α → Sort u_2) →
(xs ys : List α) →
((ys : List α) → motive [] ys) →
((xs : List α) → motive xs []) →
((x : α) → (xs : List α) → (y : α) → (ys : List α) → motive (x :: xs) (y :: ys)) → motive xs ys | null | false |
Subgroup.descending_central_series_ge_lower | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] (H : ℕ → Subgroup G),
Subgroup.IsDescendingCentralSeries H → ∀ (n : ℕ), ⊤.lowerCentralSeries n ≤ H n | Any descending central series for a group is bounded below by the lower central series. | true |
Polynomial.contentIdeal_le_span_content | Mathlib.RingTheory.Polynomial.ContentIdeal | ∀ {R : Type u_3} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] {p : Polynomial R},
p.contentIdeal ≤ Ideal.span {p.content} | null | true |
Mathlib.Tactic.LibraryRewrite.Kind.hypothesis.sizeOf_spec | Mathlib.Tactic.Widget.LibraryRewrite | sizeOf Mathlib.Tactic.LibraryRewrite.Kind.hypothesis = 1 | null | true |
exists_ne_mem_inter_of_not_pairwise_disjoint | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {ι : Type u_4} {f : ι → Set α},
¬Pairwise (Function.onFun Disjoint f) → ∃ i j, i ≠ j ∧ ∃ x, x ∈ f i ∩ f j | null | true |
Std.DTreeMap.Equiv.getEntryGT_eq.match_1 | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} {t₁ : Std.DTreeMap α β cmp} {k : α} (x : α)
(motive : x ∈ t₁ ∧ cmp x k = Ordering.gt → Prop) (x_1 : x ∈ t₁ ∧ cmp x k = Ordering.gt),
(∀ (h₁ : x ∈ t₁) (h₂ : cmp x k = Ordering.gt), motive ⋯) → motive x_1 | null | false |
CommGroupWithZero.toGroupWithZero | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → [self : CommGroupWithZero G₀] → GroupWithZero G₀ | null | true |
Lean.Grind.CommRing.Mon.sharesVar._unary | Lean.Meta.Sym.Arith.Poly | (_ : Lean.Grind.CommRing.Mon) ×' Lean.Grind.CommRing.Mon → Bool | `sharesVar m₁ m₂` returns `true` if `m₁` and `m₂` shares at least one variable. | false |
Aesop.NormalizationState.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.NormalizationState} → t = t' → Aesop.NormalizationState.noConfusionType P t t' | null | false |
CategoryTheory.CopyDiscardCategory.copy_tensor | Mathlib.CategoryTheory.CopyDiscardCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {inst_1 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.CopyDiscardCategory C] (X Y : C),
CategoryTheory.ComonObj.comul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom CategoryTheory.ComonObj.comul C... | Tensor products of copies equal copies of tensor products. | true |
Lean.Meta.Try.collect | Lean.Meta.Tactic.Try.Collect | Lean.MVarId → Lean.Try.Config → Lean.MetaM Lean.Meta.Try.Info | null | true |
MeasureTheory.SimpleFunc.noConfusionType | Mathlib.MeasureTheory.Function.SimpleFunc | Sort u_1 →
{α : Type u} →
[inst : MeasurableSpace α] →
{β : Type v} →
MeasureTheory.SimpleFunc α β →
{α' : Type u} → [inst' : MeasurableSpace α'] → {β' : Type v} → MeasureTheory.SimpleFunc α' β' → Sort u_1 | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doHave._regBuiltin.Lean.Parser.Term.doHave.parenthesizer_11 | Lean.Parser.Do | IO Unit | null | false |
Std.ExtDTreeMap.eq_empty_iff_size_eq_zero | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
t = ∅ ↔ t.size = 0 | null | true |
Multiset.ssubset_singleton_iff | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, s ⊂ {a} ↔ s = 0 | null | true |
UpperSet.completeLattice | Mathlib.Order.UpperLower.CompleteLattice | {α : Type u_1} → [inst : LE α] → CompleteLattice (UpperSet α) | null | true |
QuotientGroup.dense_preimage_mk._simp_2 | Mathlib.Topology.Algebra.Group.Quotient | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [SeparatelyContinuousMul G] {N : Subgroup G}
{s : Set (G ⧸ N)}, Dense (QuotientGroup.mk ⁻¹' s) = Dense s | null | false |
NonarchAddGroupSeminorm.instZero._proof_3 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (x : E), 0 (-x) = 0 (-x) | null | false |
Std.Iter.toList_zip_of_finite_right | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ α₂ β₁ β₂ : Type u_1} [inst : Std.Iterator α₁ Id β₁] [inst_1 : Std.Iterator α₂ Id β₂] {it₁ : Std.Iter β₁}
{it₂ : Std.Iter β₂} [Std.Iterators.Productive α₁ Id] [Std.Iterators.Finite α₂ Id],
(it₁.zip it₂).toList = (Std.Iter.take it₂.toList.length it₁).toList.zip it₂.toList | null | true |
Set.BijOn.surjOn | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, Set.BijOn f s t → Set.SurjOn f s t | null | true |
MeasureTheory.Measure.FiniteAtFilter | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} → {_m0 : MeasurableSpace α} → MeasureTheory.Measure α → Filter α → Prop | A measure is called finite at filter `f` if it is finite at some set `s ∈ f`.
Equivalently, it is eventually finite at `s` in `f.small_sets`. | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_4 | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (∃ c, b = a * c) = (a ∣ b) | null | false |
Lean.Parser.nameLitFn | Lean.Parser.Basic | Lean.Parser.ParserFn | null | true |
QuaternionAlgebra.instRing._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R] (x : QuaternionAlgebra R c₁ c₂ c₃), x * 1 = x | null | false |
ConditionallyCompletePartialOrderInf.isGLB_csInf_of_directed | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | ∀ {α : Type u_3} [self : ConditionallyCompletePartialOrderInf α] (s : Set α),
DirectedOn (fun x1 x2 => x1 ≥ x2) s → s.Nonempty → BddBelow s → IsGLB s (sInf s) | For each nonempty, directed set `s` which is bounded below, `sInf s` is
the greatest lower bound of `s`. | true |
CategoryTheory.Endofunctor.Algebra.Hom.mk.inj | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} {f : A₀.a ⟶ A₁.a}
{h :
autoParam (CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f)
CategoryTheory.Endofunctor.Algebra.H... | null | true |
CategoryTheory.Limits.PushoutCocone.ofCocone | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor CategoryTheory.Limits.WalkingSpan C} →
CategoryTheory.Limits.Cocone F →
CategoryTheory.Limits.PushoutCocone (F.map CategoryTheory.Limits.WalkingSpan.Hom.fst)
(F.map CategoryTheory.Limits.WalkingSpan.Hom.... | Given `F : WalkingSpan ⥤ C`, which is really the same as `span (F.map fst) (F.map snd)`,
and a cocone on `F`, we get a pushout cocone on `F.map fst` and `F.map snd`. | true |
Lean.Linter.LinterSetsState.mk.injEq | Lean.Linter.Init | ∀ (merged : Lean.Linter.LinterSets) (localEntries : Array (Lean.Name × Lean.NameSet))
(merged_1 : Lean.Linter.LinterSets) (localEntries_1 : Array (Lean.Name × Lean.NameSet)),
({ merged := merged, localEntries := localEntries } = { merged := merged_1, localEntries := localEntries_1 }) =
(merged = merged_1 ∧ loca... | null | true |
LaurentSeries.coe_range_dense | Mathlib.RingTheory.LaurentSeries | ∀ {K : Type u_2} [inst : Field K], DenseRange ⇑(algebraMap (RatFunc K) (LaurentSeries K)) | null | true |
_private.Mathlib.NumberTheory.Cyclotomic.Basic.0.isCyclotomicExtension_iff_eq_adjoin._simp_1_9 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
WeierstrassCurve.Projective.addY_of_X_eq | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Projective F} {P Q : Fin 3 → F},
W.Equation P →
W.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → W.addY P Q = WeierstrassCurve.Projective.addU P Q | null | true |
MeasureTheory.hittingBtwn.eq_1 | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Preorder ι] [inst_1 : InfSet ι] (u : ι → Ω → β) (s : Set β)
(n m : ι) (x : Ω),
MeasureTheory.hittingBtwn u s n m x = if ∃ j ∈ Set.Icc n m, u j x ∈ s then sInf (Set.Icc n m ∩ {i | u i x ∈ s}) else m | null | true |
CategoryTheory.Functor.Faithful.mapMon | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {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 D]
{F : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] [F.Faithful], F.mapMon.Faithful | null | true |
Finset.inv_subset_inv | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Inv α] {s t : Finset α}, s ⊆ t → s⁻¹ ⊆ t⁻¹ | null | true |
Algebra.Extension.tensorCotangentInvFun._proof_5 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R S] [inst_4 : Algebra R T] {P : Algebra.Extension R S} {Q : Algebra.Extension R T}
[alg : Algebra P.Ring Q.Ring], IsScalarTower P.Ring Q.Ring ↥Q.ker | null | false |
groupHomology.coinfNatTrans._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k : Type u_1) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal] (n : ℕ)
{X Y : Rep.{u_1, u_1, u_1} k G} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((groupHomology.functor k G n).map φ)
(groupHomology.map (QuotientGroup.mk' S) (Y.toCoinvariantsMkQ S) n) =
Ca... | null | false |
Nat.odd_mul_odd_div_two | Mathlib.Data.Nat.ModEq | ∀ {m n : ℕ}, m % 2 = 1 → n % 2 = 1 → m * n / 2 = m * (n / 2) + m / 2 | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Correctness.0.BirdDet.birdDet_eq_birdDetSpec | Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Correctness | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (A : Array R) (hA : A.size = n * n),
BirdDet.birdDet n A = BirdDet.Spec.birdDet (Matrix.ofArray A hA) | The flat-array algorithm `BirdDet.birdDet` computes the same determinant as
`BirdDet.Spec.birdDet`. | true |
TypeCat.Hom._mkInternal.noConfusion | Mathlib.CategoryTheory.Types.Basic | {X Y : Type u} →
{P : Sort u_1} → {hom' hom'' : TypeCat.Fun X Y} → { hom' := hom' } = { hom' := hom'' } → (hom' ≍ hom'' → P) → P | null | false |
Computability.encodingNatBool | Mathlib.Computability.Encoding | Computability.Encoding ℕ Bool | A binary `Encoding` of `ℕ` in `Bool`. | true |
Std.Do.Spec.modifyGet_StateT | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {σ α : Type u} {f : σ → α × σ}
{Q : Std.Do.PostCond α (Std.Do.PostShape.arg σ ps)} [inst : Monad m] [inst_1 : Std.Do.WPMonad m ps],
⦃fun s =>
have t := f s;
Q.1 t.1 t.2⦄
MonadStateOf.modifyGet f ⦃Q⦄ | null | true |
CategoryTheory.Over.instIsLeftAdjointMapOfHasPullbacksAlong | Mathlib.CategoryTheory.Comma.Over.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[CategoryTheory.Limits.HasPullbacksAlong f], (CategoryTheory.Over.map f).IsLeftAdjoint | null | true |
PartOrdEmb.instConcreteCategoryOrderEmbeddingCarrier._proof_1 | Mathlib.Order.Category.PartOrdEmb | ∀ {X Y : PartOrdEmb} (f : ↑X ↪o ↑Y), { hom' := f }.hom' = f | null | false |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_56 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x head : α) (tail : List α),
¬([(head :: tail).getLast ⋯] ++ [x]).dropLast.isEmpty = true → ([(head :: tail).getLast ⋯] ++ [x]).dropLast ≠ [] | null | false |
Lean.VersoModuleDocs.snippets | Lean.DocString.Extension | Lean.VersoModuleDocs → Lean.PersistentArray Lean.VersoModuleDocs.Snippet | null | true |
Std.Time.instHSubOffsetOffset_22 | Std.Time.Date.Basic | HSub Std.Time.Minute.Offset Std.Time.Day.Offset Std.Time.Minute.Offset | null | true |
instMulPosMonoWithZeroOfMulRightMono | Mathlib.Algebra.Order.GroupWithZero.WithZero | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulRightMono α], MulPosMono (WithZero α) | null | true |
CFC.nnrpow_two | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : NonUnitalRing A] [inst_2 : TopologicalSpace A] [inst_3 : StarRing A]
[inst_4 : Module ℝ A] [inst_5 : SMulCommClass ℝ A A] [inst_6 : IsScalarTower ℝ A A] [inst_7 : StarOrderedRing A]
[inst_8 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] [inst_9 : Nonneg... | null | true |
Std.ExtDHashMap.instInsertSigmaOfEquivBEqOfLawfulHashable.match_1 | Std.Data.ExtDHashMap.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{x : BEq α} →
{x_1 : Hashable α} →
(motive : (a : α) × β a → Std.ExtDHashMap α β → Sort u_3) →
(x_2 : (a : α) × β a) →
(x_3 : Std.ExtDHashMap α β) →
((a : α) → (b : β a) → (s : Std.ExtDHashMap α β) → motive ⟨a, b⟩ s) → motive ... | null | false |
CategoryTheory.Oplax.OplaxTrans.vcomp._proof_5 | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.OplaxFunctor B C} (η : CategoryTheory.Oplax.OplaxTrans F G)
(θ : CategoryTheory.Oplax.OplaxTrans G H) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(C... | null | false |
Antitone.iSup_comp_tendsto_atBot | Mathlib.Order.Filter.AtTopBot.CompleteLattice | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder β] [inst_1 : ConditionallyCompleteLattice γ]
[OrderTop γ] {l : Filter α} [l.NeBot] {f : β → γ},
Antitone f → ∀ {g : α → β}, Filter.Tendsto g l Filter.atBot → ⨆ a, f (g a) = ⨆ b, f b | If `f` is an antitone function taking values in a complete lattice
and `g` tends to `atBot` along a nontrivial filter,
then the indexed supremum of `f ∘ g` is equal to the indexed supremum of `f`. | true |
CategoryTheory.Mat.instAddCommGroupHom | Mathlib.CategoryTheory.Preadditive.Mat | (R : Type) → [inst : Ring R] → (X Y : CategoryTheory.Mat R) → AddCommGroup (X ⟶ Y) | null | true |
RingQuot.ringQuot_ext | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Semiring R] {T : Type uT} [inst_1 : NonAssocSemiring T] {r : R → R → Prop}
(f g : RingQuot r →+* T), f.comp (RingQuot.mkRingHom r) = g.comp (RingQuot.mkRingHom r) → f = g | null | true |
AlgebraicGeometry.isIso_ΓSpec_adjunction_unit_app_basicOpen | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ {X : AlgebraicGeometry.Scheme} [CompactSpace ↥X] [QuasiSeparatedSpace ↥X] (f : ↑(X.presheaf.obj (Opposite.op ⊤))),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.app X.toSpecΓ (PrimeSpectrum.basicOpen f)) | If `U` is qcqs, then `Γ(X, D(f)) ≃ Γ(X, U)_f` for every `f : Γ(X, U)`.
This is known as the **Qcqs lemma** in [R. Vakil, *The rising sea*][RisingSea]. | true |
RingEquiv.toNonUnitalRingHom_trans | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} {S' : Type u_6} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring S'] (e₁ : R ≃+* S) (e₂ : S ≃+* S'),
(e₁.trans e₂).toNonUnitalRingHom = e₂.toNonUnitalRingHom.comp e₁.toNonUnitalRingHom | null | true |
AddSubgroup.single_mem_pi._simp_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_5} {f : η → Type u_6} [inst : (i : η) → AddGroup (f i)] [inst_1 : DecidableEq η] {I : Set η}
{H : (i : η) → AddSubgroup (f i)} (i : η) (x : f i), (Pi.single i x ∈ AddSubgroup.pi I H) = (i ∈ I → x ∈ H i) | null | false |
Lean.Parser.«_aux_Init_Simproc___macroRules_Lean_Parser_command__Simproc__[_]_(_):=__1» | Init.Simproc | Lean.Macro | null | false |
Nat.exists_subseq_of_forall_mem_union | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {s t : Set α} (e : ℕ → α),
(∀ (n : ℕ), e n ∈ s ∪ t) → ∃ g, (∀ (n : ℕ), e (g n) ∈ s) ∨ ∀ (n : ℕ), e (g n) ∈ t | null | true |
CategoryTheory.FreeMonoidalCategory.Hom.l_inv | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} → (X : CategoryTheory.FreeMonoidalCategory C) → X.Hom (CategoryTheory.FreeMonoidalCategory.unit.tensor X) | null | true |
HomotopyGroup.commGroup._proof_3 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : Nontrivial N], ∃ y, y ≠ Classical.arbitrary N | null | false |
hasStrictDerivAt_exp_smul_const_of_mem_ball | Mathlib.Analysis.SpecialFunctions.Exponential | ∀ {𝕂 : Type u_1} {𝔸 : Type u_3} [inst : NontriviallyNormedField 𝕂] [CharZero 𝕂] [inst_2 : NormedRing 𝔸]
[inst_3 : NormedAlgebra 𝕂 𝔸] [CompleteSpace 𝔸] (x : 𝔸) (t : 𝕂),
t • x ∈ Metric.eball 0 (NormedSpace.expSeries 𝕂 𝔸).radius →
HasStrictDerivAt (fun u => NormedSpace.exp (u • x)) (NormedSpace.exp (t ... | null | true |
CategoryTheory.Functor.ι_biproductComparison'_assoc | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {J : Type w₁}
(F : CategoryTheory.Functor C D) (f : J → C) [inst_4 : CategoryTheory.Limits.H... | null | true |
_private.Lean.Parser.Tactic.Doc.0.Lean.Parser.Tactic.Doc.initFn._@.Lean.Parser.Tactic.Doc.1176478476._hygCtx._hyg.2 | Lean.Parser.Tactic.Doc | IO Unit | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_le_length_insertEntry._proof_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} {l : List ((a : α) × β a)}, ¬l.length ≤ l.length + 1 → False | null | false |
String.rawStartPos_eq | Init.Data.String.Defs | ∀ {s : String}, s.rawStartPos = 0 | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.le_weightedOrder_subst_of_forall_ne_zero._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (a ≤ iInf f) = ∀ (i : ι), a ≤ f i | null | false |
CategoryTheory.congrArg_cast_hom_left | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (p : X = Y) (q : Y ⟶ Z),
cast ⋯ q = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom p) q | Reducible form of `congrArg_mpr_hom_left` | true |
Topology.IsInducing.mk | Mathlib.Topology.Defs.Induced | ∀ {X : Type u_1} {Y : Type u_2} [tX : TopologicalSpace X] [tY : TopologicalSpace Y] {f : X → Y},
tX = TopologicalSpace.induced f tY → Topology.IsInducing f | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.