name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Meta.Defs.0.Lean.Syntax.getTailInfo?.match_1 | Init.Meta.Defs | (motive : Lean.Syntax → Sort u_1) →
(x : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive (Lean.Syntax.atom info val)) →
((info : Lean.SourceInfo) →
(rawVal : Substring.Raw) →
(val : Lean.Name) →
(preresolved : List Lean.Syntax.Preresolved) → motive (Lea... | null | false |
_private.Lean.DocString.Syntax.0.Lean.Doc.Syntax.link._regBuiltin.Lean.Doc.Syntax.link.docString_1 | Lean.DocString.Syntax | IO Unit | null | false |
Set.ncard_lt_card | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α} [Finite α], s ≠ Set.univ → s.ncard < Nat.card α | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) | null | false |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.mkSyntaxAndPat | Lean.Elab.MacroArgUtil | Option Lean.Ident → Lean.Term → Lean.TSyntax `stx → Lean.Elab.Command.CommandElabM (Lean.TSyntax `stx × Lean.Term) | null | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra.0.IntermediateField.algebraAdjoinAdjoin.instIsFractionRingSubtypeMemSubalgebraAdjoinAdjoin.match_3 | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ (F : Type u_2) [inst : Field F] {E : Type u_1} [inst_1 : Field E] [inst_2 : Algebra F E] (S : Set E)
(motive : ↥(IntermediateField.adjoin F S) → Prop) (x : ↥(IntermediateField.adjoin F S)),
(∀ (val : E) (h : val ∈ IntermediateField.adjoin F S), motive ⟨val, h⟩) → motive x | null | false |
Odd.pow_injective | Mathlib.Algebra.Order.Ring.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R] [ExistsAddOfLE R] {n : ℕ},
Odd n → Function.Injective fun x => x ^ n | null | true |
CompHausLike.LocallyConstant.counitAppAppImage | Mathlib.Condensed.Discrete.LocallyConstant | {P : TopCat → Prop} →
[inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
{S : CompHausLike P} →
{Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u w))} →
[inst_1 : CompHausLike.HasProp P PUnit.{u + 1}] →
(f : LocallyConstant (↑S.toTop) (Y.o... | The projection of the counit. | true |
Finsupp.optionElim | Mathlib.Data.Finsupp.Option | {α : Type u_1} → {M : Type u_2} → [inst : Zero M] → M → (α →₀ M) → Option α →₀ M | Extend a finitely supported function on `α` to a finitely supported function on `Option α`,
provided a default value for `none`.
| true |
_private.Init.Data.UInt.Bitwise.0.UInt32.and_eq_neg_one_iff._simp_1_2 | Init.Data.UInt.Bitwise | ∀ {w : ℕ} {x y : BitVec w}, (x &&& y = BitVec.allOnes w) = (x = BitVec.allOnes w ∧ y = BitVec.allOnes w) | null | false |
CategoryTheory.WideSubcategory.instMonoidalCategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : P.IsMonoidalStable]
{X₁ Y₁ X₂ Y₂ : CategoryTheory.WideSubcategory P} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
(CategoryTheory.wideSubcategoryInclusion P).map (CategoryT... | null | false |
_private.Lean.Parser.Extra.0.Lean.Parser.ppLine._regBuiltin.Lean.Parser.ppLine.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
Set.isUnit_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : DivisionMonoid α] {s : Set α}, IsUnit s ↔ ∃ a, s = {a} ∧ IsUnit a | null | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.isIH._sparseCasesOn_1 | Lean.Meta.IndPredBelow | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Util.Diff.0.Lean.Diff.lcs.match_8 | Lean.Util.Diff | {α : Type} →
(left right : Subarray α) →
(motive : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right)) → Sort u_1) →
(best : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right))) →
((fst : ℕ) →
(v : α) →
(li : Fin (Std.Slice.size left)... | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.Action.mkAndThenSeq._sunfold | Lean.Meta.Tactic.Grind.Split | List (Lean.TSyntax `grind) → Lean.CoreM (Lean.TSyntax `grind) | null | false |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.inverse._proof_5 | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle Cᵒᵖ} (φ : T₁ ⟶ T₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Pretriangulated.Triangle.mk T₂.mor₂.unop T₂.mor₁.unop
(CategoryTheory.Category... | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.finset_inf_span_singleton._simp_1_2 | Mathlib.RingTheory.Ideal.Operations | ∀ {α : Type u} [inst : CommSemiring α] {x y : α}, (x ∈ Ideal.span {y}) = (y ∣ x) | null | false |
Lean.Level.imax.injEq | Lean.Level | ∀ (a a_1 a_2 a_3 : Lean.Level), (a.imax a_1 = a_2.imax a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
_private.Init.Data.SInt.Bitwise.0.Int16.shiftRight_or._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int16}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
fromModuleCatToModuleCatLinearEquivtoModuleCatObj.eq_1 | Mathlib.RingTheory.Morita.Matrix | ∀ (R : Type u) {ι : Type v} [inst : Ring R] [inst_1 : Fintype ι] [inst_2 : DecidableEq ι] (M : Type u_1)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] (i : ι),
fromModuleCatToModuleCatLinearEquivtoModuleCatObj R M i =
{ toFun := (AddEquiv.refl ↑(((ModuleCat.toMatrixModCat R ι).comp (MatrixModCat.toModuleCat R... | null | true |
_private.Mathlib.NumberTheory.Height.NumberField.0.NumberField.one_le_pow_totalWeight_mul_finprod | Mathlib.NumberTheory.Height.NumberField | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {n : ℕ},
n ≠ 0 →
∀ (a : NumberField.RingOfIntegers K),
1 ≤ ↑n ^ Height.totalWeight K * ∏ᶠ (v : NumberField.FinitePlace K), ⨆ i, v (![↑a, ↑n] i) | null | true |
Lean.Widget.instToJsonRpcEncodablePacket.toJson._@.Lean.Widget.InteractiveGoal.1924226853._hygCtx._hyg.48 | Lean.Widget.InteractiveGoal | Lean.Widget.RpcEncodablePacket✝ → Lean.Json | null | false |
Pi.counit_comp_finsuppLcoeFun | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Type u_4}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : CoalgebraStruct R M],
CoalgebraStruct.counit ∘ₗ Finsupp.lcoeFun = CoalgebraStruct.counit | null | true |
CategoryTheory.Endofunctor.Algebra.Hom.mk.congr_simp | 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 f_1 : A₀.a ⟶ A₁.a) (e_f : f = f_1)
(h : CategoryTheory.CategoryStruct.comp (F.map f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str f),
{ f := f, h := h } = { f := f_1, h... | null | true |
FreeAddMonoid.lift_restrict | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : AddMonoid M] (f : FreeAddMonoid α →+ M),
FreeAddMonoid.lift (⇑f ∘ FreeAddMonoid.of) = f | null | true |
MultilinearMap.mk._flat_ctor | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] →
[inst_4 : Module R M₂] →
... | null | false |
HomologicalComplex.singleMapHomologicalComplex_inv_app_ne | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] [inst_4 : CategoryTheory.Limits.HasZeroObject W₁]
[inst_5 : Cat... | null | true |
MvPolynomial.monomial_one_mul_cancel_right_iff | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p q : MvPolynomial σ R} {m : σ →₀ ℕ},
p * (MvPolynomial.monomial m) 1 = q * (MvPolynomial.monomial m) 1 ↔ p = q | null | true |
CategoryTheory.MonoidalCategoryStruct.recOn | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
[𝒞 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.MonoidalCategoryStruct C → Sort u_1} →
(t : CategoryTheory.MonoidalCategoryStruct C) →
((tensorObj : C → C → C) →
(whiskerLeft : (X : C) → {Y₁ Y₂ : C} → (Y₁ ⟶ Y₂) → (tensorObj X Y₁ ⟶ tensorObj X Y₂)) →
... | null | false |
Encodable.decodeSum.eq_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Encodable α] [inst_1 : Encodable β] (n : ℕ),
Encodable.decodeSum n =
match n.bodd, n.div2 with
| false, m => Option.map Sum.inl (Encodable.decode m)
| x, m => Option.map Sum.inr (Encodable.decode m) | null | true |
_private.Mathlib.Topology.Separation.Regular.0.exists_mem_nhds_isClosed_subset._proof_1_2 | Mathlib.Topology.Separation.Regular | 4 ≠ 0 | null | false |
_private.Mathlib.Topology.ContinuousMap.StoneWeierstrass.0.ContinuousMap.ker_evalStarAlgHom_inter_adjoin_id._simp_1_5 | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
mul_isLeftRegular_iff._simp_2 | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : Semigroup R] {a : R} (b : R), IsLeftRegular a → IsLeftRegular (a * b) = IsLeftRegular b | null | false |
SemiRingCat.FilteredColimits.semiringObj._aux_8 | Mathlib.Algebra.Category.Ring.FilteredColimits | {J : Type u_2} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J SemiRingCat) →
(j : J) → NSMul (((F.comp (CategoryTheory.forget₂ SemiRingCat MonCat)).comp (CategoryTheory.forget MonCat)).obj j) | null | false |
Nat.map_add_toList_ric | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n k : ℕ}, List.map (fun x => x + k) (*...=n).toList = (k...=n + k).toList | null | true |
CoxeterMatrix.E₆._proof_2 | Mathlib.GroupTheory.Coxeter.Matrix | ∀ (i : Fin 6),
!![1, 2, 3, 2, 2, 2; 2, 1, 2, 3, 2, 2; 3, 2, 1, 3, 2, 2; 2, 3, 3, 1, 3, 2; 2, 2, 2, 3, 1, 3; 2, 2, 2, 2, 3, 1] i i = 1 | null | false |
Lean.Grind.PowIdentity.rec | Init.Grind.Ring.Basic | {α : Type u} →
[inst : Lean.Grind.CommSemiring α] →
{p : ℕ} →
{motive : Lean.Grind.PowIdentity α p → Sort u_1} →
((pow_eq : ∀ (x : α), x ^ p = x) → motive ⋯) → (t : Lean.Grind.PowIdentity α p) → motive t | null | false |
ZFSet.Hereditarily.eq_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (p : ZFSet.{u_1} → Prop) (x : ZFSet.{u_1}), ZFSet.Hereditarily p x = (p x ∧ ∀ y ∈ x, ZFSet.Hereditarily p y) | null | true |
scalarSMulCLE._proof_1 | Mathlib.Analysis.InnerProductSpace.StandardSubspace | ∀ (H : Type u_1) [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H], ContinuousConstSMul ℂˣ H | null | false |
IsUniformInducing.isUltraUniformity | Mathlib.Topology.UniformSpace.Ultra.Completion | ∀ {X : Type u_1} {Y : Type u_2} [inst : UniformSpace X] [inst_1 : UniformSpace Y] [IsUltraUniformity Y] {f : X → Y},
IsUniformInducing f → IsUltraUniformity X | null | true |
CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._proof_28 | Mathlib.CategoryTheory.Bicategory.Monad.Basic | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B],
autoParam
(∀ {a b c : CategoryTheory.Bicategory.OplaxTrans.ComonadBicat B} {f g : a ⟶ b} {h i : b ⟶ c} (η : f ⟶ g)
(θ : h ⟶ i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.OplaxTrans.ComonadBicat.inst._aux_9 f θ)
(Categ... | null | false |
MeasureTheory.measurable_cylinderEvents_iff | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {α : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {mα : MeasurableSpace α} [m : (i : ι) → MeasurableSpace (X i)]
{Δ : Set ι} {g : α → (i : ι) → X i}, Measurable g ↔ ∀ ⦃i : ι⦄, i ∈ Δ → Measurable fun a => g a i | null | true |
CategoryTheory.InjectiveResolution.Hom.mk.injEq | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} {I : CategoryTheory.InjectiveResolution Z} {Z' : C}
{I' : CategoryTheory.InjectiveResolution Z'} {f : Z ⟶ Z'} (hom : I.cocomplex ⟶ I'.cocomplex)
(ι_... | null | true |
Quiver.Path.getElem_vertices_zero._proof_1 | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a b : V} (p : Quiver.Path a b), 0 < p.vertices.length | null | false |
HomologicalComplex.natIsoSc'_inv_app_τ₂ | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i j k : ι) (hi : c.prev j = i) (hk : c.next j = k) (X : HomologicalComplex C c),
((HomologicalComplex.natIsoSc' C c i j k hi hk).inv.app X).τ₂ = CategoryTheory.Cate... | null | true |
Submodule.instIsModularLattice | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_10} {M : Type u_11} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsModularLattice (Submodule R M) | null | true |
isStarProjection_iff_eq_starProjection_range | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {p : E →L[𝕜] E},
IsStarProjection p ↔ ∃ (x : (↑p).range.HasOrthogonalProjection), p = (↑p).range.starProjection | An operator is a star projection if and only if it is an orthogonal projection. | true |
BoundedOrderHom.toOrderHom | Mathlib.Order.Hom.Bounded | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : BoundedOrder α] → [inst_3 : BoundedOrder β] → BoundedOrderHom α β → α →o β | null | true |
AddAut.applyAddAction._proof_2 | Mathlib.Algebra.Group.Action.End | ∀ {M : Type u_1} [inst : AddMonoid M] (x : M), 0 +ᵥ x = 0 +ᵥ x | null | false |
HomologicalComplex₂.totalFlipIso_hom_f_D₁ | Mathlib.Algebra.Homology.TotalComplexSymmetry | ∀ {C : Type u_1} {I₁ : Type u_2} {I₂ : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Preadditive C] {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
(K : HomologicalComplex₂ C c₁ c₂) (c : ComplexShape J) [inst_2 : TotalComplexShape c₁ c₂ c]
[inst_3 : TotalComplexShap... | null | true |
CategoryTheory.Limits.HasImage.exists_image | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y}
[self : CategoryTheory.Limits.HasImage f], Nonempty (CategoryTheory.Limits.ImageFactorisation f) | `HasImage f` means that there exists an image factorisation of `f`. | true |
LinearOrder.OfStdArgs.isLinearOrder | Mathlib.Order.Std | ∀ {α : Type u_1} (self : LinearOrder.OfStdArgs α),
let this := self.le;
Std.IsLinearOrder α | ≤ forms a linear order. | true |
ContinuousLinearMap.IsPositive.isSelfAdjoint | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {T : E →L[𝕜] E}, T.IsPositive → IsSelfAdjoint T | null | true |
_private.Mathlib.LinearAlgebra.Dual.Defs.0.LinearMap.range_dualMap_dual_eq_span_singleton.match_1_3 | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R M₁]
(f m : Module.Dual R M₁) (motive : (∃ a, a • f = m) → Prop) (x : ∃ a, a • f = m),
(∀ (r : R) (hr : r • f = m), motive ⋯) → motive x | null | false |
Ordinal.uniqueIioOne._proof_1 | Mathlib.SetTheory.Ordinal.Basic | 0 < 1 | null | false |
_private.Mathlib.Analysis.CStarAlgebra.Commutative.PosPart.0.CStarAlgebra.Commute.posPart_mono._simp_1_3 | Mathlib.Analysis.CStarAlgebra.Commutative.PosPart | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Star A]
[inst_3 : Module R A] {S : Type w''} [inst_4 : SetLike S A] [inst_5 : NonUnitalSubsemiringClass S A]
[hSR : SMulMemClass S R A] [inst_6 : StarMemClass S A] {s : S} (x : ↥s),
↑x = (NonUnitalStarSubalgebraCl... | null | false |
CategoryTheory.ShortComplex.homologyFunctorIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] [CategoryTheory... | null | false |
CategoryTheory.Limits.Sigma.constCompSigmaIsoConst_hom_app | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasCoproductsOfShape α C] {I : α → Type u_1}
[inst_2 : (i : α) → CategoryTheory.Category.{v_1, u_1} (I i)] (X : α → C) (X_1 : (i : α) → I i),
(CategoryTheory.Limits.Sigma.constCompSigmaIsoConst X).hom.app X_1 = ... | null | true |
CategoryTheory.Bicategory._aux_Mathlib_CategoryTheory_Bicategory_Adjunction_Basic___unexpand_CategoryTheory_Bicategory_Adjunction_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | Lean.PrettyPrinter.Unexpander | null | false |
Equiv.permCongrHom_symm | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} (e : α ≃ β), e.permCongrHom.symm = e.symm.permCongrHom | null | true |
ZMod.prime_ne_zero | Mathlib.Data.ZMod.ValMinAbs | ∀ (p q : ℕ) [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)], p ≠ q → ↑q ≠ 0 | null | true |
CategoryTheory.ComposableArrows.Mk₁.obj | Mathlib.CategoryTheory.ComposableArrows.Basic | {C : Type u_1} → C → C → Fin 2 → C | The map which sends `0 : Fin 2` to `X₀` and `1` to `X₁`. | true |
String.Slice.splitInclusive | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
(s : String.Slice) → (pat : ρ) → [inst : String.Slice.Pattern.ToForwardSearcher pat σ] → Std.Iter String.Slice | Splits a slice at each subslice that matches the pattern `pat`. Unlike `split` the
matched subslices are included at the end of each subslice.
This function is generic over all currently supported patterns.
Examples:
* `("coffee tea water".toSlice.splitInclusive Char.isWhitespace).toList == ["coffee ".toSlice, "tea ... | true |
Std.Iterators.Types.Flatten.mk.inj | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type u_1} {it₁ : Std.IterM m (Std.IterM m β)} {it₂ : Option (Std.IterM m β)}
{it₁_1 : Std.IterM m (Std.IterM m β)} {it₂_1 : Option (Std.IterM m β)},
{ it₁ := it₁, it₂ := it₂ } = { it₁ := it₁_1, it₂ := it₂_1 } → it₁ = it₁_1 ∧ it₂ = it₂_1 | null | true |
IsPredArchimedean.findAtom | Mathlib.Order.SuccPred.Tree | {α : Type u_1} →
[inst : PartialOrder α] → [inst_1 : PredOrder α] → [IsPredArchimedean α] → [OrderBot α] → [DecidableEq α] → α → α | The unique atom less than an element in an `OrderBot` with archimedean predecessor.
| true |
_private.Std.Data.String.ToInt.0.String.Slice.isInt_iff._simp_1_4 | Std.Data.String.ToInt | ∀ {s : String.Slice}, s.isNat = s.toNat?.isSome | null | false |
Turing.ToPartrec.Code.fix.sizeOf_spec | Mathlib.Computability.TuringMachine.Config | ∀ (a : Turing.ToPartrec.Code), sizeOf a.fix = 1 + sizeOf a | null | true |
ContinuousMap.continuousAt | Mathlib.Topology.ContinuousMap.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : C(α, β)) (x : α),
ContinuousAt (⇑f) x | Deprecated. Use `map_continuousAt` instead. | true |
LinearMap.mapMatrix_neg | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_4} {S : Type u_5} {α : Type u_8} {β : Type u_9} [inst : Semiring R]
[inst_1 : Semiring S] {σᵣₛ : R →+* S} [inst_2 : AddCommMonoid α] [inst_3 : AddCommGroup β] [inst_4 : Module R α]
[inst_5 : Module S β] (f : α →ₛₗ[σᵣₛ] β), (-f).mapMatrix = -f.mapMatrix | null | true |
CategoryTheory.Limits.Types.Pushout.Rel'.inr_inl | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂} (s : S),
CategoryTheory.Limits.Types.Pushout.Rel' f g (Sum.inr ((CategoryTheory.ConcreteCategory.hom g) s))
(Sum.inl ((CategoryTheory.ConcreteCategory.hom f) s)) | null | true |
SSet.π₀.lift | Mathlib.AlgebraicTopology.SimplicialSet.PiZero | {X : SSet} →
{T : Type u_1} →
(f : X.obj (Opposite.op { len := 0 }) → T) →
(∀ ⦃x₀ x₁ : X.obj (Opposite.op { len := 0 })⦄ (x : SSet.Edge x₀ x₁), f x₀ = f x₁) → X.π₀ → T | Constructor for maps from the type of connected components of a simplicial set. | true |
Lean.Grind.CommRing.Poly.insert.go._f | Init.Grind.Ring.CommSolver | ℤ →
Lean.Grind.CommRing.Mon → (a : Lean.Grind.CommRing.Poly) → Lean.Grind.CommRing.Poly.below a → Lean.Grind.CommRing.Poly | null | false |
Polynomial.leadingCoeffHom | Mathlib.Algebra.Polynomial.Degree.Operations | {R : Type u} → [inst : Semiring R] → [NoZeroDivisors R] → Polynomial R →* R | `Polynomial.leadingCoeff` bundled as a `MonoidHom` when `R` has `NoZeroDivisors`, and thus
`leadingCoeff` is multiplicative | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.formula3._simp_1_1 | Mathlib.NumberTheory.FLT.Three | ∀ {α : Type u} [inst : Monoid α] (a : αˣ) (n : ℕ), ↑a ^ n = ↑(a ^ n) | null | false |
RelSeries.last_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {β : Type u_2} {s : SetRel β β} (p : RelSeries r) (f : r.Hom s),
(p.map f).last = f p.last | null | true |
Matroid.IsBase.compl_isBase_of_dual | Mathlib.Combinatorics.Matroid.Dual | ∀ {α : Type u_1} {M : Matroid α} {B : Set α}, M✶.IsBase B → M.IsBase (M.E \ B) | null | true |
MeasureTheory.measure_union_lt_top_iff | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s t : Set α},
μ (s ∪ t) < ⊤ ↔ μ s < ⊤ ∧ μ t < ⊤ | null | true |
Lean.PrettyPrinter.Parenthesizer.Context._sizeOf_1 | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer.Context → ℕ | null | false |
WittVector.equiv._proof_1 | Mathlib.RingTheory.WittVector.Compare | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (x y : WittVector p (ZMod p)),
(WittVector.toPadicInt p) (x * y) = (WittVector.toPadicInt p) x * (WittVector.toPadicInt p) y | null | false |
Lean.logInfo | Lean.Log | {m : Type → Type} →
[Monad m] → [Lean.MonadLog m] → [Lean.AddMessageContext m] → [Lean.MonadOptions m] → Lean.MessageData → m Unit | Log a new information message using the given message data. The position is provided by `getRef`. | true |
ContinuousLinearEquiv.coe_inj | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : Ad... | null | true |
Std.DTreeMap.isEmpty_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp}, t.keys.isEmpty = t.isEmpty | null | true |
list_sum_pow_char | Mathlib.Algebra.CharP.Lemmas | ∀ {R : Type u_2} [inst : CommSemiring R] (p : ℕ) [ExpChar R p] (l : List R),
l.sum ^ p = (List.map (fun x => x ^ p) l).sum | null | true |
Hypergraph.Adj | Mathlib.Combinatorics.Hypergraph.Basic | {α : Type u_1} → Hypergraph α → α → α → Prop | Predicate for adjacency. Two vertices `x` and `y` are adjacent if there is some edge `e ∈ E(H)`
where `x` and `y` are both incident to `e`.
Note that we do not need to explicitly check that `x, y ∈ V(H)` here because a vertex that is not in
the vertex set cannot be incident to any edge.
| true |
CategoryTheory.ShortComplex.FunctorEquivalence.inverse_obj_g | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(F : CategoryTheory.Functor J (CategoryTheory.ShortComplex C)),
((CategoryTheory.ShortComplex.FunctorEquivalence.inverse J C).obj F).g =... | null | true |
SSet.horn₃₂.desc._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | (SSet.horn 3 2).MulticoequalizerDiagram (fun j => SSet.stdSimplex.face {↑j}ᶜ) fun j k => SSet.stdSimplex.face {↑j, ↑k}ᶜ | null | false |
Submodule.annihilator_mono | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N P : Submodule R M}, N ≤ P → P.annihilator ≤ N.annihilator | null | true |
Finset.sdiff_eq_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s₁ s₂ : Finset α), s₁ \ s₂ = {x ∈ s₁ | x ∉ s₂} | null | true |
instDecidableEqProd._proof_2 | Init.Core | ∀ {α : Type u_2} {β : Type u_1} (a : α) (b : β) (a' : α) (b' : β), ¬b = b' → (a, b) = (a', b') → False | null | false |
_private.Std.Data.TreeMap.Raw.Lemmas.0.Std.TreeMap.Raw.Equiv.trans.match_1_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering} {t₁ t₂ t₃ : Std.TreeMap.Raw α β cmp}
(motive : t₁.Equiv t₂ → t₂.Equiv t₃ → Prop) (x : t₁.Equiv t₂) (x_1 : t₂.Equiv t₃),
(∀ (h : t₁.inner.Equiv t₂.inner) (h' : t₂.inner.Equiv t₃.inner), motive ⋯ ⋯) → motive x x_1 | null | false |
Nat.twoStepInduction | Mathlib.Data.Nat.Init | {motive : ℕ → Sort u_1} →
motive 0 → motive 1 → ((n : ℕ) → motive n → motive (n + 1) → motive (n + 2)) → (a : ℕ) → motive a | Induction principle deriving the next case from the two previous ones. | true |
Fin.coe_divNat | Batteries.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m * n)), ↑i.divNat = ↑i / n | null | true |
Std.ExtDTreeMap.maxKeyD_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k} {fallback : α},
(t.insertIfNew k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if cmp k' k = Ordering.lt then k else k' | null | true |
NormedAddGroupHom.Equalizer.lift.congr_simp | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} {V₁ : Type u_3} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
[inst_2 : SeminormedAddCommGroup V₁] {f g : NormedAddGroupHom V W} (φ φ_1 : NormedAddGroupHom V₁ V) (e_φ : φ = φ_1)
(h : f.comp φ = g.comp φ), NormedAddGroupHom.Equalizer.lift φ h = NormedAddGroupHo... | null | true |
Metric.hausdorffEDist_ne_top_of_nonempty_of_bounded | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α},
s.Nonempty → t.Nonempty → Bornology.IsBounded s → Bornology.IsBounded t → Metric.hausdorffEDist s t ≠ ⊤ | If two sets are nonempty and bounded in a metric space, they are at finite Hausdorff
edistance. | true |
codisjoint_subtype_iff | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {pr : α → Prop},
(∀ ⦃s t : α⦄, pr s → pr t → pr (s ⊔ t)) → ∀ (htop : pr ⊤) {a b : Subtype pr}, Codisjoint a b ↔ Codisjoint ↑a ↑b | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.MonotoneOn.intervalIntegral_slope_le._proof_1_11 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → ∀ x ∈ Set.Icc b (b + c), x ∈ Set.uIcc a (b + c) | null | false |
_private.Mathlib.RingTheory.IntegralClosure.Algebra.Ideal.0.Polynomial.exists_monic_aeval_eq_zero_forall_mem_of_mem_map._proof_1_2 | Mathlib.RingTheory.IntegralClosure.Algebra.Ideal | ∀ {R : Type u_1} [inst : CommRing R] (p : Polynomial R), ∀ i < p.natDegree, ¬p.natDegree - i = 0 | null | false |
LinearMap.FiniteRangeSetoid.equiv_iff_isNoetherian_quotient_eqLocus | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V : Type u_2} {V₂ : Type u_3} [inst : CommRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : AddCommGroup V₂] [inst_4 : Module K V₂] {u v : V →ₗ[K] V₂}, u ≈ v ↔ IsNoetherian K (V ⧸ u.eqLocus v) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.