name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Grind.State.instanceMap | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.State → Std.HashMap Lean.Name Lean.Meta.Grind.EMatchTheorem | Accumulated E-matching instance map for precise unused lemma tracking.
Only populated when `config.markInstances` is `true`. | true |
MonoidAlgebra.lift._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_1) (A : Type u_2) (M : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Monoid M] (F : MonoidAlgebra R M →ₐ[R] A),
(fun F => MonoidAlgebra.liftNCAlgHom (Algebra.ofId R A) F ⋯) ((fun f => (↑f).comp (MonoidAlgebra.of R M)) F) = F | null | false |
NonemptyInterval.instCommSemiringOfCanonicallyOrderedAdd._proof_21 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommSemiring α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α], MulLeftMono α | null | false |
CategoryTheory.prod.prodμ_unitIso_hom_app | Mathlib.CategoryTheory.Products.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (A : Type u₄)
[inst_3 : CategoryTheory.Category.{v₄, u₄} A] (X : (A × C) × D × E),
(CategoryTheory.prod.prodμ C D E A).unitIso.hom.app... | null | true |
_private.Mathlib.CategoryTheory.Iso.0.CategoryTheory.Iso.homFromEquiv._proof_1 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (α : X ≅ Y) {Z : C},
Function.LeftInverse (fun g => CategoryTheory.CategoryStruct.comp α.hom g) fun f =>
CategoryTheory.CategoryStruct.comp α.inv f | null | false |
CategoryTheory.Functor.Elements.representableByOfIsInitial._proof_3 | Mathlib.CategoryTheory.Limits.Elements | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_3)}
{E : F.Elements} (he : CategoryTheory.Limits.IsInitial E) {X X' : C} (f : X ⟶ X') (g : X' ⟶ Opposite.unop E.obj),
{ toFun := fun f => (CategoryTheory.ConcreteCategory.hom (F.map f.op)) E.val,
invFun :=... | null | false |
Set.disjoint_image_left | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, Disjoint (f '' s) t ↔ Disjoint s (f ⁻¹' t) | null | true |
DividedPowerAlgebra.Rel.recOn | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ {R : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{motive : (a a_1 : MvPolynomial (ℕ × M) R) → DividedPowerAlgebra.Rel R M a a_1 → Prop}
{a a_1 : MvPolynomial (ℕ × M) R} (t : DividedPowerAlgebra.Rel R M a a_1),
motive 0 0 ⋯ →
(∀ {a : M}, motive (MvPolynom... | null | false |
SimpleGraph.cliqueSet | Mathlib.Combinatorics.SimpleGraph.Clique | {α : Type u_1} → SimpleGraph α → ℕ → Set (Finset α) | The `n`-cliques in a graph as a set. | true |
Metric.unitSphere.instGroup | Mathlib.Analysis.Normed.Field.UnitBall | {𝕜 : Type u_1} → [inst : NormedDivisionRing 𝕜] → Group ↑(Metric.sphere 0 1) | null | true |
CategoryTheory.Grp.tensorUnit_one | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C], CategoryTheory.MonObj.one = CategoryTheory.MonObj.one | null | true |
Std.DTreeMap.size_insertIfNew_le | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{v : β k}, (t.insertIfNew k v).size ≤ t.size + 1 | null | true |
Finmap.keysLookupEquiv._proof_4 | Mathlib.Data.Finmap | ∀ {α : Type u_1} {β : α → Type u_2} [inst : DecidableEq α] (x : { f // ∀ (i : α), (f.2 i).isSome = true ↔ i ∈ f.1 }),
⟨({ entries := ((↑x).1.sigma fun i => ((↑x).2 i).toFinset).val, nodupKeys := ⋯ }.keys, fun i =>
Finmap.lookup i { entries := ((↑x).1.sigma fun i => ((↑x).2 i).toFinset).val, nodupKeys := ⋯ }),... | null | false |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Option.isSome.match_1.splitter | Mathlib.Computability.TuringMachine.PostTuringMachine | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((val : α) → motive (some val)) → (Unit → motive none) → motive x | null | true |
HNNExtension.NormalWord.TransversalPair.mk.inj | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} {inst : Group G} {A B : Subgroup G} {set : ℤˣ → Set G}
{compl : ∀ (u : ℤˣ), Subgroup.IsComplement (↑(HNNExtension.toSubgroup A B u)) (set u)} {set_1 : ℤˣ → Set G}
{compl_1 : ∀ (u : ℤˣ), Subgroup.IsComplement (↑(HNNExtension.toSubgroup A B u)) (set_1 u)},
{ set := set, compl := compl } = { set := ... | null | true |
Lake.BuildTrace.checkAgainstTime | Lake.Build.Trace | {i : Type u_1} → [Lake.GetMTime i] → i → Lake.BuildTrace → BaseIO Bool | Check if the info is up-to-date using modification time.
That is, check if the info is newer than this input trace's modification time.
| true |
CategoryTheory.Equivalence.ε_comp_map_ε_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] {Z : C}
(h : e.in... | null | true |
Matrix.of_symm_single | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : Zero α] (i : m)
(j : n) (a : α), Matrix.of.symm (Matrix.single i j a) = Pi.single i (Pi.single j a) | null | true |
CategoryTheory.ProjectiveResolution.extAddEquivCohomologyClass_symm_apply | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.ProjectiveResolution X) {n : ℕ}
(a : CochainComplex.HomComplex.CohomologyClass R.cochainComplex ((CochainComplex.singleFunctor C 0).obj Y) ↑n),
R.extAddEqui... | null | true |
UInt16.toUInt8_eq | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), a.toUInt8 = b.toUInt8 ↔ a % 256 = b % 256 | null | true |
SupHom.comp_apply | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Max α] [inst_1 : Max β] [inst_2 : Max γ] (f : SupHom β γ)
(g : SupHom α β) (a : α), (f.comp g) a = f (g a) | null | true |
Std.DHashMap.Raw.getEntry! | Std.Data.DHashMap.Raw | {α : Type u} →
{β : α → Type v} → [BEq α] → [Hashable α] → [Inhabited ((a : α) × β a)] → Std.DHashMap.Raw α β → α → (a : α) × β a | Checks if a mapping for the given key exists and returns the key-value pair if it does, otherwise panics.
The key in the returned pair will be `BEq` to the input `a`.
| true |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.fundamentalSequence_has_prop._simp_1_9 | Mathlib.SetTheory.Ordinal.Notation | ∀ {α : Type u_1} {b : α} [inst : AddZeroClass α] [inst_1 : LT α] [AddLeftStrictMono α] [AddLeftReflectLT α] (a : α),
(a < a + b) = (0 < b) | null | false |
Std.ExtHashSet.eq_empty_iff_size_eq_zero | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α],
m = ∅ ↔ m.size = 0 | null | true |
Nat.Upto.succ._proof_1 | Mathlib.Data.Nat.Upto | ∀ {p : ℕ → Prop} (x : Nat.Upto p), ¬p ↑x → ∀ j < (↑x).succ, ¬p j | null | false |
Filter.neBot_iff._simp_1 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {f : Filter α}, (f ≠ ⊥) = f.NeBot | null | false |
Std.Roo.mk.noConfusion | Init.Data.Range.Polymorphic.PRange | {α : Type u} →
{P : Sort u_1} →
{lower upper lower' upper' : α} → lower<...upper = lower'<...upper' → (lower ≍ lower' → upper ≍ upper' → P) → P | null | false |
Lean.SyntaxNode.getKind | Lean.Syntax | Lean.SyntaxNode → Lean.SyntaxNodeKind | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.elabs | Lean.Elab.MutualInductive | Lean.Elab.Command.FinalizeContext✝ → Array Lean.Elab.Command.InductiveElabStep2 | null | true |
ISize.neg_mul | Init.Data.SInt.Lemmas | ∀ (a b : ISize), -a * b = -(a * b) | null | true |
CategoryTheory.GradedObject.mapBifunctorLeftUnitorCofanIsColimit._proof_4 | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {C : Type u_6} {D : Type u_2} {I : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : Zero I] [inst_3 : DecidableEq I]
[inst_4 : CategoryTheory.Limits.HasInitial C] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) (X : C)
(... | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.ideal_mono | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Monotone AlgebraicGeometry.Scheme.IdealSheafData.ideal | null | true |
LinearMap.BilinForm.tensorDistribEquiv._proof_2 | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | ∀ (R : Type u_1) [inst : CommRing R], SMulCommClass R R R | null | false |
Fin.valOrderEmb_apply | Mathlib.Order.Fin.Basic | ∀ (n : ℕ) (self : Fin n), (Fin.valOrderEmb n) self = ↑self | null | true |
CategoryTheory.Grothendieck.final_map | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat}
(α : F ⟶ G) [hα : ∀ (X : C), (α.app X).toFunctor.Final], (CategoryTheory.Grothendieck.map α).Final | The functor `Grothendieck.map α` for a natural transformation `α : F ⟶ G`, with
`F G : C ⥤ Cat`, is final if for each `X : C`, the functor `α.app X` is final. | true |
AddGroup.exponent_dvd_sub_iff_zsmul_eq_zsmul | Mathlib.GroupTheory.Exponent | ∀ {G : Type u} [inst : AddGroup G] {n m : ℤ}, ↑(AddMonoid.exponent G) ∣ n - m ↔ ∀ (g : G), n • g = m • g | null | true |
FiniteIndexNormalAddSubgroup.ext_iff | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} {inst : AddGroup G} {x y : FiniteIndexNormalAddSubgroup G}, x = y ↔ x.carrier = y.carrier | null | true |
NNRat.instMetricSpace | Mathlib.Topology.Instances.Rat | MetricSpace ℚ≥0 | null | true |
IsOpen.union | Mathlib.Topology.Basic | ∀ {X : Type u} {s₁ s₂ : Set X} [inst : TopologicalSpace X], IsOpen s₁ → IsOpen s₂ → IsOpen (s₁ ∪ s₂) | null | true |
Subalgebra.moduleLeft._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {α : Type u_3}
[inst_3 : AddCommMonoid α] [inst_4 : Module A α] (S : Subalgebra R A) (r₁ r₂ : ↥S.toSubsemiring) (x : α),
(↑r₁ + ↑r₂) • x = ↑r₁ • x + ↑r₂ • x | null | false |
OrderIso.map_csSup_of_directedOn' | Mathlib.Order.ConditionallyCompletePartialOrder.Indexed | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompletePartialOrderSup α]
[inst_1 : ConditionallyCompletePartialOrderSup β] (e : α ≃o β) {s : Set α},
DirectedOn (fun x1 x2 => x1 ≤ x2) s → s.Nonempty → BddAbove s → e (sSup s) = sSup (⇑e '' s) | null | true |
ProbabilityTheory.gaussianReal_conv_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {m₁ m₂ : ℝ} {v₁ v₂ : NNReal},
(ProbabilityTheory.gaussianReal m₁ v₁).conv (ProbabilityTheory.gaussianReal m₂ v₂) =
ProbabilityTheory.gaussianReal (m₁ + m₂) (v₁ + v₂) | The convolution of two real Gaussian distributions with means `m₁, m₂` and variances `v₁, v₂`
is a real Gaussian distribution with mean `m₁ + m₂` and variance `v₁ + v₂`. | true |
Subgroup.characteristic_iff_map_eq | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, H.Characteristic ↔ ∀ (ϕ : G ≃* G), Subgroup.map ϕ.toMonoidHom H = H | null | true |
MeasureTheory.NullMeasurableSet.smul_measure | Mathlib.MeasureTheory.Measure.Filter | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasureTheory.NullMeasurableSet s μ → ∀ (c : ENNReal), MeasureTheory.NullMeasurableSet s (c • μ) | null | true |
AddGroupSeminorm.instSupSet._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] (s : Set (AddGroupSeminorm E)), ⨆ p, ↑p 0 = 0 | null | false |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.toNat_two_pow_sub_one_sub_toInt | Init.Data.Range.Polymorphic.SInt | ∀ {n : ℕ} {lo : BitVec n}, n > 0 → (2 ^ (n - 1) - lo.toInt).toNat = 2 ^ n - (BitVec.Signed.rotate✝ lo).toNat | null | true |
NumberField.InfinitePlace.Completion.ofCompletion.inj | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} {inst : Field K} {v : NumberField.InfinitePlace K} {toCompletion toCompletion_1 : (↑v).Completion},
NumberField.InfinitePlace.Completion.ofCompletion toCompletion =
NumberField.InfinitePlace.Completion.ofCompletion toCompletion_1 →
toCompletion = toCompletion_1 | null | true |
CategoryTheory.Limits.CategoricalPullback.Hom | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
... | The Hom types for the categorical pullback are given by pairs of maps compatible with the
structural isomorphisms. | true |
CategoryTheory.Bicategory.conjugateEquiv_apply' | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d : B} {l₁ l₂ : c ⟶ d} {r₁ r₂ : d ⟶ c}
(adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁) (adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (α : l₂ ⟶ l₁),
(CategoryTheory.Bicategory.conjugateEquiv adj₁ adj₂) α =
CategoryTheory.CategoryStruct.comp (Catego... | null | true |
_private.Mathlib.LinearAlgebra.TensorProduct.Vanishing.0.TensorProduct.vanishesTrivially_of_sum_tmul_eq_zero._simp_1_4 | Mathlib.LinearAlgebra.TensorProduct.Vanishing | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | null | false |
IncidenceAlgebra.coe_sub | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_4} [inst : AddGroup 𝕜] [inst_1 : LE α] (f g : IncidenceAlgebra 𝕜 α), ⇑(f - g) = ⇑f - ⇑g | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.0.SSet.instKanComplexOp._proof_10 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex | ∀ (n : ℕ) (j k : Fin (n + 3)), j < k → ↑k.rev < n + 2 | null | false |
AddSubgroup.coe_equivMapOfInjective_apply | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_4} [inst_1 : AddGroup N] (H : AddSubgroup G) (f : G →+ N)
(hf : Function.Injective ⇑f) (h : ↥H), ↑((H.equivMapOfInjective f hf) h) = f ↑h | null | true |
SimpleGraph.Walk.support_bypass_subset_support | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} [inst : DecidableEq V] (p : G.Walk u v), p.bypass.support ⊆ p.support | null | true |
PiTensorProduct.mapL_smul | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {ι : Type u_1} [inst : Fintype ι] {𝕜 : Type u_2} {E : ι → Type u_3} [inst_1 : (i : ι) → SeminormedAddCommGroup (E i)]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)] {E' : ι → Type u_5}
[inst_4 : (i : ι) → SeminormedAddCommGroup (E' i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (E' i)]
... | null | true |
CategoryTheory.ShortComplex.Homotopy.trans._proof_8 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ φ₃ : S₁ ⟶ S₂} (h₁₂ : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂)
(h₂₃ : CategoryTheory.ShortComplex.Homotopy φ₂ φ₃),
φ₁.τ₂ =
CategoryTheory.CategoryStruct.comp ... | null | false |
Finpartition.equivSigmaParts | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : DecidableEq α] → {s : Finset α} → (P : Finpartition s) → ↥s ≃ (t : ↥P.parts) × ↥↑t | Equivalence between a finpartition's parts as a dependent sum and the partitioned set. | true |
Polynomial.Monic.leadingCoeff_C_mul | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → ∀ (r : R), (Polynomial.C r * p).leadingCoeff = r | null | true |
_private.Init.Data.Array.MapIdx.0.List.mapFinIdx.go.match_1.splitter | Init.Data.Array.MapIdx | {α : Type u_1} →
{β : Type u_2} →
(as : List α) →
(motive : (x : List α) → (x_1 : Array β) → x.length + x_1.size = as.length → Sort u_3) →
(x : List α) →
(x_1 : Array β) →
(x_2 : x.length + x_1.size = as.length) →
((acc : Array β) → (h : [].length + acc.size = as.... | null | true |
CategoryTheory.MonoidalCategory.leftAssocTensor._proof_2 | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X : C × C × C),
CategoryTheory.MonoidalCategoryStruct.tensorHom
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X).1
(CategoryTheory.CategoryStruct.id X).2.1)... | null | false |
_private.Mathlib.FieldTheory.Finite.Basic.0.termQ | Mathlib.FieldTheory.Finite.Basic | Lean.ParserDescr | null | true |
Matrix.IsTotallyNonneg | Mathlib.LinearAlgebra.Matrix.Determinant.TotallyNonneg | {ι : Type u_1} → {R : Type u_3} → [PartialOrder ι] → [CommRing R] → [PartialOrder R] → Matrix ι ι R → Prop | A matrix is totally nonnegative if all its finite minors have nonnegative determinant. | true |
CategoryTheory.MonoidalClosed.uncurry_natural_left_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X X' Y : C}
[inst_2 : CategoryTheory.Closed A] (f : X ⟶ X') (g : X' ⟶ A ⟹ Y) {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalClosed.uncurry (CategoryTheory.CategoryStruct.comp f g... | null | true |
_private.Mathlib.Analysis.Normed.Ring.Ultra.0.IsUltrametricDist.norm_add_one_le_max_norm_one._simp_1_1 | Mathlib.Analysis.Normed.Ring.Ultra | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c ≤ max a b) = (c ≤ a ∨ c ≤ b) | null | false |
AddGroupSeminorm.mk.noConfusion | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
{inst : AddGroup G} →
{P : Sort u} →
{toFun : G → ℝ} →
{map_zero' : toFun 0 = 0} →
{add_le' : ∀ (r s : G), toFun (r + s) ≤ toFun r + toFun s} →
{neg' : ∀ (r : G), toFun (-r) = toFun r} →
{toFun' : G → ℝ} →
{map_zero'' : toFun' 0 = ... | null | false |
hasSumLocallyUniformlyOn_of_forall_compact | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
IsOpen s →
∀ [LocallyCompactSpace β], (∀ K ⊆ s, IsCompact K → HasSumUniformlyOn f g K) → HasSumLocallyUniformlyOn f g s | null | true |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.isColoop_iff_forall_notMem_isCircuit._proof_1_1 | Mathlib.Combinatorics.Matroid.Loop | 1 ≠ 0 | null | false |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.tendsto_div_of_monotone_of_exists_subseq_tendsto_div._simp_1_3 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Lean.getAttributeNames | Lean.Attributes | Lean.Environment → List Lean.Name | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Deriv.0.Real.deriv_Gamma_one_eq_integral_log_log._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Gamma.Deriv | ∀ {s : ℝ} (x : ℝ),
1 < x →
x⁻¹ * ((Real.log (s - 1) + Real.log (Real.log x)) * (x ^ (-s) * x)) =
(Real.log (Real.log x) + Real.log (s - 1)) * x ^ (-s) | null | false |
SMulCommClass.symm | Mathlib.Algebra.Group.Action.Defs | ∀ (M : Type u_9) (N : Type u_10) (α : Type u_11) [inst : SMul M α] [inst_1 : SMul N α] [SMulCommClass M N α],
SMulCommClass N M α | Commutativity of actions is a symmetric relation. This lemma can't be an instance because this
would cause a loop in the instance search graph. | true |
Std.«term_..._» | Init.Data.Range.Polymorphic.PRange | Lean.TrailingParserDescr | `a...b` is the range of elements greater than or equal to `a` and less than `b`.
See also `Std.Rco`.
| true |
AddMonoidAlgebra.mapDomainRingEquiv._proof_1 | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ (R : Type u_1) {M : Type u_3} {N : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid M] [inst_2 : AddMonoid N]
(e : M ≃+ N),
(AddMonoidAlgebra.mapDomainRingHom R ↑e).comp (AddMonoidAlgebra.mapDomainRingHom R ↑e.symm) =
RingHom.id (AddMonoidAlgebra R N) | null | false |
Lean.Grind.Config.detailed | Init.Grind.Config | Lean.Grind.Config → ℕ | Minimum number of instantiations to trigger detailed report in `#grind_lint`.
Remark: this option is only relevant for the `#grind_lint` command.
| true |
Nat.testBit_add | Init.Data.Nat.Bitwise.Lemmas | ∀ (x i n : ℕ), x.testBit (i + n) = (x / 2 ^ n).testBit i | null | true |
Std.HashMap.Raw.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α Unit} [EquivBEq α] [LawfulHashable α]
[inst_4 : Inhabited α],
m.WF →
∀ {l : List α} {k k' : α},
(k == k') = true →
k ∉ m → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKey! k' = k | null | true |
Algebra.normalizedTrace_def | Mathlib.FieldTheory.NormalizedTrace | ∀ (F : Type u_1) (K : Type u_2) [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K] [inst_3 : CharZero F]
[inst_4 : Algebra.IsIntegral F K] (a : K),
(Algebra.normalizedTrace F K) a =
(↑(Module.finrank F ↥F⟮a⟯))⁻¹ • (Algebra.trace F ↥F⟮a⟯) (IntermediateField.AdjoinSimple.gen F a) | null | true |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.isCompl_opensRange_inl_inr._simp_1_1 | Mathlib.AlgebraicGeometry.Limits | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : BoundedOrder α] {a b : α},
IsCompl a b = (Disjoint a b ∧ Codisjoint a b) | null | false |
List.Vector.mem_map_succ_iff | Mathlib.Data.Vector.Mem | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} (b : β) (v : List.Vector α (n + 1)) (f : α → β),
b ∈ (List.Vector.map f v).toList ↔ f v.head = b ∨ ∃ a ∈ v.tail.toList, f a = b | null | true |
Std.Http.URI.Query.contains | Std.Http.Data.URI.Basic | Std.Http.URI.Query → String → Bool | Checks if a query parameter exists by raw key string. The key is percent-encoded before matching.
| true |
Lean.Json.arr.noConfusion | Lean.Data.Json.Basic | {P : Sort u} → {elems elems' : Array Lean.Json} → Lean.Json.arr elems = Lean.Json.arr elems' → (elems = elems' → P) → P | null | false |
Algebra.Extension.tensorToH1Cotangent._proof_10 | Mathlib.RingTheory.Extension.Cotangent.BaseChange | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (T : Type u_2)
[inst_3 : CommRing T] [inst_4 : Algebra R T], IsScalarTower R T (TensorProduct R T S) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_twoPow_of_le._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {m n : ℕ}, ¬1 < 2 → False | null | false |
CategoryTheory.Bicategory.«term⊗𝟙» | Mathlib.Tactic.CategoryTheory.BicategoricalComp | Lean.ParserDescr | Notation for identities up to unitors and associators. | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.leftActionOfMonoidalOppositeRightAction_actionHomRight | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction Cᴹᵒᵖ D] (c : C) {d d' : D} (f : d ⟶ d'),
CategoryTheory.MonoidalCategory.Monoidal... | null | true |
_private.Plausible.Testable.0.Plausible.Decorations._aux_Plausible_Testable___elabRules_Plausible_Decorations_tacticMk_decorations_1._sparseCasesOn_4 | Plausible.Testable | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Std.Net.instInhabitedSocketAddress | Std.Net.Addr | Inhabited Std.Net.SocketAddress | null | true |
CategoryTheory.Pretriangulated.shortComplexOfDistTriangleIsoOfIso | Mathlib.CategoryTheory.Triangulated.Pretriangulated | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[inst_3 : CategoryTheory.Preadditive C] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[hC : CategoryTheo... | The isomorphism between the short complex attached to
two isomorphic distinguished triangles. | true |
AbstractCompletion.uniformStruct | Mathlib.Topology.UniformSpace.AbstractCompletion | {α : Type u} → [inst : UniformSpace α] → (self : AbstractCompletion.{v, u} α) → UniformSpace self.space | The completion carries a uniform structure. | true |
Finpartition.IsEquipartition | Mathlib.Order.Partition.Equipartition | {α : Type u_1} → [inst : DecidableEq α] → {s : Finset α} → Finpartition s → Prop | An equipartition is a partition whose parts are all the same size, up to a difference of `1`. | true |
Mathlib.Tactic.ITauto.Proof.andRight.injEq | Mathlib.Tactic.ITauto | ∀ (ak : Mathlib.Tactic.ITauto.AndKind) (p : Mathlib.Tactic.ITauto.Proof) (ak_1 : Mathlib.Tactic.ITauto.AndKind)
(p_1 : Mathlib.Tactic.ITauto.Proof),
(Mathlib.Tactic.ITauto.Proof.andRight ak p = Mathlib.Tactic.ITauto.Proof.andRight ak_1 p_1) = (ak = ak_1 ∧ p = p_1) | null | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.iUnion_inf._simp_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), ⋃ i, t i ∩ s = (⋃ i, t i) ∩ s | null | false |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosDef.inv._simp_1_2 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] {A : Matrix n n α},
IsUnit A⁻¹ = IsUnit A | null | false |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.psi_sub_theta_bounds._proof_1_20 | Mathlib.NumberTheory.Chebyshev | ∀ (N₁ N₂ N₃ N₅ N₇ n : ℕ), 1 ≤ n ∧ n ≤ N₁ + N₂ + N₃ + N₅ + N₇ → 6 * n - 1 ≤ 6 * n | null | false |
_private.Lean.Compiler.LCNF.LambdaLifting.0.Lean.Compiler.LCNF.LambdaLifting.etaContractibleDecl?._sparseCasesOn_7 | Lean.Compiler.LCNF.LambdaLifting | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((declName : Lean.Name) →
(us : List Lean.Level) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.pure) →
... | null | false |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.getMsbD_ofFnBE._proof_1_5 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ), (BitVec.ofFnBE f).getMsbD i = if h : i < n then f ⟨i, h⟩ else false | null | false |
groupHomology.inhomogeneousChains.d_comp_d | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (n : ℕ),
CategoryTheory.CategoryStruct.comp (groupHomology.inhomogeneousChains.d A (n + 1))
(groupHomology.inhomogeneousChains.d A n) =
0 | null | true |
ISize.ofInt_tmod | Init.Data.SInt.Lemmas | ∀ {a b : ℤ},
ISize.minValue.toInt ≤ a →
a ≤ ISize.maxValue.toInt →
ISize.minValue.toInt ≤ b → b ≤ ISize.maxValue.toInt → ISize.ofInt (a.tmod b) = ISize.ofInt a % ISize.ofInt b | null | true |
CategoryTheory.ModObj.ofIso_smul | Mathlib.CategoryTheory.Monoidal.Mod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
{M : C} [inst_4 : CategoryTheory.MonObj M] {X : D} {N : C} [inst_5 : CategoryTheory.M... | null | true |
_private.Std.Async.Basic.0.Std.Async.Async.ofIOTask.match_1 | Std.Async.Basic | {α : Type} →
(motive : Except IO.Error (Task α) → Sort u_1) →
(__do_lift : Except IO.Error (Task α)) →
((data : Task α) → motive (Except.ok data)) → ((err : IO.Error) → motive (Except.error err)) → motive __do_lift | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.