name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
lift_rank_range_le | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Cardinal.lift.{v, v'} (Module.rank R ↥f.range) ≤ Cardinal.lift.{v', v} (Module.rank R M) | The rank of the range of a linear map is at most the rank of the source. | true |
Nat.lt | Init.Prelude | ℕ → ℕ → Prop | Strict inequality of natural numbers, usually accessed via the `<` operator.
It is defined as `n < m = n + 1 ≤ m`.
| true |
Dioph.«term_D*_» | Mathlib.NumberTheory.Dioph | Lean.TrailingParserDescr | Diophantine functions are closed under multiplication. | true |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic.0.IsIntegral.of_pow.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {x : B} {n : ℕ}
(motive : IsIntegral R (x ^ n) → Prop) (hx : IsIntegral R (x ^ n)),
(∀ (p : Polynomial R) (hmonic : p.Monic) (heval : Polynomial.eval₂ (algebraMap R B) (x ^ n) p = 0), motive ⋯) →
motive hx | null | false |
Turing.ToPartrec.Code.brecOn.eq | Mathlib.Computability.TuringMachine.Config | ∀ {motive : Turing.ToPartrec.Code → Sort u} (t : Turing.ToPartrec.Code)
(F_1 : (t : Turing.ToPartrec.Code) → Turing.ToPartrec.Code.below t → motive t),
Turing.ToPartrec.Code.brecOn t F_1 = F_1 t (Turing.ToPartrec.Code.brecOn.go t F_1).2 | null | true |
CategoryTheory.MonObj.mk | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
(one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
(mul : CategoryTheory.MonoidalCategoryStruct.tensorObj X X ⟶ X) →
autoParam
(C... | null | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithM | Mathlib.Tactic.DefEqAbuse | {m : Type → Type} →
[Monad m] →
{α : Type} →
{β : Type u_1} →
Array β →
(β → m α) →
autoParam α Lean.MessageData.visitWithM._auto_1✝ →
autoParam (α → α → α) Lean.MessageData.visitWithM._auto_3✝ → m α | Convenience wrapper which accumulates the results of `visitM` across `arr`, attempting to
produce `empty` and `combine` from `{}` and `(· ++ ·)` or `(· ∪ ·)`. | true |
Lean.Server.Ilean.rec | Lean.Server.References | {motive : Lean.Server.Ilean → Sort u} →
((version : ℕ) →
(module : Lean.Name) →
(directImports : Array Lean.Lsp.ImportInfo) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) →
motive
{ version := version, module := module, directImports :... | null | false |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.exists_isBasis.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) (X : Set α) (motive : (∃ J, M.IsBasis J X ∧ ∅ ⊆ J) → Prop)
(x : ∃ J, M.IsBasis J X ∧ ∅ ⊆ J), (∀ (w : Set α) (hI : M.IsBasis w X) (right : ∅ ⊆ w), motive ⋯) → motive x | null | false |
RootPairing.reflectionPerm_root | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : 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] (self : RootPairing ι R M N) (i j : ι),
self.root j - (self.toLinearMap (self.root j)) (self.coroot i) • self.root i = self.root ((self.re... | null | true |
Set.LeftInvOn.image_inter | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {f : α → β} {f' : β → α},
Set.LeftInvOn f' f s → f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s | null | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.noConfusion | Lean.DocString.Extension | {P : Sort u} →
{content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock)} →
{priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)} →
{titleString : String} →
{title : Array (Lean.Doc.Inline Lean.ElabInline)} →
{content' : Array (Lean.Doc.Block Lean.ElabInline Lean... | null | false |
Std.DTreeMap.Internal.Impl.link.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (r : Std.DTreeMap.Internal.Impl α β) (hr : r.Balanced)
(hr_2 : Std.DTreeMap.Internal.Impl.leaf.Balanced),
Std.DTreeMap.Internal.Impl.link k v Std.DTreeMap.Internal.Impl.leaf r hr_2 hr =
{ impl := (Std.DTreeMap.Internal.Impl.insertMin k v r ⋯).impl, balanced_impl... | null | true |
Filter.Germ.LiftRel._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (r : β → γ → Prop) (_f : α → β) (_g : α → γ) (_f' : α → β)
(_g' : α → γ),
(l.germSetoid β) _f _f' →
(l.germSetoid γ) _g _g' → (∀ᶠ (x : α) in l, r (_f x) (_g x)) = ∀ᶠ (x : α) in l, r (_f' x) (_g' x) | null | false |
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 | ∀ {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 |
RingEquiv.ofHomInv_symm_apply | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (g : S →+* R)
(h₁ : f.comp g = RingHom.id S) (h₂ : g.comp f = RingHom.id R) (a : S), (RingEquiv.ofRingHom f g h₁ h₂).symm a = g a | **Alias** of `RingEquiv.ofRingHom_symm_apply`. | 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_5} [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_5} →
{E₂ : Type u_6} →
[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_2} {β : Type u_3} [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 |
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_5} {E₂ : Type u_6} [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_11} [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 |
_private.Mathlib.Algebra.MvPolynomial.Variables.0.MvPolynomial.vars_rename._simp_1_1 | Mathlib.Algebra.MvPolynomial.Variables | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.toFinset) = (a ∈ s) | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.