name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Functor.PullbackObjObj.mapArrowRight._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_2} {C₃ : Type u_4} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_3, u_4} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ : CategoryTheory.Arrow C₁}
{f₃ f₃' : CategoryTheor... | null | false |
Lean.Meta.Grind.Arith.CommRing.CommSemiring.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.CommSemiring → Lean.Meta.Grind.Arith.CommRing.CommSemiring → Sort u | null | false |
Finsupp.uniqueLinearEquiv_symm_apply | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ (R : Type u_1) {α : Type u_2} (M : Type u_3) [inst : AddCommMonoid M] [inst_1 : Semiring R] [inst_2 : Module R M]
[inst_3 : Subsingleton α] (a : α) (a_1 : M), (Finsupp.uniqueLinearEquiv R M a).symm a_1 = fun₀ | a => a_1 | null | true |
Std.Do.SPred.forall_nil | Std.Do.SPred.SPred | ∀ {α : Sort u_1} {P : α → Std.Do.SPred []}, Std.Do.SPred.forall P = { down := ∀ (a : α), (P a).down } | null | true |
Std.DTreeMap.Internal.Impl.insert._proof_24 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced →
∀ (d : Std.DTreeMap.Internal.Impl α β),
r'.size ≤ d.size → d.size ≤ r'.size + 1 → Std.DTreeMap.Internal.Impl.BalanceLPrecond d.size l'.size | null | false |
CategoryTheory.Iso.coreLeftUnitor | Mathlib.CategoryTheory.Core | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D},
F.leftUnitor.core =
(CategoryTheory.Functor.id C).coreComp F ≪≫
CategoryTheory.Functor.isoWhiskerRight (CategoryTheory.Functor.coreId C) F.core ≪≫ F.cor... | null | true |
MeasureTheory.Measure.toProbabilityMeasure.congr_simp | Mathlib.Dynamics.Ergodic.EmpiricalMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ μ_1 : MeasureTheory.Measure Ω) (e_μ : μ = μ_1)
[inst_1 : MeasureTheory.IsProbabilityMeasure μ], μ.toProbabilityMeasure = μ_1.toProbabilityMeasure | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.isNonarchimedean_smoothingFun._simp_1_1 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ (b : α), a ≤ b → p b | null | false |
Rat.instMetricSpace._proof_5 | Mathlib.Topology.Instances.Rat | autoParam (uniformity ℚ = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε})
PseudoMetricSpace.uniformity_dist._autoParam | null | false |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.mem_piAntidiag._proof_1_4 | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {ι : Type u_1} {μ : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid μ] {s : Finset ι} {f : ι → μ}
(e : ↥s ≃ Fin s.card),
(∀ (i : ι), f i ≠ 0 → i ∈ s) → (fun i => if hi : i ∈ s then (f ∘ Subtype.val ∘ ⇑e.symm) (e ⟨i, hi⟩) else 0) = f | null | false |
CategoryTheory.nerve.homEquiv._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {x y : CategoryTheory.ComposableArrows C 0}
(f : CategoryTheory.nerveEquiv x ⟶ CategoryTheory.nerveEquiv y),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 1))
(CategoryTheory.ComposableArrows.mk₁ ... | null | false |
_private.Init.Data.Nat.Lemmas.0.Nat.lt_of_add_lt_add_right.match_1_1 | Init.Data.Nat.Lemmas | ∀ {k m : ℕ} (motive : (x : ℕ) → k + x < m + x → Prop) (x : ℕ) (x_1 : k + x < m + x),
(∀ (h : k + 0 < m + 0), motive 0 h) → (∀ (n : ℕ) (h : k + (n + 1) < m + (n + 1)), motive n.succ h) → motive x x_1 | null | false |
BitVec.cpopNatRec_allOnes | Init.Data.BitVec.Lemmas | ∀ {n w acc : ℕ}, n ≤ w → (BitVec.allOnes w).cpopNatRec n acc = acc + n | null | true |
Std.Slice.length_iter_eq_size | Std.Data.Iterators.Lemmas.Producers.Slice | ∀ {γ : Type u} {α β : Type v} [inst : Std.ToIterator (Std.Slice γ) Id α β] [inst_1 : Std.Iterator α Id β]
{s : Std.Slice γ} [Std.Iterators.Finite α Id] [inst_3 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id]
[inst_5 : Std.Slice.SliceSize γ] [Std.Slice.LawfulSliceSize γ], s.iter.length = s.size | null | true |
IsAddConj.setoid.eq_1 | Mathlib.Algebra.Group.Conj | ∀ (α : Type u_1) [inst : AddMonoid α], IsAddConj.setoid α = { r := IsAddConj, iseqv := ⋯ } | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_invalid_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false →
ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.invalid | null | true |
Lean.EnvExtension.instInhabitedAsyncMode | Lean.Environment | Inhabited Lean.EnvExtension.AsyncMode | null | true |
_private.Mathlib.Analysis.Normed.Lp.lpSpace.0.Memℓp.const_smul._simp_1_5 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {x y : NNReal} {z : ℝ}, x ^ z * y ^ z = (x * y) ^ z | null | false |
Nat.factorial_pos._f | Mathlib.Data.Nat.Factorial.Basic | ∀ (x : ℕ) (f : Nat.below x), 0 < x.factorial | null | false |
_private.Batteries.Data.Array.Merge.0.Array.merge.go._unary._proof_3 | Batteries.Data.Array.Merge | ∀ {α : Type u_1} (xs ys acc : Array α) (i j : ℕ) (hi : ¬i ≥ xs.size),
¬j ≥ ys.size →
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun acc i => PSigma.casesOn i fun i j => xs.size + ys.size - (i + j))
⟨acc.push xs[i], ⟨i + 1, j⟩⟩ ⟨acc, ⟨i, j⟩⟩ | null | false |
Aesop.LIFOQueue.mk.sizeOf_spec | Aesop.Search.Queue | ∀ (goals : Array Aesop.GoalRef), sizeOf { goals := goals } = 1 + sizeOf goals | null | true |
Std.Rco.toList_eq_ite_roo | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rco α} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.Rxo.IsAlwaysFinite α]
[Std.PRange.LawfulUpwardEnumerableLT α],
r.toList = if r.lower < r.upper then r.lower :: (r.lower<...r.upper).toList els... | null | true |
_private.Mathlib.NumberTheory.ModularForms.RamanujanFormula.0.Derivative.serreDerivativeOne_E2_slash._simp_1_11 | Mathlib.NumberTheory.ModularForms.RamanujanFormula | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
_private.Mathlib.RingTheory.DedekindDomain.AdicValuation.0.IsDedekindDomain.HeightOneSpectrum.valuation.eq_1 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
IsDedekindDomain.HeightOneSpectrum.valuation K v = v.intValuation.extendToLocalization ⋯ K | null | true |
IO.Promise.noConfusion | Init.System.Promise | {P : Sort u} →
{α : Type} →
{t : IO.Promise α} → {α' : Type} → {t' : IO.Promise α'} → α = α' → t ≍ t' → IO.Promise.noConfusionType P t t' | null | false |
ZMod.instFiniteZModUnits | Mathlib.Data.ZMod.Units | ∀ (n : ℕ), Finite (ZMod n)ˣ | For each `n ≥ 0`, the unit group of `ZMod n` is finite. | true |
Sep.mk.noConfusion | Init.Core | {α : outParam (Type u)} →
{γ : Type v} →
{P : Sort u_1} → {sep sep' : (α → Prop) → γ → γ} → { sep := sep } = { sep := sep' } → (sep ≍ sep' → P) → P | null | false |
Rep.linearization._proof_4 | Mathlib.RepresentationTheory.Rep.Basic | ∀ (k : Type u_3) (G : Type u_2) [inst : CommRing k] [inst_1 : Monoid G] {X Y Z : Action (Type u_1) G} (f : X ⟶ Y)
(g : Y ⟶ Z),
Rep.ofHom (Representation.linearizeMap (CategoryTheory.CategoryStruct.comp f g)) =
CategoryTheory.CategoryStruct.comp (Rep.ofHom (Representation.linearizeMap f))
(Rep.ofHom (Repre... | null | false |
isUnit_star._simp_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : Monoid R] [inst_1 : StarMul R] {a : R}, IsUnit (star a) = IsUnit a | null | false |
CategoryTheory.Limits.Cone.isLimitEquivIsTerminal._proof_3 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_3, u_2} C] {F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F),
Function.LeftInverse (fun h s => { default := h.from s, uniq := ⋯ }) fun x =>
CategoryTheory.Limits.IsTerminal.ofUniq... | null | false |
Finset.map_toDual_max | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α),
WithBot.map (⇑OrderDual.toDual) s.max = (Finset.image (⇑OrderDual.toDual) s).min | null | true |
Mathlib.Tactic.AtomM.addAtom | Mathlib.Util.AtomM | Lean.Expr → Mathlib.Tactic.AtomM (ℕ × Lean.Expr) | If an atomic expression has already been encountered, get the index and the stored form of the
atom (which will be defeq at the specified transparency, but not necessarily syntactically equal).
If the atomic expression has *not* already been encountered, store it in the list of atoms, and
return the new index (and the ... | true |
CategoryTheory.PreZeroHypercover.pullback₂_I₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S T : C} (f : S ⟶ T) (E : CategoryTheory.PreZeroHypercover T)
[inst_1 : ∀ (i : E.I₀), CategoryTheory.Limits.HasPullback (E.f i) f],
(CategoryTheory.PreZeroHypercover.pullback₂ f E).I₀ = E.I₀ | null | true |
Matrix.uniformContinuous | Mathlib.Topology.UniformSpace.Matrix | ∀ (m : Type u_1) (n : Type u_2) (𝕜 : Type u_3) [inst : UniformSpace 𝕜] {β : Type u_4} [inst_1 : UniformSpace β]
{f : β → Matrix m n 𝕜}, UniformContinuous f ↔ ∀ (i : m) (j : n), UniformContinuous fun x => f x i j | null | true |
List.zipWithLeft'._f | Batteries.Data.List.Basic | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
(α → Option β → γ) →
(x : List α) → List.below (motive := fun x => List β → List γ × List β) x → List β → List γ × List β | null | false |
_private.Mathlib.Algebra.NeZero.0.not_neZero._simp_1_1 | Mathlib.Algebra.NeZero | ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n = (n ≠ 0) | null | false |
CategoryTheory.Limits.ReflectsColimitsOfSize.reflectsColimitsOfShape._autoParam | Mathlib.CategoryTheory.Limits.Preserves.Basic | Lean.Syntax | null | false |
mod_natCard_zsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : AddGroup G] (a : G) (n : ℤ), (n % ↑(Nat.card G)) • a = n • a | null | true |
MonoidHom.submonoidMap_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {f : M →* N},
Function.Injective ⇑f → ∀ (M' : Submonoid M), Function.Injective ⇑(f.submonoidMap M') | null | true |
Matrix.decidableEq | Mathlib.Data.Matrix.Basic | {m : Type u_2} →
{n : Type u_3} → {α : Type u_8} → [DecidableEq α] → [Fintype m] → [Fintype n] → DecidableEq (Matrix m n α) | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mapIdIso._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.StrictlyUnitaryLaxFunctor B C) (x : B),
CategoryTheory.CategoryStruct.comp (F.mapId x) (CategoryTheory.eqToHom ⋯) =
CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id (... | null | false |
Cardinal.SharplyLT.recOn | Mathlib.CategoryTheory.Presentable.SharplyLT.Basic | {κ₁ κ₂ : Cardinal.{w}} →
[inst : Fact κ₁.IsRegular] →
[inst_1 : Fact κ₂.IsRegular] →
{motive : κ₁.SharplyLT κ₂ → Sort u} →
(t : κ₁.SharplyLT κ₂) →
((lt : κ₁ < κ₂) →
(isCardinalAccessible_cardinalDirectedPoset :
CategoryTheory.IsCardinalAccessibleCategory (Ca... | null | false |
_private.Mathlib.RingTheory.Polynomial.ScaleRoots.0.Polynomial.scaleRoots_dvd_iff._simp_1_1 | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} [inst : CommSemiring R] (p : Polynomial R) (r s : R),
(p.scaleRoots r).scaleRoots s = p.scaleRoots (r * s) | null | false |
AddAction.period_pos_of_addOrderOf_pos | Mathlib.GroupTheory.GroupAction.Period | ∀ {α : Type v} {M : Type u} [inst : AddMonoid M] [inst_1 : AddAction M α] {m : M},
0 < addOrderOf m → ∀ (a : α), 0 < AddAction.period m a | null | true |
CategoryTheory.shrinkCoyonedaCorepresentableBy | Mathlib.CategoryTheory.ShrinkYoneda | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] →
(X : Cᵒᵖ) → (CategoryTheory.shrinkCoyoneda.{w, v, u}.obj X).CorepresentableBy (Opposite.unop X) | `shrinkCoyoneda.obj X` is corepresented by `X`. | true |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.atomise_empty._simp_1_4 | Mathlib.Order.Partition.Finpartition | ∀ (α : Sort u), (∀ (a : α), True) = True | null | false |
Int.toArray_roc_eq_push | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, m < n → (m<...=n).toArray = (m<...=n - 1).toArray.push n | null | true |
Bornology.ext_iff' | Mathlib.Topology.Bornology.Basic | ∀ {α : Type u_2} {t t' : Bornology α}, t = t' ↔ ∀ (s : Set α), s ∈ Bornology.cobounded α ↔ s ∈ Bornology.cobounded α | null | true |
_private.Lean.Compiler.ExternAttr.0.Lean.parseOptNum._unary | Lean.Compiler.ExternAttr | (pattern : String.Slice) → (_ : pattern.Pos) ×' ℕ → pattern.Pos × ℕ | null | false |
Nat.count_true | Mathlib.Data.Nat.Count | ∀ (n : ℕ), Nat.count (fun x => True) n = n | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.ReplicateTarget.mk.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Replicate | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {combined : ℕ} [inst_2 : SizeOf α]
{w : ℕ} (n : ℕ) (inner : aig.RefVec w) (h : combined = w * n),
sizeOf { w := w, n := n, inner := inner, h := h } = 1 + sizeOf w + sizeOf n + sizeOf inner + sizeOf h | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastCpopTreeTarget.mk.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {w : ℕ} [inst_2 : SizeOf α] {len : ℕ}
(x : aig.RefVec (len * w)) (h : 0 < len), sizeOf { len := len, x := x, h := h } = 1 + sizeOf len + sizeOf x + sizeOf h | null | true |
CategoryTheory.Monoidal.instMonoidalTransportedInverseSymmEquivalenceTransported._proof_6 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] (e : C ≌ D) (X Y : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.Monoidal.equivalenceTrans... | null | false |
CategoryTheory.PreZeroHypercover.empty | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (S : C) → CategoryTheory.PreZeroHypercover S | The empty pre-`0`-hypercover. | true |
Std.HashSet.get!_diff_of_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, k ∈ m₂ → (m₁ \ m₂).get! k = default | null | true |
Array.mergeSort_perm | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {xs : Array α} {le : α → α → Bool}, (xs.mergeSort le).Perm xs | null | true |
CategoryTheory.PreOneHypercover.sieve₀_map | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D),
(E.map F).sieve₀ = CategoryTheory.Sieve.functorPushforward F E.sieve₀ | null | true |
Lake.instDecidableEqStdVer | Lake.Util.Version | DecidableEq Lake.StdVer | null | true |
WeierstrassCurve.Jacobian.negY_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R}, P 2 = 0 → W'.negY P = -P 1 | null | true |
CategoryTheory.ShortComplex.mapHomologyIso | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | {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] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(S : CategoryTheory.ShortComplex C) →
... | When a functor `F` preserves the left homology of a short complex `S`, this is the
canonical isomorphism `(S.map F).homology ≅ F.obj S.homology`. | true |
differentiable_finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i : Fin n) → F... | null | true |
CategoryTheory.MonoidalCategory.pentagon_hom_inv_inv_inv_hom | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {W X Y Z : C},
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator W X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z)).hom
(CategoryTheory.CategoryStruct.comp
... | null | true |
Mathlib.Tactic.Ring.Common.ExtractCoeff.mk.inj | Mathlib.Tactic.Ring.Common | ∀ {e k e' : Q(ℕ)} {ve' : Mathlib.Tactic.Ring.Common.ExProdNat e'} {p : Q(«$e» = «$e'» * «$k»)} {k_1 e'_1 : Q(ℕ)}
{ve'_1 : Mathlib.Tactic.Ring.Common.ExProdNat e'_1} {p_1 : Q(«$e» = «$e'_1» * «$k_1»)},
{ k := k, e' := e', ve' := ve', p := p } = { k := k_1, e' := e'_1, ve' := ve'_1, p := p_1 } →
k = k_1 ∧ e' = e'... | null | true |
instTopologicalSpaceModelPi._aux_1 | Mathlib.Geometry.Manifold.ChartedSpace | {ι : Type u_2} → {Hi : ι → Type u_1} → [(i : ι) → TopologicalSpace (Hi i)] → TopologicalSpace (ModelPi Hi) | null | false |
BoundedContinuousFunction.comp._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β] {C : NNReal}
(f : BoundedContinuousFunction α β) (x y : α), ↑C * dist (f x) (f y) ≤ ↑(max C 0) * dist (f x) (f y) | null | false |
IsDedekindDomain.instCommRingFiniteAdeleRing._aux_3 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | (R : Type u_1) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
(K : Type u_2) →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] →
IsDedekindDomain.FiniteAdeleRing R K →
IsDedekindDomain.FiniteAdeleRing R K → IsDe... | null | false |
Std.HashMap.getKey?_eq_some_iff | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α}, m.getKey? k = some k' ↔ ∃ (h : k ∈ m), m.getKey k h = k' | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!.match_3.eq_2 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2}
(motive : Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Sort u_3) (size : ℕ) (lrk : α)
(lrv : β lrk) (l r : Std.DTreeMap.Internal.Impl α β)
(h_1 : Unit → motive Std.DTreeMap.Internal.Impl.leaf Std.DTreeMap.Internal.Impl.leaf)
(h_2 :
(size : ℕ) →
... | null | true |
Finset.noncommProd_commute | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (s : Finset α) (f : α → β)
(comm : (↑s).Pairwise (Function.onFun Commute f)) (y : β),
(∀ x ∈ s, Commute y (f x)) → Commute y (s.noncommProd f comm) | null | true |
SameRay.pos_smul_left | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {x y : M} {S : Type u_4} [inst_5 : CommSemiring S]
[inst_6 : PartialOrder S] [inst_7 : Algebra S R] [inst_8 : Module S M] [SMulPosMono S R] [IsScalarTow... | A positive multiple of a vector is in the same ray as one it is in the same ray as. | true |
BoxIntegral.TaggedPrepartition.casesOn | Mathlib.Analysis.BoxIntegral.Partition.Tagged | {ι : Type u_1} →
{I : BoxIntegral.Box ι} →
{motive : BoxIntegral.TaggedPrepartition I → Sort u} →
(t : BoxIntegral.TaggedPrepartition I) →
((toPrepartition : BoxIntegral.Prepartition I) →
(tag : BoxIntegral.Box ι → ι → ℝ) →
(tag_mem_Icc : ∀ (J : BoxIntegral.Box ι), tag J ∈ ... | null | false |
String.Pos.toSlice_le._simp_1 | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, (p.toSlice ≤ q.toSlice) = (p ≤ q) | null | false |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.linearOrder._proof_8 | Mathlib.Data.Num.Lemmas | ∀ (a b : PosNum), ↑a ≤ ↑b ∨ ↑b ≤ ↑a | null | false |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_inv | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b : B} (f : a ⟶ b),
CategoryTheory.Bicategory.whiskerRight (F.mapId a).inv (F.map f) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor (F.m... | null | true |
Lean.Meta.Match.matchEqnsExt | Lean.Meta.Match.MatchEqsExt | Lean.EnvExtension Lean.Meta.Match.MatchEqnsExtState | null | true |
Mathlib.Tactic.Abel.AbelMode.casesOn | Mathlib.Tactic.Abel | {motive : Mathlib.Tactic.Abel.AbelMode → Sort u} →
(t : Mathlib.Tactic.Abel.AbelMode) →
motive Mathlib.Tactic.Abel.AbelMode.term → motive Mathlib.Tactic.Abel.AbelMode.raw → motive t | null | false |
SSet.Subcomplex.Pairing.RankFunction.rec | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} →
{α : Type v} →
[inst : PartialOrder α] →
{motive : P.RankFunction α → Sort u_1} →
((rank : ↑P.II → α) →
(lt : ∀ {x y : ↑P.II}, P.AncestralRel x y → rank x < rank y) → motive { rank := rank, lt := lt }) →
... | null | false |
ImportGraph.Shake.Needs.HighToLow.mk.noConfusion | ImportGraph.Shake.Basic | {P : Sort u} →
{toNeeds toNeeds' : ImportGraph.Shake.Needs} →
{ toNeeds := toNeeds } = { toNeeds := toNeeds' } → (toNeeds = toNeeds' → P) → P | null | false |
ReaderT.run_orElse | Batteries.Control.Lemmas | ∀ {m : Type u_1 → Type u_2} {ρ α : Type u_1} [inst : Monad m] [inst_1 : Alternative m] (x y : ReaderT ρ m α) (ctx : ρ),
(x <|> y).run ctx = (x.run ctx <|> y.run ctx) | null | true |
Nat.divisors_prime_pow | Mathlib.NumberTheory.Divisors | ∀ {p : ℕ} (pp : Nat.Prime p) (k : ℕ),
(p ^ k).divisors = Finset.map { toFun := fun x => p ^ x, inj' := ⋯ } (Finset.range (k + 1)) | null | true |
Quiver.Symmetrify.lift.match_1 | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} →
[inst : Quiver V] →
{X Y : Quiver.Symmetrify V} →
(motive : (X ⟶ Y) → Sort u_3) →
(x : X ⟶ Y) → ((g : X ⟶ Y) → motive (Sum.inl g)) → ((g : Y ⟶ X) → motive (Sum.inr g)) → motive x | null | false |
Algebra.Presentation.compRelationAux | Mathlib.RingTheory.Extension.Presentation.Basic | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{ι' : Type u_1} →
{σ' : Type u_2} →
{T : Type u_3} →
[inst_3 : CommRing T] →
... | A choice of pre-image of `Q.relation r` under the canonical
map `MvPolynomial (ι' ⊕ ι) R →ₐ[R] MvPolynomial ι' S` given by the evaluation of `P`. | true |
SemistandardYoungTableau.col_strict | Mathlib.Combinatorics.Young.SemistandardTableau | ∀ {μ : YoungDiagram} (T : SemistandardYoungTableau μ) {i1 i2 j : ℕ}, i1 < i2 → (i2, j) ∈ μ → T i1 j < T i2 j | null | true |
Lean.Meta.instMonadMCtxMetaM | Lean.Meta.Basic | Lean.MonadMCtx Lean.MetaM | null | true |
InnerProductSpace.Core.toSeminormedAddCommGroup._proof_4 | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x : F), √(RCLike.re (inner 𝕜 (-x) (-x))) = √(RCLike.re (inner 𝕜 x x)) | null | false |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.mem_filter_key._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Substring.Raw.hasBeq | Init.Data.String.Substring | BEq Substring.Raw | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.oangle_sign_smul_add_right._proof_1_3 | 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),
(∀ (r' : ℝ), o.oangle x (r' • x + y) ≠ 0 ∧ o.oangle x (r' • x + y) ≠ ↑Real.pi) →
∀ z ∈ (fun r' => (x, r' • x + y)) '' Set.univ, ¬o.oangle z.1 z.2 = 0 ... | null | false |
Finset.sum_mul_boole | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {R : Type u_4} [inst : NonAssocSemiring R] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → R) (i : ι),
(∑ j ∈ s, f j * if i = j then 1 else 0) = if i ∈ s then f i else 0 | null | true |
Algebra.IsInvariant.recOn | Mathlib.RingTheory.Invariant.Defs | {A : Type u_1} →
{B : Type u_2} →
{G : Type u_3} →
[inst : CommSemiring A] →
[inst_1 : Semiring B] →
[inst_2 : Algebra A B] →
[inst_3 : Group G] →
[inst_4 : MulSemiringAction G B] →
{motive : Algebra.IsInvariant A B G → Sort u} →
... | null | false |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValidForSlice_sliceTo.match_1_3 | Init.Data.String.Basic | ∀ {s : String.Slice} {p : s.Pos} {off : String.Pos.Raw}
(motive : off ≤ p.offset ∧ String.Pos.Raw.IsValidForSlice s off → Prop)
(x : off ≤ p.offset ∧ String.Pos.Raw.IsValidForSlice s off),
(∀ (h₁ : off ≤ p.offset) (h₂ : off ≤ s.rawEndPos)
(h₃ : String.Pos.Raw.IsValid s.str (off.offsetBy s.startInclusive.off... | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.face_le_horn_iff._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
ENNReal.tsum_eq_iSup_nat | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {f : ℕ → ENNReal}, ∑' (i : ℕ), f i = ⨆ i, ∑ a ∈ Finset.range i, f a | null | true |
Option.instSMulCommClass | Mathlib.Algebra.Group.Action.Option | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_3} [inst : SMul M α] [inst_1 : SMul N α] [SMulCommClass M N α],
SMulCommClass M N (Option α) | null | true |
CategoryTheory.Pretriangulated.Triangle.instZeroHom._proof_6 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
{T₁ T₂ : CategoryTheory.Pretriangulated.Triangle C} [inst_2 : CategoryTheory.Preadditive C]
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive],
CategoryTheory.CategoryStruct.comp T₁.mor₃ ((CategoryTheory.shi... | null | false |
Profinite.NobelingProof.πs._proof_1 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] (o : Ordinal.{u_1}),
Continuous (Profinite.NobelingProof.ProjRestrict C fun x => Profinite.NobelingProof.ord I x < o) | null | false |
String.Slice.Pattern.Model.IsValidRevSearchFrom.startPos_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {p : s.Pos}
{l : List (String.Slice.Pattern.SearchStep s)},
p = s.startPos → l = [] → String.Slice.Pattern.Model.IsValidRevSearchFrom pat p l | null | true |
SeminormedAddGroup.toNorm | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → [self : SeminormedAddGroup E] → Norm E | null | true |
PresheafOfModules.isoMk._proof_8 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (app : (X : Cᵒᵖ) → M₁.obj X ≅ M₂.obj X)
(naturality :
∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (M₁.map f)
((ModuleCat.restrictScalars (RingCa... | null | false |
_private.Mathlib.Data.List.Sort.0.List.Pairwise.eq_of_mem_iff._proof_1_2 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l₁ l₂ : List α}, (∀ (a : α), a ∈ l₁ ↔ a ∈ l₂) → l₂ ⊆ l₁ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.