name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.IsRegularEpi.w | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.IsRegularEpi f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.IsRegularEpi.left f) f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.IsRegularEpi.right f) f | The coequalizer condition. | true |
Algebra.TensorProduct.lift._proof_7 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_2} {S : Type u_3} {C : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring C] [inst_4 : Algebra S C] [inst_5 : Algebra R C] [IsScalarTower R S C],
LinearMap.CompatibleSMul C C R S | null | false |
TopologicalSpace.NonemptyCompacts.instDiscreteUniformity | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] [DiscreteUniformity α],
DiscreteUniformity (TopologicalSpace.NonemptyCompacts α) | null | true |
CategoryTheory.Limits.limitConeOfEqualizerAndProduct._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J C) [inst_2 : CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor F.obj)]
[inst_3 : CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun f =... | null | false |
Aesop.RuleResult.proved | Aesop.Search.Expansion | Array Aesop.RappRef → Aesop.RuleResult | null | true |
Nat.log_zero_right | Mathlib.Data.Nat.Log | ∀ (b : ℕ), Nat.log b 0 = 0 | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.weierstrassP_add_coe_aux._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | null | false |
Functor.map_map | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} {α β γ : Type u_1} [inst : Functor f] [LawfulFunctor f] (m : α → β) (g : β → γ) (x : f α),
g <$> m <$> x = (fun a => g (m a)) <$> x | null | true |
Function.Embedding.swap_apply | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq β] (f : α ↪ β) (x y z : α),
(Equiv.swap (f x) (f y)) (f z) = f ((Equiv.swap x y) z) | null | true |
CategoryTheory.PresheafIsFinite | Mathlib.CategoryTheory.Subfunctor.Finite | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Functor Cᵒᵖ (Type w) → Prop | A presheaf is "finite" if it is generated by finitely many sections. | true |
lp.instInnerProductSpace._proof_3 | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {ι : Type u_2} {𝕜 : Type u_1} [inst : RCLike 𝕜] {G : ι → Type u_3} [inst_1 : (i : ι) → NormedAddCommGroup (G i)]
[inst_2 : (i : ι) → InnerProductSpace 𝕜 (G i)] (f₁ f₂ g : ↥(lp G 2)),
∑' (i : ι), inner 𝕜 (↑(f₁ + f₂) i) (↑g i) = ∑' (i : ι), inner 𝕜 (↑f₁ i) (↑g i) + ∑' (i : ι), inner 𝕜 (↑f₂ i) (↑g i) | null | false |
Set.mem_inv_smul_set_iff | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {A : Set β} {a : α} {x : β},
x ∈ a⁻¹ • A ↔ a • x ∈ A | null | true |
AddGroupSeminorm.instMax | Mathlib.Analysis.Normed.Group.Seminorm | {E : Type u_3} → [inst : AddGroup E] → Max (AddGroupSeminorm E) | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.extractLsb'_append_of_lt._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ {k w i : ℕ}, ∀ j < w, i * w ≤ (k - 1) * w → ¬i * w + j < (k - 1) * w + w → False | null | false |
Lean.Meta.FunInd.Collector.main | Lean.Meta.Tactic.FunIndCollect | Lean.Meta.FunIndInfo → Lean.MVarId → Lean.MetaM (Array Lean.Expr) | null | true |
_private.Mathlib.Analysis.Convex.DoublyStochasticMatrix.0.convex_doublyStochastic._simp_1_3 | Mathlib.Analysis.Convex.DoublyStochasticMatrix | ∀ {α : Type u_1} {a b : α} [inst : AddZeroClass α] [inst_1 : Preorder α] [AddLeftMono α],
0 ≤ a → 0 ≤ b → (0 ≤ a + b) = True | null | false |
instDiscreteTopologySignType | Mathlib.Topology.Instances.Sign | DiscreteTopology SignType | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling.0.SimpleGraph.EdgeLabeling.ext_get.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} (motive : ↑G.edgeSet → Prop) (h : ↑G.edgeSet),
(∀ (e : Sym2 V) (he : e ∈ G.edgeSet), motive ⟨e, he⟩) → motive h | null | false |
OrderInfSet.choose | Mathlib.Order.Bounds.Basic | {α : Type u_1} → [inst : Preorder α] → α → OrderInfSet α | Noncomputably constructs an `OrderInfSet` using the axiom of choice,
where `sInf s` returns `d` if a greatest lower bound does not exist. | true |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.nodes._f | Mathlib.Tactic.Widget.StringDiagram | ℕ →
(x : Mathlib.Tactic.BicategoryLike.WhiskerLeft) →
Mathlib.Tactic.BicategoryLike.WhiskerLeft.below (motive := fun x =>
ℕ → ℕ → List Mathlib.Tactic.Widget.StringDiagram.Node) x →
ℕ → ℕ → List Mathlib.Tactic.Widget.StringDiagram.Node | null | false |
Std.DHashMap.Internal.Raw₀.getKey!_inter_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, m₁.contains k = false → (m₁.inter m₂).getKey! k = default | null | true |
_private.Init.Data.List.Nat.Erase.0.List.getElem?_eraseIdx._proof_1_3 | Init.Data.List.Nat.Erase | ∀ {α : Type u_1} {l : List α} {i j : ℕ}, j < i → i ≤ j → False | null | false |
Mathlib.Tactic.Ring.Common.ExBaseNat._sizeOf_inst | Mathlib.Tactic.Ring.Common | (e : Q(ℕ)) → SizeOf (Mathlib.Tactic.Ring.Common.ExBaseNat e) | null | false |
Std.DHashMap.Const.getKey!_unitOfList_of_mem | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α] {l : List α}
{k k' : α},
(k == k') = true →
List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (Std.DHashMap.Const.unitOfList l).getKey! k' = k | null | true |
IsDedekindDomain.instCommRingFiniteAdeleRing._aux_15 | 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] →
IsDedekindDomain.FiniteAdeleRing R K →
IsDedekindDomain.FiniteAdeleRing R K → IsDe... | null | false |
contMDiff_finset_sum | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {H : Type u_3}
[inst_1 : TopologicalSpace H] {E : Type u_4} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E]
{I : ModelWithCorners 𝕜 E H} {G : Type u_5} [inst_4 : AddCommMonoid G] [inst_5 : TopologicalSpace G]
[inst_... | **Alias** of `contMDiff_finsetSum`. | true |
Mathlib.Tactic.BicategoryLike.HorizontalComp.of.injEq | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | ∀ (η η_1 : Mathlib.Tactic.BicategoryLike.WhiskerRight),
(Mathlib.Tactic.BicategoryLike.HorizontalComp.of η = Mathlib.Tactic.BicategoryLike.HorizontalComp.of η_1) = (η = η_1) | null | true |
Std.DHashMap.Raw.Const.any_eq_false_iff_forall_mem_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.any p = false ↔ ∀ (a : α) (h : a ∈ m), p a (Std.DHashMap.Raw.Const.get m a h) = false) | null | true |
_private.Batteries.Data.List.Lemmas.0.List.isPrefixOf.match_1.eq_3 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (a : α) (as : List α) (b : α) (bs : List α)
(h_1 : (x : List α) → motive [] x) (h_2 : (x : List α) → motive x [])
(h_3 : (a : α) → (as : List α) → (b : α) → (bs : List α) → motive (a :: as) (b :: bs)),
(match a :: as, b :: bs with
| [], x => h_1 x
| x... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int16.reduceAdd._regBuiltin.Int16.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.1259268813._hygCtx._hyg.68 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
RatFunc.numDenom.eq_1 | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] (x : RatFunc K),
x.numDenom =
x.liftOn'
(fun p q =>
if q = 0 then (0, 1)
else
have r := gcd p q;
(Polynomial.C (q / r).leadingCoeff⁻¹ * (p / r), Polynomial.C (q / r).leadingCoeff⁻¹ * (q / r)))
⋯ | null | true |
Std.DTreeMap.Internal.RciSlice | Std.Data.DTreeMap.Internal.Zipper | (α : Type u_1) → (α → Type u_2) → [Ord α] → Type (max u_2 u_1) | null | true |
Profinite.Extend.functor | Mathlib.Topology.Category.Profinite.Extend | {I : Type u} →
[inst : CategoryTheory.SmallCategory I] →
{F : CategoryTheory.Functor I FintypeCat} →
(c : CategoryTheory.Limits.Cone (F.comp FintypeCat.toProfinite)) →
CategoryTheory.Functor I (CategoryTheory.StructuredArrow c.pt FintypeCat.toProfinite) | Given a cone in `Profinite`, consisting of finite sets and indexed by a cofiltered category,
we obtain a functor from the indexing category to `StructuredArrow c.pt toProfinite`.
| true |
Lean.ImportM.Context.casesOn | Lean.Environment | {motive : Lean.ImportM.Context → Sort u} →
(t : Lean.ImportM.Context) →
((env : Lean.Environment) → (opts : Lean.Options) → motive { env := env, opts := opts }) → motive t | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertMany_list'._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 |
FirstOrder.Language.BoundedFormula.IsPrenex.rec | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {motive : {n : ℕ} → (a : L.BoundedFormula α n) → a.IsPrenex → Prop},
(∀ {n : ℕ} {φ : L.BoundedFormula α n} (h : φ.IsQF), motive φ ⋯) →
(∀ {n : ℕ} {φ : L.BoundedFormula α (n + 1)} (h : φ.IsPrenex), motive φ h → motive φ.all ⋯) →
(∀ {n : ℕ} {φ : L.BoundedFormula α (n ... | null | false |
Lean.Expr.collectMVars | Lean.Util.CollectMVars | Lean.CollectMVars.State → Lean.Expr → Lean.CollectMVars.State | null | true |
List.any_eq_true | Init.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, l.any p = true ↔ ∃ x ∈ l, p x = true | null | true |
Std.TreeSet.Raw.isSome_get?_iff_mem._simp_1 | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {a : α}, ((t.get? a).isSome = true) = (a ∈ t) | null | false |
Set.range_eq_singleton_iff | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α} [Nonempty ι] {y : α}, Set.range f = {y} ↔ ∀ (x : ι), f x = y | null | true |
ContinuousAt.const_vadd | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : VAdd M α] [ContinuousConstVAdd M α]
[inst_3 : TopologicalSpace β] {g : β → α} {b : β}, ContinuousAt g b → ∀ (c : M), ContinuousAt (c +ᵥ g) b | null | true |
Mathlib.Util.TermReduce.betaStx | Mathlib.Util.TermReduce | Lean.ParserDescr | `beta% t` elaborates `t` and then if the result is in the form
`f x1 ... xn` where `f` is a (nested) lambda expression,
it will substitute all of its arguments by beta reduction.
This does not recursively do beta reduction, nor will it do
beta reduction of subexpressions.
In particular, `t` is elaborated, its metavari... | true |
UInt16.toNat_not | Init.Data.UInt.Bitwise | ∀ (a : UInt16), (~~~a).toNat = UInt16.size - 1 - a.toNat | null | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_12 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (ht₀ : 0 < table.size),
(∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) → table[table.size - 1] < table.size | null | false |
Finset.weightedVSubOfPoint_smul | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {k : Type u_1} {V : Type u_2} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V] {ι : Type u_4}
{G : Type u_6} [inst_3 : Group G] [inst_4 : DistribMulAction G V] [SMulCommClass G k V] (s : Finset ι) (w : ι → k)
(p : ι → V) (b : V) (a : G), (s.weightedVSubOfPoint (a • p) b) w = a • (s.weightedVSubOfPo... | null | true |
ManyOneDegree.le_add_right | Mathlib.Computability.Reduce | ∀ (d₁ d₂ : ManyOneDegree), d₂ ≤ d₁ + d₂ | null | true |
Set.instInhabited | Mathlib.Data.Set.Basic | {α : Type u} → Inhabited (Set α) | null | true |
AddOpposite.op.eq_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1}, AddOpposite.op = PreOpposite.op' | null | true |
add_neg_neg_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b : α}, b + -a < 0 ↔ b < a | null | true |
_private.Mathlib.NumberTheory.LSeries.Injectivity.0.LSeries.eq_of_LSeries_eventually_eq._simp_1_1 | Mathlib.NumberTheory.LSeries.Injectivity | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
PartOrdEmb.Hom._sizeOf_inst | Mathlib.Order.Category.PartOrdEmb | (X Y : PartOrdEmb) → SizeOf (X.Hom Y) | null | false |
Lean.PersistentArray.Stats.mk.inj | Lean.Data.PersistentArray | ∀ {numNodes depth tailSize numNodes_1 depth_1 tailSize_1 : ℕ},
{ numNodes := numNodes, depth := depth, tailSize := tailSize } =
{ numNodes := numNodes_1, depth := depth_1, tailSize := tailSize_1 } →
numNodes = numNodes_1 ∧ depth = depth_1 ∧ tailSize = tailSize_1 | null | true |
CategoryTheory.Abelian.Ext.mk₀_id_comp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n),
(CategoryTheory.Abelian.Ext.mk₀ (CategoryTheory.CategoryStruct.id X)).comp α ⋯ = α | null | true |
List.Nat.antidiagonalTuple._f | Mathlib.Data.Fin.Tuple.NatAntidiagonal | (x : ℕ) → Nat.below (motive := fun x => ℕ → List (Fin x → ℕ)) x → ℕ → List (Fin x → ℕ) | null | false |
OrderIso.orderIsoCongr | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
{δ : Type u_5} →
[inst : LE α] → [inst_1 : LE β] → [inst_2 : LE γ] → [inst_3 : LE δ] → α ≃o γ → β ≃o δ → α ≃o β ≃ (γ ≃o δ) | Transport an `OrderIso` across a pair of `OrderIso`s, by pre- and post-composition.
This is `Equiv.equivCongr`/`RelIso.relIsoCongr` for `OrderIso`. | true |
Set.MapsTo.extendDomain | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {p : β → Prop} [inst : DecidablePred p] {f : α ≃ Subtype p} {g : Equiv.Perm α}
{s t : Set α}, Set.MapsTo (⇑g) s t → Set.MapsTo (⇑(g.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t) | null | true |
Lean.Lsp.instFromJsonLeanFileProgressKind._sparseCasesOn_1 | Lean.Data.Lsp.Extra | {ε : Type u} →
{α : Type v} →
{motive : Except ε α → Sort u_1} →
(t : Except ε α) → ((a : α) → motive (Except.ok a)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.ChosenPullbacksAlong.Over.leftUnitor_inv_left_fst | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
(Z : CategoryTheory.Over X),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left (CategoryTheory.MonoidalCategoryStruct.leftUnitor Z).inv)
(CategoryTheory.ChosenPullbacksAlong.fst... | null | true |
Std.DTreeMap.Internal.Impl.alter._proof_15 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced) (d : Std.DTreeMap.Internal.Impl α β)
(hd : d.Balanced) (hd'₁ : l'.size - 1 ≤ d.size) (hd'₂ : d.size ≤ l'.size + 1),
(Std.DTreeMap.Internal.Im... | null | false |
Vector.getElem_ofFn | Init.Data.Vector.OfFn | ∀ {i : ℕ} {α : Type u_1} {n : ℕ} {f : Fin n → α} (h : i < n), (Vector.ofFn f)[i] = f ⟨i, h⟩ | null | true |
ByteArray.extract_add_left | Init.Data.ByteArray.Lemmas | ∀ {b : ByteArray} {i j : ℕ}, b.extract (i + j) i = ByteArray.empty | null | true |
CategoryTheory.Discrete.sumEquiv.match_3 | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_2} →
{K : Type u_1} →
(motive : CategoryTheory.Discrete (J ⊕ K) → Sort u_3) →
(x : CategoryTheory.Discrete (J ⊕ K)) → ((x : J ⊕ K) → motive { as := x }) → motive x | null | false |
RingHom.smulOneHom_eq_algebraMap | Mathlib.Algebra.Algebra.Defs | ∀ {R : Type u} {A : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
RingHom.smulOneHom = algebraMap R A | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity.0.SimpleGraph.isEdgeReachable_two._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {R : Type u_1} [inst : AddMonoidWithOne R], 2 = 1 + 1 | null | false |
Nat.prime_five | Mathlib.Data.Nat.Prime.Defs | Nat.Prime 5 | null | true |
Lean.Diff.instBEqAction | Lean.Util.Diff | BEq Lean.Diff.Action | null | true |
MeasureTheory.Measure.measure_subtype_coe_eq_zero_of_comap_eq_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.NullMeasurableSet s μ →
∀ {t : Set ↑s}, (MeasureTheory.Measure.comap Subtype.val μ) t = 0 → μ (Subtype.val '' t) = 0 | null | true |
UInt16.ofNatLT_finVal | Init.Data.UInt.Lemmas | ∀ (n : Fin UInt16.size), UInt16.ofNatLT ↑n ⋯ = UInt16.ofFin n | null | true |
Hypergraph.mk.congr_simp | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_4} (vertexSet vertexSet_1 : Set α) (e_vertexSet : vertexSet = vertexSet_1)
(edgeSet edgeSet_1 : Set (Set α)) (e_edgeSet : edgeSet = edgeSet_1)
(subset_vertexSet_of_mem_edgeSet' : ∀ ⦃e : Set α⦄, e ∈ edgeSet → e ⊆ vertexSet),
{ vertexSet := vertexSet, edgeSet := edgeSet, subset_vertexSet_of_mem_edgeSe... | null | true |
_private.Mathlib.Tactic.Order.Preprocessing.0.Mathlib.Tactic.Order.preprocessFacts.match_1 | Mathlib.Tactic.Order.Preprocessing | (motive : Mathlib.Tactic.Order.OrderType → Sort u_1) →
(orderType : Mathlib.Tactic.Order.OrderType) →
(Unit → motive Mathlib.Tactic.Order.OrderType.pre) →
(Unit → motive Mathlib.Tactic.Order.OrderType.part) →
(Unit → motive Mathlib.Tactic.Order.OrderType.lin) → motive orderType | null | false |
MeasureTheory.integral_div_right_eq_self | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_2} {E : Type u_3} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
{μ : MeasureTheory.Measure G} [inst_3 : Group G] [MeasurableMul G] [μ.IsMulRightInvariant] (f : G → E) (g : G),
∫ (x : G), f (x / g) ∂μ = ∫ (x : G), f x ∂μ | null | true |
CategoryTheory.IndParallelPairPresentation._sizeOf_1 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} →
{f g : A ⟶ B} → [SizeOf C] → CategoryTheory.IndParallelPairPresentation f g → ℕ | null | false |
CocompactMap.comp_apply | Mathlib.Topology.ContinuousMap.CocompactMap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] (f : CocompactMap β γ) (g : CocompactMap α β) (a : α), (f.comp g) a = f (g a) | null | true |
_private.Mathlib.RingTheory.GradedAlgebra.TensorProduct.0.GradedAlgebra.baseChange._simp_1 | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {s : Set M}
{p : Submodule R M}, (Submodule.span R s ≤ p) = (s ⊆ ↑p) | null | false |
AddSubmonoid.toSubmonoid._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {A : Type u_1} [inst : AddZeroClass A] (x : Submonoid (Multiplicative A)),
(fun S => { carrier := ⇑Multiplicative.toAdd ⁻¹' ↑S, mul_mem' := ⋯, one_mem' := ⋯ })
((fun S => { carrier := ⇑Multiplicative.ofAdd ⁻¹' ↑S, add_mem' := ⋯, zero_mem' := ⋯ }) x) =
x | null | false |
continuous_of_discreteTopology | Mathlib.Topology.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [DiscreteTopology α] {β : Type u_2} [inst_2 : TopologicalSpace β]
{f : α → β}, Continuous f | null | true |
_private.Mathlib.Data.PNat.Find.0.PNat.find_le_iff._simp_1_1 | Mathlib.Data.PNat.Find | ∀ {a b : ℕ+}, (a ≤ b) = (a < b + 1) | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.σ_σ₀Iter._proof_1_11 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ {m : ℕ} (j : Fin (m + 1)), ∀ k ≤ j.castSucc, k ≤ j.castSucc | null | false |
_private.Lean.DocString.Extension.0.Lean.builtinDocStrings._proof_1 | Lean.DocString.Extension | Nonempty (ST.Ref IO.RealWorld (Lean.NameMap String)) | null | false |
Sigma.instVAddAssocClassOfVAdd | Mathlib.Algebra.Group.Action.Sigma | ∀ {ι : Type u_1} {M : Type u_2} {N : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → VAdd M (α i)]
[inst_1 : (i : ι) → VAdd N (α i)] [inst_2 : VAdd M N] [∀ (i : ι), VAddAssocClass M N (α i)],
VAddAssocClass M N ((i : ι) × α i) | null | true |
Lean.Elab.RecKind.noConfusion | Lean.Elab.DeclModifiers | {P : Sort v✝} → {x y : Lean.Elab.RecKind} → x = y → Lean.Elab.RecKind.noConfusionType P x y | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Unique.0.MeasureTheory.Measure.haarScalarFactor_eq_mul._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {n m : NNReal}, (↑n = ↑m) = (n = m) | null | false |
Representation.Equiv.symm_apply_apply | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
{ρ : Representation A G V} {σ : Representation A G W} (φ : ρ.Equiv σ) (v : V), φ.symm (φ v) = v | null | true |
Antivary.add_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : AddCommGroup β] [inst_2 : LinearOrder β]
[IsOrderedAddMonoid β] {f : ι → α} {g₁ g₂ : ι → β}, Antivary f g₁ → Antivary f g₂ → Antivary f (g₁ + g₂) | null | true |
PowerSeries.«_aux_Mathlib_RingTheory_PowerSeries_WeierstrassPreparation___macroRules_PowerSeries_term_/ʷ__1» | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | Lean.Macro | null | false |
Function.iterate_fixed | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} {f : α → α} {x : α}, f x = x → ∀ (n : ℕ), f^[n] x = x | null | true |
CommGrpCat.uliftFunctor_preservesLimitsOfSize | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)} CommGrpCat.uliftFunctor | The universe lift for commutative groups preserves limits of arbitrary size.
| true |
Rep.invariantsAdjunction_homEquiv_apply_hom._proof_1 | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_2) (G : Type u_3) [inst : CommRing k] [inst_1 : Group G] {X : ModuleCat k} {Y : Rep.{u_1, u_2, u_3} k G}
(f : (Rep.trivialFunctor k G).obj X ⟶ Y) (c : ↑((Rep.trivialFunctor k G).obj X)),
(Rep.Hom.hom f).toLinearMap c ∈ Y.ρ.invariants | null | false |
_private.Mathlib.Algebra.Homology.TotalComplexShift.0.HomologicalComplex₂.D₂_totalShift₁XIso_hom._proof_1_2 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ (x n₀ n₁ n₀' n₁' : ℤ), n₀ + x = n₀' → n₁ + x = n₁' → n₀ + 1 = n₁ → ∀ (p q : ℤ), p + q = n₀ → p + x + (q + 1) = n₁' | null | false |
Array.mkArray8 | Init.Prelude | {α : Type u} → α → α → α → α → α → α → α → α → Array α | Create array `#[a₁, a₂, a₃, a₄, a₅, a₆, a₇, a₈]` | true |
MonomialOrder.degree_X | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] [Nontrivial R] {s : σ},
m.degree (MvPolynomial.X s) = fun₀ | s => 1 | null | true |
RKHS.kernel_span_singleton | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] {H : Type u_4} [inst_3 : NormedAddCommGroup H] [inst_4 : InnerProductSpace 𝕜 H]
[inst_5 : RKHS 𝕜 H X V] [CompleteSpace H] [inst_7 : CompleteSpace V] (f : H),
RKHS.kernel ↥(𝕜 ∙ f)... | null | true |
TopRep.resolution | Mathlib.RepresentationTheory.Homological.ContCohomology.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : Ring k] →
[inst_1 : Group G] →
[inst_2 : TopologicalSpace k] →
[inst_3 : TopologicalSpace G] → [IsTopologicalGroup G] → TopRep k G → CochainComplex (TopRep k G) ℕ | The complex of functors whose behaviour pointwise takes an `R`-linear `G`-representation `M`
to the complex `M → C(G, M) → ⋯ → C(G, C(G,...,C(G, M))) → ⋯`
The `G`-invariant submodules of it is the homogeneous cochains (shifted by one). | true |
SSet.instUniqueHomOneTruncation₂ObjTruncatedOfNatNatTruncationSimplexCategoryStdSimplexMk._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ (y : SSet.OneTruncation₂ ((SSet.truncation 2).obj (SSet.stdSimplex.obj { len := 0 }))), default = y | null | false |
CategoryTheory.Aut.isoPerm._proof_9 | Mathlib.Algebra.Category.Grp.Basic | ∀ {α : Type u_1},
CategoryTheory.CategoryStruct.comp (GrpCat.ofHom { toFun := fun g => g.asIso.toEquiv, map_one' := ⋯, map_mul' := ⋯ })
(GrpCat.ofHom { toFun := fun g => { asIso := Equiv.toIso g }, map_one' := ⋯, map_mul' := ⋯ }) =
CategoryTheory.CategoryStruct.id ↧(CategoryTheory.Aut α) | null | false |
LightCondensed.lanLightCondSet | Mathlib.Condensed.Discrete.Colimit | Type u → LightCondSet | `lanPresheaf (locallyConstantPresheaf X)` as a light condensed set.
| true |
Lean.PersistentHashMap.Entry.recOn | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type w} →
{motive : Lean.PersistentHashMap.Entry α β σ → Sort u_1} →
(t : Lean.PersistentHashMap.Entry α β σ) →
((key : α) → (val : β) → motive (Lean.PersistentHashMap.Entry.entry key val)) →
((node : σ) → motive (Lean.PersistentHashMap.Entry.... | null | false |
CategoryTheory.Functor.pointwiseLeftKanExtensionCompIsoOfPreserves_hom_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | null | true |
FirstOrder.Language.BoundedFormula.iSup | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} →
{α : Type u'} → {β : Type v'} → {n : ℕ} → [Finite β] → (β → L.BoundedFormula α n) → L.BoundedFormula α n | Take the disjunction of a finite set of formulas.
Note that this is an arbitrary formula defined using the axiom of choice. It is only well-defined up
to equivalence of formulas. | true |
cmp_compares | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : α), (cmp a b).Compares a b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.