name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Cardinal.instMul | Mathlib.SetTheory.Cardinal.Defs | Mul Cardinal.{u} | null | true |
ContinuousAlternatingMap.toContinuousMultilinearMap_zero | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N], ContinuousAlternatingMap.toContinuousMultilinearMap 0 = 0 | null | true |
Lean.Meta.Simp.ConfigWithOptions.decide._inherited_default | Lean.Elab.Tactic.Simp | Bool | null | false |
ArchimedeanClass.FiniteResidueField.instArchimedean | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
Archimedean (ArchimedeanClass.FiniteResidueField K) | null | true |
Interval.instPreorder._proof_4 | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α] (a b c : Interval α), a ≤ b → b ≤ c → a ≤ c | null | false |
Derivative.serreDerivative_smul | Mathlib.NumberTheory.ModularForms.Derivative | ∀ (k c : ℂ) (F : UpperHalfPlane → ℂ),
MDiff F → Derivative.serreDerivative k (c • F) = c • Derivative.serreDerivative k F | null | true |
RelHom.toOrderHom | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
[inst : PartialOrder α] → [inst_1 : Preorder β] → ((fun x1 x2 => x1 < x2) →r fun x1 x2 => x1 < x2) → α →o β | A bundled expression of the fact that a map between partial orders that is strictly monotone
is weakly monotone. | true |
SimplexCategory.δ₀Iter_apply | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ} (j : Fin (n + 1)) (hi : autoParam (n + i = m) SimplexCategory.δ₀Iter_apply._auto_1),
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.δ₀Iter i hi)) j = ⟨↑j + i, ⋯⟩ | null | true |
CategoryTheory.OplaxFunctor.mapComp'_comp_mapComp'_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.OplaxFunctor B C) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁)
(f₁₂ : b₁ ⟶ b₂) (f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃)
(h₀₂ : Categ... | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.lctx | Lean.Elab.MutualInductive | Lean.Elab.Command.FinalizeContext✝ → Lean.LocalContext | null | true |
FirstOrder.Language.Theory.Model.realize_of_mem | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} {inst : L.Structure M} {T : L.Theory} [self : M ⊨ T], ∀ φ ∈ T, M ⊨ φ | null | true |
Ideal.image_subset_nonunits_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] {A : Subring K} (I : Ideal ↥A),
I ≠ ⊤ → ∃ B, A ≤ B.toSubring ∧ ⇑A.subtype '' ↑I ⊆ ↑B.nonunits | null | true |
Subgroup.strictPeriods_le_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods ≤ 𝒢.periods | null | true |
and_imp._simp_1 | Init.SimpLemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
_private.Lean.Elab.PreDefinition.Structural.Main.0.Lean.Elab.Structural.structuralRecursion.match_3 | Lean.Elab.PreDefinition.Structural.Main | (motive : Option (ℕ × Subarray ℕ) → Sort u_1) →
(x : Option (ℕ × Subarray ℕ)) →
(Unit → motive none) → ((recArgPos : ℕ) → (s' : Subarray ℕ) → motive (some (recArgPos, s'))) → motive x | null | false |
_private.Lean.Meta.DecLevel.0.Lean.Meta.decAux?.match_8 | Lean.Meta.DecLevel | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((mvarId : Lean.LMVarId) → motive (Lean.Level.mvar mvarId)) →
((u : Lean.Level) → motive u.succ) → ((u : Lean.Level) → motive u) → motive x | null | false |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.sizeOf_spec | Lean.DocString.Extension | ∀ (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)),
sizeOf { content := content, priorParts := priorParts, titleString := titleString, title := title ... | null | true |
Polynomial.trailingDegree_lt_wf | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R], WellFounded fun p q => p.trailingDegree < q.trailingDegree | null | true |
Std.TreeMap.Raw.modify | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → (β → β) → Std.TreeMap.Raw α β cmp | Modifies in place the value associated with a given key.
This function ensures that the value is used linearly.
| true |
MeasureTheory.OuterMeasure.isCaratheodory_iUnion_of_disjoint | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α},
(∀ (i : ℕ), m.IsCaratheodory (s i)) → Pairwise (Function.onFun Disjoint s) → m.IsCaratheodory (⋃ i, s i) | Use `isCaratheodory_iUnion` instead, which does not require the disjoint assumption. | true |
QuadraticMap.ofPolar._proof_3 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N], SMulCommClass R R N | null | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.mem_grothendieckTopology | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} {U : X.AffineZariskiSite} {S : CategoryTheory.Sieve U},
S ∈ (AlgebraicGeometry.Scheme.AffineZariskiSite.grothendieckTopology X) U ↔
∀ x ∈ U.toOpens, ∃ V f, S.arrows f ∧ x ∈ V.toOpens | null | true |
List.isPrefixOfAux_toArray_succ' | Init.Data.List.ToArray | ∀ {α : Type u_1} [inst : BEq α] (l₁ l₂ : List α) (hle : l₁.length ≤ l₂.length) (i : ℕ),
l₁.toArray.isPrefixOfAux l₂.toArray hle (i + 1) =
(List.drop (i + 1) l₁).toArray.isPrefixOfAux (List.drop (i + 1) l₂).toArray ⋯ 0 | null | true |
RootPairing.chainBotIdx.eq_1 | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] (i j : ι),
Roo... | null | true |
AdjoinRoot.coe_ofAlgHom | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommSemiring S] [inst_2 : Algebra S R] (p : Polynomial R),
⇑(AdjoinRoot.ofAlgHom S p) = ⇑(AdjoinRoot.of p) | null | true |
ProofWidgets.HtmlDisplayProps.mk.sizeOf_spec | ProofWidgets.Component.HtmlDisplay | ∀ (html : ProofWidgets.Html), sizeOf { html := html } = 1 + sizeOf html | null | true |
MeasureTheory.Filtration.IsRightContinuous.RC | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {inst : PartialOrder ι} {𝓕 : MeasureTheory.Filtration ι m}
[self : 𝓕.IsRightContinuous], 𝓕.rightCont ≤ 𝓕 | The right continuity property. | true |
CategoryTheory.ShortComplex.RightHomologyData.opcyclesIso_inv_comp_descOpcycles_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) {A : C} (k : S.X₂ ⟶ A)
(hk : CategoryTheory.CategoryStruct.comp S.f k = 0) [inst_2 : S.HasRightHomology] {Z : C} (h_1 : A ⟶ Z),
CategoryT... | null | true |
LinearEquiv.domMulActCongrRight._proof_5 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8... | null | false |
AddMagma.FreeAddSemigroup.map.eq_1 | Mathlib.Algebra.Free | ∀ {α : Type u} [inst : Add α] {β : Type v} [inst_1 : Add β] (f : α →ₙ+ β),
AddMagma.FreeAddSemigroup.map f = AddMagma.FreeAddSemigroup.lift (AddMagma.FreeAddSemigroup.of.comp f) | null | true |
AntitoneOn.map_bddBelow | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
AntitoneOn f t → s ⊆ t → (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s) | The image under an antitone function of a set which is bounded below is bounded
above. | true |
_private.Mathlib.Topology.LocalAtTarget.0.TopologicalSpace.IsOpenCover.isOpenMap_iff_restrictPreimage._simp_1_1 | Mathlib.Topology.LocalAtTarget | ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, (a = b) = (↑a = ↑b) | null | false |
Rat.num_le_denom_iff | Mathlib.Algebra.Order.Ring.Unbundled.Rat | ∀ {q : ℚ}, q.num ≤ ↑q.den ↔ q ≤ 1 | null | true |
Lean.Grind.Linarith.Poly.NonnegCoeffs.add | Init.Grind.Module.NatModuleNorm | ∀ (a : ℤ) (x : Lean.Grind.Linarith.Var) (p : Lean.Grind.Linarith.Poly),
a ≥ 0 → p.NonnegCoeffs → (Lean.Grind.Linarith.Poly.add a x p).NonnegCoeffs | null | true |
Function.Periodic.contDiff_qParam | Mathlib.Analysis.Complex.Periodic | ∀ {h : ℝ} (m : WithTop ℕ∞), ContDiff ℂ m (Function.Periodic.qParam h) | null | true |
Function.Surjective.mulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
{A' : Type u_8} →
[inst : MonoidWithZero M₀] →
[inst_1 : Zero A] →
[inst_2 : MulActionWithZero M₀ A] →
[inst_3 : Zero A'] →
[inst_4 : SMul M₀ A'] →
(f : ZeroHom A A') →
Function.Surjective ⇑f → (... | Pushforward a `MulActionWithZero` structure along a surjective zero-preserving homomorphism. | true |
MonCat.adjoinOneAdj._proof_1 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X' X : Semigrp} {Y : MonCat} (f : X' ⟶ X) (g : X ⟶ (CategoryTheory.forget₂ MonCat Semigrp).obj Y),
(CategoryTheory.ConcreteCategory.homEquiv.trans
(WithOne.lift.symm.trans CategoryTheory.ConcreteCategory.homEquiv.symm)).symm
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStru... | null | false |
Subalgebra.coe_unop | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R Aᵐᵒᵖ), ↑S.unop = MulOpposite.op ⁻¹' ↑S | null | true |
Finsupp.split_apply | Mathlib.Data.Finsupp.Basic | ∀ {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_12} [inst : Zero M] (l : (i : ι) × αs i →₀ M) (i : ι) (x : αs i),
(l.split i) x = l ⟨i, x⟩ | null | true |
ENNReal.mul_div_right_comm | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, a * b / c = a / c * b | null | true |
Ideal.associatesEquivIsPrincipal._proof_3 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ (R : Type u_1) [inst : CommRing R] (I : { I // Submodule.IsPrincipal I }), Submodule.IsPrincipal ↑I | null | false |
LipschitzWith.mapsTo_closedBall | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ (x : α) (r : ℝ), Set.MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) (↑K * r)) | null | true |
Nat.Coprime.sum_divisors_mul | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {m n : ℕ}, m.Coprime n → ∑ d ∈ (m * n).divisors, d = (∑ d ∈ m.divisors, d) * ∑ d ∈ n.divisors, d | null | true |
Real.instDistribLattice._proof_4 | Mathlib.Data.Real.Basic | ∀ (a b c : ℝ), a ≤ c → b ≤ c → max a b ≤ c | null | false |
Real.isTheta_exp_comp_exp_comp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {l : Filter α} {f g : α → ℝ},
((fun x => Real.exp (f x)) =Θ[l] fun x => Real.exp (g x)) ↔
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => |f x - g x| | null | true |
Std.Time.Minute.instOrdOffset | Std.Time.Time.Unit.Minute | Ord Std.Time.Minute.Offset | null | true |
Std.ExtDTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (a : α) × β a}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd | null | true |
RBTree.RBSet.findP?_some_memP | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {y : α} {t : RBTree.RBSet α cmp},
t.findP? cut = some y → RBTree.RBSet.MemP cut t | null | true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁.instMonoHomologyMapIntι._proof_2 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n₁ : ℤ), n₁ - 1 = n₁ - 1 | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_3.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker | ∀ {n : ℕ} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClauseAction n) → Sort u_1)
(h_1 : Unit → motive none)
(h_2 : (id : ℕ) → (rupHints : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints)))
(h_3 :
(id : ℕ) →
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClaus... | null | true |
MonovaryOn.of_neg_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn (-f) g s → AntivaryOn f g s | null | true |
CategoryTheory.Functor.kernel | Mathlib.CategoryTheory.ObjectProperty.ContainsZero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] → CategoryTheory.Functor C D → CategoryTheory.ObjectProperty C | Given a functor `F : C ⥤ D`, this is the property of objects of `C`
satisfied by those `X : C` such that `IsZero (F.obj X)`. | true |
_private.Mathlib.Analysis.LocallyConvex.AbsConvex.0.nhds_hasBasis_absConvex_closed._simp_1_3 | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, (interior s ⊆ s) = True | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt64.reduceSub._regBuiltin.UInt64.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.79 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
WithLp.uniformEquiv_unitization_addEquiv_prod._proof_2 | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | ∀ (𝕜 : Type u_1) (A : Type u_2) [inst : NormedField 𝕜] [inst_1 : NonUnitalNormedRing A] [inst_2 : NormedSpace 𝕜 A],
UniformContinuous (WithLp.unitization_addEquiv_prod 𝕜 A).invFun | null | false |
Substring.Raw.Internal.get | Init.Data.String.Bootstrap | Substring.Raw → String.Pos.Raw → Char | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_fdiv_le_natAbs._proof_1_4 | Init.Data.Int.DivMod.Lemmas | ∀ (b : ℤ) (a b : ℕ), ¬0 < a + 1 → False | null | false |
Vector.insertIdx_eraseIdx._proof_3 | Init.Data.Vector.InsertIdx | ∀ {n i : ℕ}, i < n → i + 1 < n + 1 | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] {n s : ℕ} {h : n < (List.idxsOf x [] s).length},
(List.idxsOf x [] s)[n] - s + 1 ≤ [].length → (List.idxsOf x [] s)[n] - s < [].length | null | false |
Std.DTreeMap.Internal.Impl.keysArray_insertIfNew!_perm | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : BEq α] [Std.TransOrd α]
[Std.LawfulBEqOrd α],
t.WF →
∀ {k : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insertIfNew! k v t).keysArray.Perm
(if Std.DTreeMap.Internal.Impl.contains k t = true then t.keysArra... | null | true |
signedDist._proof_3 | Mathlib.Geometry.Euclidean.SignedDist | SMulCommClass ℝ ℝ ℝ | null | false |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toStalkₗ'.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top R)),
AlgebraicGeometry.StructureSheaf.toStalkₗ'✝ R M x =
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (AlgebraicGeometry.StructureSheaf.toOpenₗ R M ⊤))
((AlgebraicGeometry... | null | true |
List.length_erase | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {l : List α},
(l.erase a).length = if a ∈ l then l.length - 1 else l.length | null | true |
Nat.Partition.recOn | Mathlib.Combinatorics.Enumerative.Partition.Basic | {n : ℕ} →
{motive : n.Partition → Sort u} →
(t : n.Partition) →
((parts : Multiset ℕ) →
(parts_pos : ∀ {i : ℕ}, i ∈ parts → 0 < i) →
(parts_sum : parts.sum = n) → motive { parts := parts, parts_pos := parts_pos, parts_sum := parts_sum }) →
motive t | null | false |
Mathlib.Meta.FunProp.instInhabitedFunPropDecl | Mathlib.Tactic.FunProp.Decl | Inhabited Mathlib.Meta.FunProp.FunPropDecl | null | true |
Dynamics.coverEntropyInf_image_of_comap | Mathlib.Dynamics.TopologicalEntropy.Semiconj | ∀ {X : Type u_1} {Y : Type u_2} (u : UniformSpace Y) {S : X → X} {T : Y → Y} {φ : X → Y},
Function.Semiconj φ S T → ∀ (F : Set X), Dynamics.coverEntropyInf T (φ '' F) = Dynamics.coverEntropyInf S F | The entropy of `φ '' F` equals the entropy of `F` if `X` is endowed with the pullback by `φ`
of the uniform structure of `Y`. This version uses a `liminf`. | true |
Lists'.rec.eq._@.Mathlib.SetTheory.Lists.1973585389._hygCtx._hyg.4 | Mathlib.SetTheory.Lists | @Lists'.rec = @Lists'.rec✝ | null | false |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis.0.Tactic.ComputeAsymptotics.WellFormedBasis.eventually_pos._simp_1_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {α : Type u} {R : α → α → Prop} {a : α} {l : List α},
List.Pairwise R (a :: l) = ((∀ a' ∈ l, R a a') ∧ List.Pairwise R l) | null | false |
instOrOpInt8 | Init.Data.SInt.Basic | OrOp Int8 | null | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.xor_not._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Lean.Level.mvar.inj | Lean.Level | ∀ {a a_1 : Lean.LMVarId}, Lean.Level.mvar a = Lean.Level.mvar a_1 → a = a_1 | null | true |
CategoryTheory.yonedaMonFullyFaithful._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N : CategoryTheory.Mon C} (α : CategoryTheory.yonedaMon.obj M ⟶ CategoryTheory.yonedaMon.obj N),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one
((CategoryTheory.ConcreteCategor... | null | false |
TwoSidedIdeal.subtype_injective | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : TwoSidedIdeal R), Function.Injective ⇑I.subtype | null | true |
AddAction.orbitRel | Mathlib.GroupTheory.GroupAction.Defs | (G : Type u_1) → (α : Type u_2) → [inst : AddGroup G] → [AddAction G α] → Setoid α | The relation 'in the same orbit'. | true |
CategoryTheory.MorphismProperty.IsStableUnderBraiding.braiding_hom_mem | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} (P : CategoryTheory.MorphismProperty C) [self : P.IsStableUnderBraiding]
(c c' : C), P (β_ c c').hom | null | true |
Lean.Name.getRoot._sunfold | Init.Meta.Defs | Lean.Name → Lean.Name | null | false |
_private.Init.Data.Vector.Algebra.0.Vector.zero_hmul._proof_1_2 | Init.Data.Vector.Algebra | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {n : ℕ} [inst : Zero α] [inst_1 : Zero γ] [inst_2 : HMul α β γ],
(∀ (c : β), 0 * c = 0) → ∀ (c : Vector β n), 0 * c = 0 | null | false |
SimpleGraph.Subgraph.instMin._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G₁ G₂ : G.Subgraph) {v w : V},
G₁.Adj v w ∧ G₂.Adj v w → v ∈ G₁.verts ∧ v ∈ G₂.verts | null | false |
LinearOrderedCommGroupWithZero.zpow_succ' | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_3} [self : LinearOrderedCommGroupWithZero α] (n : ℕ) (a : α),
LinearOrderedCommGroupWithZero.zpow (↑n.succ) a = LinearOrderedCommGroupWithZero.zpow (↑n) a * a | `a ^ (n + 1) = a ^ n * a` | true |
TypeVec.typevecCasesNil₂._proof_2 | Mathlib.Data.TypeVec | ∀ {β : TypeVec.Arrow Fin2.elim0 Fin2.elim0 → Sort u_1} (g : TypeVec.Arrow Fin2.elim0 Fin2.elim0),
g = TypeVec.nilFun → β g = β TypeVec.nilFun | null | false |
Std.TreeMap.mem_union_of_left | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₁ → k ∈ t₁ ∪ t₂ | null | true |
SimpleGraph.Coloring.sumEquiv._proof_1 | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} {γ : Type u_3} {G : SimpleGraph V} {H : SimpleGraph W} (c : (G ⊕g H).Coloring γ),
(fun p => p.1.sum p.2) ((fun c => (c.sumLeft, c.sumRight)) c) = c | null | false |
FixedDetMatrices.instSMulSpecialLinearGroupFixedDetMatrix | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | (n : Type u_1) →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
(R : Type u_2) → [inst_2 : CommRing R] → (m : R) → SMul (Matrix.SpecialLinearGroup n R) (FixedDetMatrix n R m) | null | true |
Lean.Meta.RecursorInfo | Lean.Meta.RecursorInfo | Type | null | true |
RootedTree.mk.noConfusion | Mathlib.Order.SuccPred.Tree | {P : Sort u} →
{α : Type u_2} →
{semilatticeInf : SemilatticeInf α} →
{orderBot : OrderBot α} →
{predOrder : PredOrder α} →
{isPredArchimedean : IsPredArchimedean α} →
{α' : Type u_2} →
{semilatticeInf' : SemilatticeInf α'} →
{orderBot' : OrderBot ... | null | false |
_private.Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic.0.Path.Homotopic.Quotient.symm_trans._simp_1_4 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁},
(Path.Homotopic.Quotient.mk p = Path.Homotopic.Quotient.mk q) = p.Homotopic q | null | false |
instRankConditionMulOpposite | Mathlib.LinearAlgebra.Matrix.InvariantBasisNumber | ∀ {R : Type u_1} [inst : Semiring R] [RankCondition R], RankCondition Rᵐᵒᵖ | null | true |
CategoryTheory.ShortComplex.Exact.isZero_of_both_zeros | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.f = 0 → S.g = 0 → CategoryTheory.Limits.IsZero S.X₂ | null | true |
Hyperreal.instField._aux_70 | Mathlib.Analysis.Real.Hyperreal | ℚ → ℝ* → ℝ* | null | false |
Std.Roi.size.eq_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.Rxi.HasSize α] [inst_1 : Std.PRange.UpwardEnumerable α] (r : Std.Roi α),
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some lower => Std.Rxi.HasSize.size lower | null | true |
AddMonoidHom.compLeftContinuousBounded._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {β : Type u_2} {γ : Type u_3} (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
[inst_2 : AddMonoid β] [inst_3 : BoundedAdd β] [inst_4 : ContinuousAdd β] [inst_5 : PseudoMetricSpace γ]
[inst_6 : AddMonoid γ] [inst_7 : BoundedAdd γ] [inst_8 : ContinuousAdd γ] (g : β →+ γ) {C : NNReal}
(hg... | null | false |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.matches'.match_1.eq_4 | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (motive : RegularExpression α → Sort u_2) (P Q : RegularExpression α)
(h_1 : Unit → motive RegularExpression.zero) (h_2 : Unit → motive RegularExpression.epsilon)
(h_3 : (a : α) → motive (RegularExpression.char a)) (h_4 : (P Q : RegularExpression α) → motive (P.plus Q))
(h_5 : (P Q : RegularExpre... | null | true |
TopModuleCat.endRingEquiv._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] (M : TopModuleCat R),
Function.LeftInverse TopModuleCat.ofHom TopModuleCat.Hom.hom | null | false |
Nat.forall_lt_succ_left'._proof_2 | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, 0 < n + 1 | null | false |
AddRightCancelMonoid.add_eq_zero | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : AddRightCancelMonoid α] [Subsingleton (AddUnits α)] {a b : α}, a + b = 0 ↔ a = 0 ∧ b = 0 | null | true |
CategoryTheory.SingleFunctors.hom_ext_iff | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A} {f g : F ⟶ G},
f = g ↔ f.hom = g.hom | null | true |
CategoryTheory.Adjunction.ofNatIsoLeft | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F G : CategoryTheory.Functor C D} → {H : CategoryTheory.Functor D C} → (F ⊣ H) → (F ≅ G) → (G ⊣ H) | Transport an adjunction along a natural isomorphism on the left. | true |
Lean.Elab.CommandContextInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.CommandContextInfo → ℕ | null | false |
Topology.«_aux_Mathlib_Topology_Defs_Filter___macroRules_Topology_term𝓝ˢ_1» | Mathlib.Topology.Defs.Filter | Lean.Macro | null | false |
WithAbs.instField._proof_2 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Field R]
(v : AbsoluteValue R S),
autoParam (∀ (a : WithAbs v), (WithAbs.equiv v).symm.1 ((WithAbs.equiv v).toEquiv a ^ 0) = 1)
DivInvMonoid.zpow_zero'._autoParam | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.