name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousMultilinearMap.currySumEquiv._proof_11 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (ι : Type u_2) (ι' : Type u_3) (G : Type u_4) (G' : Type u_5) [inst : Fintype ι] [inst_1 : Fintype ι']
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G]
[inst_5 : NormedAddCommGroup G'] [inst_6 : NormedSpace 𝕜 G'] (f : ContinuousMultilinearMap 𝕜 (f... | null | false |
CategoryTheory.cechNerveTerminalFrom._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Limits.HasFiniteProducts C] (X : C)
(n : SimplexCategoryᵒᵖ), CategoryTheory.Limits.HasLimit (CategoryTheory.Discrete.functor fun x => X) | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance.eq_def | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : String.Slice) (patByte : UInt8) (table : Array ℕ) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (guess : ℕ) (hg : guess < table.size),
String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝ pat patByte table ht h guess hg =
if pat.getUTF8Byte { ... | null | true |
Module.Relations.instQuotient | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u_1} → [inst : Ring A] → (relations : Module.Relations A) → Module A relations.Quotient | null | true |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._proof_17 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_4} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} {S' : C} {p : S' ⟶ S} {ι' : Type u_3} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'} {α : ι' → ι}
{p' : (j : ι') → X' j ⟶ X (α j)},
(∀ (j : ι'), CategoryTheory.CategoryStruct.comp (p' j) (f (α j)) ... | null | false |
CategoryTheory.Limits.image.lift_mk_comp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasImage g] (h : Y ⟶ CategoryTheory.Limits.image g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) (CategoryTheory.Limits.image.ι g) =
CategoryTheory... | null | false |
CategoryTheory.Limits.coprod.braiding_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
(P Q : C),
(CategoryTheory.Limits.coprod.braiding P Q).inv =
CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl | null | true |
PNat.XgcdType.flip_z | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.z = u.w | null | true |
PresheafOfModules.ModuleColimit.ιM_jointly_surjective | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.LocallySmall.{w, v, u} C]
[CategoryTheory.IsCofiltered C] [CategoryTheory.InitiallySmall C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{cR : CategoryTheory.Limits.Cocone R} {hcR : CategoryTheory.Limits.IsColimit cR} {M : PresheafOfModules R}
{... | null | true |
LieSubmodule.mem_map_of_mem | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup M']
[inst_6 : Module R M'] [inst_7 : LieRingModule L M'] {f : M →ₗ⁅R,L⁆ M'} {N : LieSubmodule R L M} {m : M},
m ∈ N →... | null | true |
NegPart.mk._flat_ctor | Mathlib.Algebra.Notation | {α : Type u_1} → (α → α) → NegPart α | null | false |
Sum.smul_inl | Mathlib.Algebra.Group.Action.Sum | ∀ {M : Type u_1} {α : Type u_3} {β : Type u_4} [inst : SMul M α] [inst_1 : SMul M β] (a : M) (b : α),
a • Sum.inl b = Sum.inl (a • b) | null | true |
MulDistribMulActionHom.map_one' | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : Monoid A]
[inst_3 : MulDistribMulAction M A] {B : Type u_5} [inst_4 : Monoid B] [inst_5 : MulDistribMulAction N B]
(self : A →ₑ*[φ] B), self.toFun 1 = 1 | The proposition that the function preserves 1 | true |
Orientation.oangle_sign_neg_right | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), (o.oangle x (-y)).sign = -(o.oangle x y).sign | Negating the second vector passed to `oangle` negates the sign of the angle. | true |
CategoryTheory.Limits.limitIsoLimitCurryCompLim | Mathlib.CategoryTheory.Limits.Fubini | {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] →
(G : CategoryTheory.Functor (J × K) C) →
[inst_3 : CategoryTheory... | The Fubini theorem for a functor `G : J × K ⥤ C`,
showing that the limit of `G` can be computed as
the limit of the limits of the functors `G.obj (j, _)`.
| true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryToUnit._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
⦃X_1 Y : CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)⦄ (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruc... | null | false |
_private.Lean.Compiler.ExternAttr.0.Lean.isExternC._sparseCasesOn_2 | Lean.Compiler.ExternAttr | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
derangements.Equiv.RemoveNone.fiber | Mathlib.Combinatorics.Derangements.Basic | {α : Type u_1} → [DecidableEq α] → Option α → Set (Equiv.Perm α) | The set of permutations `f` such that the preimage of `(a, f)` under
`Equiv.Perm.decomposeOption` is a derangement. | true |
dist_neg | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] (x y : E), dist (-x) y = dist x (-y) | null | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.Subsingleton.congr._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {s : Cycle α}, s.Subsingleton = (s.length ≤ 1) | null | false |
CategoryTheory.SimplicialObject | Mathlib.AlgebraicTopology.SimplicialObject.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max v u) | The category of simplicial objects valued in a category `C`.
This is the category of contravariant functors from `SimplexCategory` to `C`. | true |
LinearIsometryEquiv.toContinuousLinearEquiv | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{E : Type u_4} →
{E₂ : Type u_5} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] →
... | Interpret a `LinearIsometryEquiv` as a `ContinuousLinearEquiv`. | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.ApproximatesLinearOn.norm_fderiv_sub_le._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] {t : Set β} {a : α} {x : β}, (x ∈ a • t) = ∃ y ∈ t, a • y = x | null | false |
cantorSequence_eq_self_sub_sum_cantorToTernary | Mathlib.Topology.Instances.CantorSet | ∀ (x : ℝ) (n : ℕ),
(cantorSequence x).get n = (x - ∑ i ∈ Finset.range n, Real.ofDigitsTerm (cantorToTernary x).get i) * 3 ^ n | null | true |
sum_chartAt_inr_apply | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u} {M : Type u_2} {M' : Type u_3} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M'] [cm : ChartedSpace H M] [cm' : ChartedSpace H M'] {x y : M'},
↑(chartAt H (Sum.inr x)) (Sum.inr y) = ↑(chartAt H x) y | null | true |
Batteries.UnionFind.equiv_empty._simp_1 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ}, Batteries.UnionFind.empty.Equiv a b = (a = b) | null | false |
IsRadical.dvd_radical | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M}, IsRadical a → a ≠ 0 → a ∣ UniqueFactorizationMonoid.radical a | If `a` is a radical element, then it divides its radical. | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSomeRev?_eq_some_iff.match_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {f : Fin n → Option α}
(motive : (∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none) → Prop)
(x : ∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none),
(∀ (i : Fin n) (h : f i.rev = some a ∧ ∀ j < i, f j.rev = none), motive ⋯) → motive x | null | false |
Pi.nonAssocSemiring._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocSemiring (f i)] (a : (i : I) → f i), 1 * a = a | null | false |
CategoryTheory.ObjectProperty.IsClosedUnderQuotients.prop_of_epi | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.ObjectProperty C}
[self : P.IsClosedUnderQuotients] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f], P X → P Y | null | true |
instMetricSpaceEmpty._proof_5 | Mathlib.Topology.MetricSpace.Defs | ∀ (x x : Empty), 0 = 0 | null | false |
Hypergraph.IsNonempty.of_nonempty_vertexSet | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_1} {H : Hypergraph α}, H.vertexSet.Nonempty → H.IsNonempty | null | true |
CategoryTheory.Regular.regularEpiIsStableUnderBaseChange | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Regular C],
(CategoryTheory.MorphismProperty.regularEpi C).IsStableUnderBaseChange | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.isPrimitiveRoot_exp_of_isCoprime._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (↑n * x) | null | false |
groupHomology.δ_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)}
(hX : X.ShortExact) {i j : ℕ} (hij : j + 1 = i) (z : (Fin i → G) →₀ ↑X.X₃)
(hz : (CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains X.X₃).d i j)) z = 0)
(y : (Fin i → G) →₀ ↑X.X₂),
... | null | true |
Lean.Elab.Command.instMonadMacroAdapterCommandElabM | Lean.Elab.Command | Lean.Elab.MonadMacroAdapter Lean.Elab.Command.CommandElabM | null | true |
Std.DTreeMap.Internal.Impl.WF.casesOn | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{β : α → Type v} {a : Std.DTreeMap.Internal.Impl α β} (t : a.WF),
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} (a : t.Balanced) (a_1 : ∀ [Std.TransOrd α], t.Ordered),
motive t ⋯) →
(∀... | null | false |
_private.Mathlib.Algebra.Order.Group.Indicator.0.Function.mulSupport_iSup._simp_1_3 | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
CategoryTheory.Limits.WalkingMulticospan.functorExt.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
(motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u_3) →
(j : CategoryTheory.Limits.WalkingMulticospan J) →
((i : J.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((i : J.R) → motive (CategoryTheory.Limits.WalkingMulticospan.... | null | false |
_private.Lean.Data.Options.0.Lean.Options.mk.inj | Lean.Data.Options | ∀ {map : Lean.NameMap Lean.DataValue} {hasTrace : Bool} {map_1 : Lean.NameMap Lean.DataValue} {hasTrace_1 : Bool},
{ map := map, hasTrace := hasTrace } = { map := map_1, hasTrace := hasTrace_1 } → map = map_1 ∧ hasTrace = hasTrace_1 | null | true |
Std.Sat.AIG.RelabelNat.State.Inv2.below.gate | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)}
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1 → Prop} {idx : ℕ}
{map : Std.HashMap α ℕ} {l r : Std.Sat.AIG.Fanin} (hinv : Std.Sat.AIG.RelabelNat.State.Inv2 decls idx map)
(h... | null | true |
Turing.TM2to1.StAct.casesOn | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{motive : Turing.TM2to1.StAct K Γ σ k → Sort u} →
(t : Turing.TM2to1.StAct K Γ σ k) →
((a : σ → Γ k) → motive (Turing.TM2to1.StAct.push a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct... | null | false |
Std.Rcc.size_eq_ite_rcc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxc.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[Std.Rxc.IsAlwaysFinite α] [Std.Rxc.LawfulHasSize α],
r.size =
if r.lower ≤ r.upper then
... | null | true |
Fin.insertNth_mul | Mathlib.Algebra.Group.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (j : Fin (n + 1)) → Mul (α j)] (i : Fin (n + 1)) (x y : α i)
(p q : (j : Fin n) → α (i.succAbove j)), i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q | null | true |
SemiNormedGrp.explicitCokernelIso_hom_desc | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y Z : SemiNormedGrp} {f : X ⟶ Y} {g : Y ⟶ Z} (w : CategoryTheory.CategoryStruct.comp f g = 0),
CategoryTheory.CategoryStruct.comp (SemiNormedGrp.explicitCokernelIso f).hom
(CategoryTheory.Limits.cokernel.desc f g w) =
SemiNormedGrp.explicitCokernelDesc w | null | true |
UInt16.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin UInt16.size), (UInt16.ofFin x).toNat = ↑x | null | true |
Std.DHashMap.values | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → List β | Returns a list of all values present in the hash map in some order. | true |
Set.Nonempty.image2 | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
s.Nonempty → t.Nonempty → (Set.image2 f s t).Nonempty | null | true |
_private.Init.Data.List.Basic.0.List.dropLast.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) →
((head : α) → motive [head]) → ((a : α) → (as : List α) → (as = [] → False) → motive (a :: as)) → motive x | null | true |
MeasureTheory.Measure.WeaklyRegular.recOn | Mathlib.MeasureTheory.Measure.Regular | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : μ.WeaklyRegular → Sort u} →
(t : μ.WeaklyRegular) →
([toOuterRegular : μ.OuterRegular] → (innerRegular : μ.InnerRegularWRT IsClosed IsOpen) → motive ⋯) →
... | null | false |
LinearIsometry.comp_continuous_iff._simp_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂) {α : Type u_9} [inst_6 : TopologicalSpace α] {g : α ... | null | false |
CategoryTheory.ShortComplex.toCyclesNatTrans | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasKernels C] →
[inst_3 : CategoryTheory.Limits.HasCokernels C] →
CategoryTheory.ShortComplex.π₁ ⟶ CategoryTheory.ShortComplex.cyclesFuncto... | The natural transformation `S.X₁ ⟶ S.cycles` for all short complexes `S`. | true |
LieAlgebra.SpecialLinear.val_single | Mathlib.Algebra.Lie.Classical | ∀ {n : Type u_1} {R : Type u₂} [inst : CommRing R] [inst_1 : DecidableEq n] [inst_2 : Fintype n] (i j : n) (h : i ≠ j)
(r : R), ↑((LieAlgebra.SpecialLinear.single i j h) r) = Matrix.single i j r | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Deriv.0.Real.iter_deriv_rpow_const._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ (r : ℝ) (k : ℕ) (y : ℝ),
y ^ (r - ↑k - 1) = y ^ (r - (↑k + 1)) ∨ Polynomial.eval r (descPochhammer ℝ k) = 0 ∨ r - ↑k = 0 | null | false |
CategoryTheory.Pseudofunctor.Grothendieck.Hom.fiber | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{X Y : F.Grothendieck} → (self : X.Hom Y) → (F.map self.base.toLoc).toFunctor.obj X.fiber ⟶ Y.fiber | The morphism in the fiber over the domain. | true |
Set.ordConnected_pi' | Mathlib.Order.Interval.Set.OrdConnected | ∀ {ι : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → Preorder (α i)] {s : Set ι} {t : (i : ι) → Set (α i)}
[h : ∀ (i : ι), (t i).OrdConnected], (s.pi t).OrdConnected | null | true |
CategoryTheory.MorphismProperty.LeftFraction.noConfusionType | Mathlib.CategoryTheory.Localization.CalculusOfFractions | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
W.LeftFraction X Y →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{W' : CategoryTheory.MorphismPr... | null | false |
Task.get | Init.Core | {α : Type u} → Task α → α | Blocks the current thread until the given task has finished execution, and then returns the result
of the task. If the current thread is itself executing a (non-dedicated) task, the maximum
threadpool size is temporarily increased by one while waiting so as to ensure the process cannot
be deadlocked by threadpool starv... | true |
CategoryTheory.ChosenPullbacksAlong.binaryFanIsBinaryProduct._proof_4 | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong Z.hom] {T : CategoryTheory.Over X} (f : T ⟶ Y) (g : T ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.homMk
(CategoryTheory.ChosenPullbacksAl... | null | false |
SimpleGraph.neighborSet_ne_univ | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) (v : V), G.neighborSet v ≠ Set.univ | null | true |
AddSubmonoid.le_toAddSubmonoid_saturation | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {a : AddSubmonoid M}, a ≤ a.saturation.toAddSubmonoid | null | true |
FinPartOrd._sizeOf_1 | Mathlib.Order.Category.FinPartOrd | FinPartOrd → ℕ | null | false |
LeftOrdContinuous.rightOrdContinuous_dual | Mathlib.Order.OrdContinuous | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
LeftOrdContinuous f → RightOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) | **Alias** of `LeftOrdContinuous.dual`. | true |
Lean.Grind.CommRing.Poly.denote_combineC | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(p₁ p₂ : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (p₁.combineC p₂ c) =
Lean.Grind.CommRing.Poly.denote ctx p₁ + Lean.Grind.CommRing.Poly.denote ctx p₂ | null | true |
HahnEmbedding.Seed.rec | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
... | null | false |
geom_sum_mul_of_le_one | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [AddLeftReflectLE R] [AddLeftMono R]
[ExistsAddOfLE R] [inst_5 : Sub R] [OrderedSub R] {x : R},
x ≤ 1 → ∀ (n : ℕ), (∑ i ∈ Finset.range n, x ^ i) * (1 - x) = 1 - x ^ n | null | true |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_1 | Mathlib.Tactic.Linter.FindDeprecations | (motive : Lean.Name × Lean.Syntax.Range → Sort u_1) →
(x : Lean.Name × Lean.Syntax.Range) →
((decl : Lean.Name) → (s e : String.Pos.Raw) → motive (decl, { start := s, stop := e })) → motive x | null | false |
_private.Mathlib.RingTheory.PowerSeries.Substitution.0.PowerSeries.substInvFun.match_1.splitter | Mathlib.RingTheory.PowerSeries.Substitution | (motive : ℕ → Sort u_1) →
(x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → (n = 0 → False) → motive n.succ) → motive x | null | true |
Lean.Parser.Command.versoCommentBody.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
AlgebraicGeometry.instIsOpenImmersionMapScheme | Mathlib.AlgebraicGeometry.Morphisms.OpenImmersion | ∀ {X Y X' Y' : AlgebraicGeometry.Scheme} (f : X ⟶ X') (g : Y ⟶ Y') [AlgebraicGeometry.IsOpenImmersion f]
[AlgebraicGeometry.IsOpenImmersion g], AlgebraicGeometry.IsOpenImmersion (CategoryTheory.Limits.coprod.map f g) | null | true |
cfc_nonneg_of_predicate._simp_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [inst_9 : LE A]
[inst_10 : ContinuousFunctionalCalculus... | null | false |
Std.TreeMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ \ t₂)[k]? = none | null | true |
TrivSqZeroExt.kerIdeal._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Ideal | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [IsCentralScalar R M], SMulCommClass R Rᵐᵒᵖ M | null | false |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.of_eq.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char}
(motive :
(x : Substring.Raw) →
x.str.toList = l ++ m ++ r →
x.startPos.byteIdx = String.utf8Len l → x.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Prop)
(x : Substring.Raw) (x_1 : x.str.toList = l ++ m ++ r) (x_2 : x.startPos.byteIdx = String.utf8Len l)
(x_3 : x... | null | false |
Std.HashMap.insertMany_ind | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {ρ : Type w} [inst : ForIn Id ρ (α × β)]
{motive : Std.HashMap α β → Prop} (m : Std.HashMap α β) {l : ρ},
motive m → (∀ (m : Std.HashMap α β) (a : α) (b : β), motive m → motive (m.insert a b)) → motive (m.insertMany l) | null | true |
CochainComplex.mappingCone.trianglehMapOfHomotopy_hom₂ | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁}
{φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂}
(H : Homotopy (CategoryTheory.CategoryStruct.comp φ₁ b) (Catego... | null | true |
Std.TreeSet.get!_ofList_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.ofList l cmp).get! k' = k | null | true |
WithZero.decidableEq | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_1} → [DecidableEq α] → DecidableEq (WithZero α) | null | true |
Std.ExtTreeMap.minEntry.match_1 | Std.Data.ExtTreeMap.Basic | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering}
(motive : (t : Std.ExtTreeMap α β cmp) → t ≠ ∅ → t.inner = ∅ → Prop) (t : Std.ExtTreeMap α β cmp) (h : t ≠ ∅)
(x : t.inner = ∅), motive t h x | null | false |
Mathlib.Tactic.Algebra.pushCast | Mathlib.Tactic.Algebra.Basic | Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result | Push `algebraMap`s into sums and products and convert `algebraMap`s from `ℕ`, `ℤ` and `ℚ`
into casts. | true |
Finsupp.domCongr_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (e : α ≃ β) (l : α →₀ M),
(Finsupp.domCongr e) l = Finsupp.equivMapDomain e l | null | true |
Lean.Compiler.LCNF.CodeDecl.collectUsed | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.CodeDecl pu → optParam Lean.FVarIdHashSet ∅ → Lean.FVarIdHashSet | null | true |
String.Slice.toInt?_eq_toNat?_of_startsWith_eq_false | Std.Data.String.ToInt | ∀ {s : String.Slice}, s.startsWith '-' = false → s.toInt? = Option.map (fun n => ↑n) s.toNat? | null | true |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff._simp_1_2 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
RootPairing.EmbeddedG2.shortAddLong.eq_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : 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)
[inst_5 : P.EmbeddedG2],
RootPairing.EmbeddedG2.shortAddLong P =
(P.reflectionPerm (RootPairing.EmbeddedG2... | null | true |
instMinNat | Init.Prelude | Min ℕ | null | true |
Function.Injective.isLeftCancelAdd | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Add M₂] [IsLeftCancelAdd M₂] (f : M₁ → M₂),
Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → IsLeftCancelAdd M₁ | A type has left-cancellative addition, if it admits an injective map that
preserves `+` to another type with left-cancellative addition. | true |
Inclusion.InclusionM.Context.noConfusionType | Mathlib.Tactic.Inclusion.Core.Types | Sort u → Inclusion.InclusionM.Context → Inclusion.InclusionM.Context → Sort u | null | false |
Order.Frame.toDistribLattice._proof_1 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} [inst : Order.Frame α] (a b c : α), a ⊓ (b ⊔ c) ≤ a ⊓ b ⊔ a ⊓ c | null | false |
List.toFinset_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s : List α) (p : α → Bool),
(List.filter p s).toFinset = {x ∈ s.toFinset | p x = true} | null | true |
SSet.horn_ι_mem_innerHornInclusions | Mathlib.AlgebraicTopology.Quasicategory.InnerFibration | ∀ {n : ℕ} {i : Fin (n + 1)}, 0 < i → i < Fin.last n → SSet.innerHornInclusions (SSet.horn n i).ι | null | true |
Subgroup.isFiniteRelIndex_map_powMonoidHom_of_fg | Mathlib.GroupTheory.FiniteAbelian.Basic | ∀ {A : Type u_1} [inst : CommGroup A] {B : Subgroup A},
B.FG → ∀ {n : ℕ}, n ≠ 0 → (Subgroup.map (powMonoidHom n) B).IsFiniteRelIndex B | null | true |
UniformSpaceCat.completionFunctor._proof_2 | Mathlib.Topology.Category.UniformSpace | ∀ {X Y Z : UniformSpaceCat} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.ConcreteCategory.ofHom
⟨UniformSpace.Completion.map ⇑(CategoryTheory.CategoryStruct.comp f g).hom', ⋯⟩).hom) =
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct... | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.noConfusionType | Init.Data.Format.Basic | Sort u → Std.Format.WorkGroup✝ → Std.Format.WorkGroup✝ → Sort u | null | false |
integral_bilinear_hasLineDerivAt_right_eq_neg_left_of_integrable | Mathlib.Analysis.Calculus.LineDeriv.IntegrationByParts | ∀ {E : Type u_1} {F : Type u_2} {G : Type u_3} {W : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
[inst_6 : NormedAddCommGroup W] [inst_7 : NormedSpace ℝ W] [inst_8 : Measurable... | **Integration by parts for line derivatives**
Version with a general bilinear form `B`.
If `B f g` is integrable, as well as `B f' g` and `B f g'` where `f'` and `g'` are derivatives
of `f` and `g` in a given direction `v`, then `∫ B f g' = - ∫ B f' g`. | true |
BitVec.instHashable | Init.Data.BitVec.Basic | {n : ℕ} → Hashable (BitVec n) | null | true |
Aesop.Frontend.instInhabitedPriority.default | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority | null | true |
OrderRingHom.comp_id | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocSemiring α] [inst_1 : Preorder α] [inst_2 : NonAssocSemiring β]
[inst_3 : Preorder β] (f : α →+*o β), f.comp (OrderRingHom.id α) = f | null | true |
isLinearSet_iff_exists_fin_addMonoidHom | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsLinearSet s ↔ ∃ a n f, s = a +ᵥ Set.range ⇑f | null | true |
Real.sin_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), Real.sin (x + ↑n * (2 * Real.pi)) = Real.sin x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.