name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE.0.CategoryTheory.Triangulated.TStructure.TruncAux.triangleFunctor_map | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
Profinite.NobelingProof.coe_πs | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] (o : Ordinal.{u})
(f : LocallyConstant ↑(Profinite.NobelingProof.π C fun x => Profinite.NobelingProof.ord I x < o) ℤ),
⇑((Profinite.NobelingProof.πs C o) f) =
⇑f ∘ Profinite.NobelingProof.ProjRestrict C fun x => Profinite.Nobe... | null | true |
_private.Std.Data.DHashMap.Internal.Model.0.Std.DHashMap.Internal.Raw₀.Const.modify.eq_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} [inst : BEq α] {β : Type v} [inst_1 : Hashable α] (a : α) (f : β → β) (size : ℕ)
(buckets : Array (Std.DHashMap.Internal.AssocList α fun x => β))
(hm : 0 < { size := size, buckets := buckets }.buckets.size),
Std.DHashMap.Internal.Raw₀.Const.modify ⟨{ size := size, buckets := buckets }, hm⟩ a f =
... | null | true |
HasProdLocallyUniformlyOn.multipliableLocallyUniformlyOn | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α] [inst_2 : TopologicalSpace β],
HasProdLocallyUniformlyOn f g s → MultipliableLocallyUniformlyOn f s | null | true |
Vector.mapIdx_mk._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_2} {β : Type u_1} {n : ℕ} {f : ℕ → α → β} {xs : Array α}, xs.size = n → (Array.mapIdx f xs).size = n | null | false |
Polynomial.degree_add_div | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Field R] {p q : Polynomial R}, q ≠ 0 → q.degree ≤ p.degree → q.degree + (p / q).degree = p.degree | null | true |
MeasureTheory.OuterMeasure.mk._flat_ctor | Mathlib.MeasureTheory.OuterMeasure.Defs | {α : Type u_2} →
(measureOf : Set α → ENNReal) →
measureOf ∅ = 0 →
(∀ {s₁ s₂ : Set α}, s₁ ⊆ s₂ → measureOf s₁ ≤ measureOf s₂) →
(∀ (s : ℕ → Set α), Pairwise (Function.onFun Disjoint s) → measureOf (⋃ i, s i) ≤ ∑' (i : ℕ), measureOf (s i)) →
MeasureTheory.OuterMeasure α | null | false |
CategoryTheory.Pseudofunctor.StrongTrans.comp_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.Pseudofunctor B C} (η : F ⟶ G) (θ : G ⟶ H) (a : B),
(CategoryTheory.CategoryStruct.comp η θ).app a = CategoryTheory.CategoryStruct.comp (η.app a) (θ.app a) | null | true |
CategoryTheory.Limits.PreservesPullback.iso_inv_snd_assoc | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | null | true |
Int32.toInt8_add | Init.Data.SInt.Lemmas | ∀ (a b : Int32), (a + b).toInt8 = a.toInt8 + b.toInt8 | null | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.reduceLtQ.match_1 | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(iM' : Q(PartialOrder «$M»)) →
(iM'' : Q(PosMulStrictMono «$M»)) →
(iM''' : Q(PosMulReflectLT «$M»)) →
(iM'''' : Q(ZeroLEOneClass «$M»)) →
(l₁ l₂ : Mathlib.Tactic.FieldSimp.qNF M) →
... | null | false |
LinearMap.lTensor_tmul | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : N →ₗ[R] P) (m : M) (n : N), (LinearMap.lTensor M f) (m ⊗ₜ[R] n) = m ⊗ₜ[R] f n | null | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.process._unsafe_rec | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Term.ToParserDescr | null | false |
MulOpposite.instSemiring._proof_2 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : Semiring R] (a : Rᵐᵒᵖ), 1 * a = a | null | false |
measurable_prodMk_left | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {x : α}, Measurable (Prod.mk x) | null | true |
Caratheodory.mem_minCardFinsetOfMemConvexHull | Mathlib.Analysis.Convex.Caratheodory | ∀ {𝕜 : Type u_1} {E : Type u} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {s : Set E} {x : E} (hx : x ∈ (convexHull 𝕜) s),
x ∈ (convexHull 𝕜) ↑(Caratheodory.minCardFinsetOfMemConvexHull hx) | null | true |
Mathlib.Tactic.BicategoryLike.MkMor₂.noConfusionType | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Sort u →
{m : Type → Type} →
Mathlib.Tactic.BicategoryLike.MkMor₂ m → {m' : Type → Type} → Mathlib.Tactic.BicategoryLike.MkMor₂ m' → Sort u | null | false |
MeasureTheory.VectorMeasure.integrableOn_univ._simp_1 | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {X : Type u_2} {E : Type u_3} {F : Type u_4} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.VectorMeasure X F} {f : X → E},
μ.IntegrableOn f Set.univ = μ.Integrable f | null | false |
_private.Mathlib.NumberTheory.RamificationInertia.Ramification.0.Ideal.ramificationIdx'_comap_eq._simp_1_1 | Mathlib.NumberTheory.RamificationInertia.Ramification | ∀ {R : Type u} {S : Type v} {F : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S] {f : F}
{I : Ideal R} {K : Ideal S} [inst_3 : RingHomClass F R S], (Ideal.map f I ≤ K) = (I ≤ Ideal.comap f K) | null | false |
_private.Mathlib.Order.Birkhoff.0.OrderIso.supIrredLowerSet_symm_apply._simp_1_1 | Mathlib.Order.Birkhoff | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) {x : α} {y : β}, (e.symm y = x) = (y = e x) | null | false |
Std.TreeMap.Raw.size_left_le_size_union | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.size ≤ (t₁ ∪ t₂).size | null | true |
CategoryTheory.createsColimitOfFullyFaithfulOfLift | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | When `F` is fully faithful, and `HasColimit (K ⋙ F)`, to show that `F` creates the colimit for `K`
it suffices to exhibit a lift of the chosen colimit cocone for `K ⋙ F`.
| true |
SSet.π₀.fromChainComplexXZero.eq_1 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.HomologyZero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (X : SSet) (R : C),
SSet.π₀.fromChainComplexXZero X R = (CategoryTheory.Limits.sigmaConst.obj R).map (TypeCat.ofHom SSet.π₀.mk) | null | true |
Bifunctor.mapEquiv_apply | Mathlib.Logic.Equiv.Functor | ∀ {α β : Type u} {α' β' : Type v} (F : Type u → Type v → Type w) [inst : Bifunctor F] [inst_1 : LawfulBifunctor F]
(h : α ≃ β) (h' : α' ≃ β') (x : F α α'), (Bifunctor.mapEquiv F h h') x = bimap (⇑h) (⇑h') x | null | true |
CategoryTheory.Functor.FullyFaithful.addGrpObj_zero | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
{F : CategoryTheory.Functor C D} [inst_4 : F.Monoidal] (hF : F.FullyFaithful) (X : C)
... | null | true |
Function.coframeMinimalAxioms | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {β : Type v} [inst : CompleteLattice α] [inst_1 : CompleteLattice β],
Order.Coframe.MinimalAxioms β →
∀ (f : α → β),
(∀ {x y : α}, f y ≤ f x ↔ y ≤ x) →
(∀ (a b : α), f (a ⊔ b) = f a ⊔ f b) →
(∀ (s : Set α), f (sInf s) = ⨅ a ∈ s, f a) → Order.Coframe.MinimalAxioms α | Pullback an `Order.Coframe.MinimalAxioms` along a function. | true |
Int.Internal.Linear.Poly.coeff_k_eq_coeff | Init.Data.Int.Linear | ∀ (p : Int.Internal.Linear.Poly) (x : Int.Internal.Linear.Var), p.coeff_k x = p.coeff x | null | true |
Lean.Elab.Structural.RecArgInfo.mk._flat_ctor | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Name →
Lean.Elab.FixedParamPerm → ℕ → Array ℕ → Lean.Elab.Structural.IndGroupInst → ℕ → Lean.Elab.Structural.RecArgInfo | null | false |
IndepMatroid.matroid | Mathlib.Combinatorics.Matroid.IndepAxioms | {α : Type u_1} → IndepMatroid α → Matroid α | An `M : IndepMatroid α` gives a `Matroid α` whose bases are the maximal `M`-independent sets. | true |
instNormedAddTorsorProd | Mathlib.Analysis.Normed.Group.AddTorsor | {V : Type u_2} →
{P : Type u_3} →
{W : Type u_4} →
{Q : Type u_5} →
[inst : SeminormedAddCommGroup V] →
[inst_1 : PseudoMetricSpace P] →
[NormedAddTorsor V P] →
[inst_3 : SeminormedAddCommGroup W] →
[inst_4 : PseudoMetricSpace Q] → [NormedAddTorsor... | null | true |
instPartialEquivBEqFloat32_batteries | Batteries.Data.Float.Lemmas | PartialEquivBEq Float32 | Boolean equality on `Float32`s is symmetric and transitive, but not reflexive, as demonstrated
by `nan != nan`.
| true |
_private.Mathlib.Topology.ClusterPt.0.accPt_iff_frequently._simp_1_3 | Mathlib.Topology.ClusterPt | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Lean.Linter.CodeQuality.Value.ctorIdx | Lean.Linter.CodeQuality.Basic | Lean.Linter.CodeQuality.Value → ℕ | null | false |
Lean.Meta.SynthInstance.Answer.resultType | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.Answer → Lean.Expr | null | true |
Module.End.IsSemisimple.of_mem_adjoin_pair | Mathlib.LinearAlgebra.Semisimple | ∀ {M : Type u_2} [inst : AddCommGroup M] {K : Type u_3} [inst_1 : Field K] [inst_2 : Module K M] {f g : Module.End K M}
[FiniteDimensional K M] [PerfectField K],
Commute f g → f.IsSemisimple → g.IsSemisimple → ∀ {a : Module.End K M}, a ∈ K[f, g] → a.IsSemisimple | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.seqToCode.go.match_1.splitter | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Compiler.LCNF.ToLCNF.Element✝ → Sort u_1) →
(x : Lean.Compiler.LCNF.ToLCNF.Element✝) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.let✝ decl)) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
... | null | true |
Lean.IR.EmitLLVM.callLeanSetupLibUV | Lean.Compiler.IR.EmitLLVM | {llvmctx : Lean.LLVM.Context} →
Lean.LLVM.Builder llvmctx →
Lean.LLVM.Value llvmctx → Lean.LLVM.Value llvmctx → Lean.IR.EmitLLVM.M llvmctx (Lean.LLVM.Value llvmctx) | null | true |
Std.ExtDHashMap.Const.alter_eq_empty_iff_erase_eq_empty | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
Std.ExtDHashMap.Const.alter m k f = ∅ ↔ m.erase k = ∅ ∧ f (Std.ExtDHashMap.Const.get? m k) = none | null | true |
MonoidHom.ofLeftInverse | Mathlib.Algebra.Group.Subgroup.Ker | {G : Type u_1} →
[inst : Group G] →
{N : Type u_4} → [inst_1 : Group N] → {f : G →* N} → {g : N →* G} → Function.LeftInverse ⇑g ⇑f → G ≃* ↥f.range | Computable alternative to `MonoidHom.ofInjective`. | true |
Set.sUnion_eq_biUnion | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {s : Set (Set α)}, ⋃₀ s = ⋃ i ∈ s, i | null | true |
Lean.Meta.instInhabitedAuxLemmas.default | Lean.Meta.Tactic.AuxLemma | Lean.Meta.AuxLemmas | null | true |
BoxIntegral.Prepartition.biUnion_top | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.Prepartition I), (π.biUnion fun x => ⊤) = π | null | true |
Finset.disjiUnion_map_sigma_mk | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Finset ι} {t : (i : ι) → Finset (α i)},
s.disjiUnion (fun i => Finset.map (Function.Embedding.sigmaMk i) (t i)) ⋯ = s.sigma t | null | true |
CategoryTheory.Triangulated.Octahedron'.mem | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | null | true |
instCompleteLatticeStructureGroupoid._proof_4 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
DistribMulActionSemiHomClass.toAddMonoidHomClass | Mathlib.GroupTheory.GroupAction.Hom | ∀ {F : Type u_10} {M : outParam (Type u_11)} {N : outParam (Type u_12)} {φ : outParam (M → N)}
{A : outParam (Type u_13)} {B : outParam (Type u_14)} {inst : Monoid M} {inst_1 : Monoid N} {inst_2 : AddMonoid A}
{inst_3 : AddMonoid B} {inst_4 : DistribMulAction M A} {inst_5 : DistribMulAction N B} {inst_6 : FunLike F... | null | true |
CategoryTheory.Functor.Monoidal.copy._auto_3 | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | null | false |
Prod.map_involutive._simp_1 | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} [Nonempty α] [Nonempty β] {f : α → α} {g : β → β},
Function.Involutive (Prod.map f g) = (Function.Involutive f ∧ Function.Involutive g) | null | false |
qrSign.sq_eq_one | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ {m n : ℕ}, Odd m → Odd n → qrSign m n ^ 2 = 1 | When `m` and `n` are odd, then the square of `qrSign m n` is `1`. | true |
Nat.factorization_choose' | Mathlib.Data.Nat.Choose.Factorization | ∀ {p n k b : ℕ},
Nat.Prime p →
Nat.log p (n + k) < b →
((n + k).choose k).factorization p = {i ∈ Finset.Ico 1 b | p ^ i ≤ k % p ^ i + n % p ^ i}.card | The factorization of `p` in `choose (n + k) k` is the number of carries when `k` and `n` are
added in base `p`. The set is expressed by filtering `Ico 1 b` where `b` is any bound greater
than `log p (n + k)`. | true |
CategoryTheory.AsSmall.instAdditiveDown | Mathlib.CategoryTheory.Abelian.Transfer | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C],
CategoryTheory.AsSmall.down.Additive | null | true |
_private.Init.Data.Range.Polymorphic.PRange.0.Std.instDecidableEqRcc.decEq._proof_3 | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u_1} (a a_1 b b_1 : α), ¬a = b → a...=a_1 = b...=b_1 → False | null | false |
Equiv.Perm.VectorsProdEqOne.one_eq | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ (G : Type u_2) [inst : Group G], Equiv.Perm.vectorsProdEqOne G 1 = {1 ::ᵥ List.Vector.nil} | null | true |
UInt8.not_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, ¬a < b ↔ b ≤ a | null | true |
ContinuousLinearMap.coprodSubtypeLEquivOfIsCompl._proof_5 | Mathlib.Analysis.Normed.Operator.Banach | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [CompleteSpace E]
{F : Type u_1} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Submodule 𝕜 F} [CompleteSpace ↥G],
CompleteSpace (E × ↥G) | null | false |
Std.ExtDHashMap.Const.getKey_insertManyIfNewUnit_list_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k : α} (mem : k ∈ m)
{h : k ∈ Std.ExtDHashMap.Const.insertManyIfNewUnit m l},
(Std.ExtDHashMap.Const.insertManyIfNewUnit m l).getKey k h = m.getKey k mem | null | true |
Filter.map₂_eq_bot_iff | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β},
Filter.map₂ m f g = ⊥ ↔ f = ⊥ ∨ g = ⊥ | null | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.isPatternVar.match_1 | Lean.Elab.Match | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo val))) →
((val : Lean.ConstantInfo) → motive (some val)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | null | false |
CategoryTheory.SimplicialObject.Augmented.whiskeringObj.eq_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (D : Type u_1) [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor C D),
CategoryTheory.SimplicialObject.Augmented.whiskeringObj C D F =
{
obj := fun X =>
{
left :=
((CategoryTheory.SimplicialObj... | null | true |
Std.DTreeMap.getKey!_inter_of_mem_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [inst : Inhabited α]
[Std.TransCmp cmp] {k : α}, k ∈ t₂ → (t₁ ∩ t₂).getKey! k = t₁.getKey! k | null | true |
EuclideanGeometry.Concyclic.mk | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {ps : Set P},
EuclideanGeometry.Cospherical ps → Coplanar ℝ ps → EuclideanGeometry.Concyclic ps | null | true |
Std.DTreeMap.Raw.get?_ofList_of_mem | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Std.LawfulEqCmp cmp]
{l : List ((a : α) × β a)} {k k' : α} (k_eq : cmp k k' = Ordering.eq) {v : β k},
List.Pairwise (fun a b => ¬cmp a.fst b.fst = Ordering.eq) l →
⟨k, v⟩ ∈ l → (Std.DTreeMap.Raw.ofList l cmp).get? k' = some (cas... | null | true |
OrderIso.bddBelow_preimage._simp_1 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {s : Set β},
BddBelow (⇑e ⁻¹' s) = BddBelow s | null | false |
CategoryTheory.Limits.WalkingReflexivePair._sizeOf_1 | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | CategoryTheory.Limits.WalkingReflexivePair → ℕ | null | false |
QPF.recF._f | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type v} → [q : QPF F] → {α : Type u} → (F α → α) → (x : (QPF.P F).W) → WType.below x → α | null | false |
DilationEquiv.apply_symm_apply | Mathlib.Topology.MetricSpace.DilationEquiv | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (e : X ≃ᵈ Y) (x : Y),
e (e.symm x) = x | null | true |
CategoryTheory.ExponentiableMorphism.instChosenPullbacksAlongHomMk._aux_1 | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u_2} →
[inst : CategoryTheory.Category.{u_1, u_2} C] →
{I J : C} →
{f : I ⟶ J} →
[CategoryTheory.ChosenPullbacksAlong f] → CategoryTheory.ChosenPullbacksAlong (CategoryTheory.Over.mk f).hom | null | false |
Vector.prod_toList | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : Mul α] [inst_1 : One α] {xs : Vector α n}, xs.toList.prod = xs.prod | null | true |
_private.Mathlib.Data.List.Induction.0.List.bidirectionalRec.match_1.splitter | Mathlib.Data.List.Induction | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) → ((a : α) → motive [a]) → ((a b : α) → (l : List α) → motive (a :: b :: l)) → motive x | null | true |
SimpleGraph.neighborSet_inf | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} {G₁ G₂ : SimpleGraph V} (v : V), (G₁ ⊓ G₂).neighborSet v = G₁.neighborSet v ∩ G₂.neighborSet v | null | true |
Filter.liminfReparam.eq_1 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {ι : Type u_4} {ι' : Type u_5} [inst : ConditionallyCompleteLinearOrder α] (f : ι → α) (s : ι' → Set ι)
(p : ι' → Prop) [inst_1 : Countable (Subtype p)] [inst_2 : Nonempty (Subtype p)] (j : Subtype p),
Filter.liminfReparam f s p j = if j ∈ {j | BddBelow (Set.range fun i => f ↑i)} then j else ⋯.choo... | null | true |
Polynomial.natSepDegree_X_pow | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} [inst : Field F] {n : ℕ}, (Polynomial.X ^ n).natSepDegree = if n = 0 then 0 else 1 | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.DivModState.toNat_shiftRight_sub_one_eq._proof_1_4 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {args : BitVec.DivModArgs w} {qr : BitVec.DivModState w}, qr.wr + qr.wn = w → ¬qr.wn ≤ w → False | null | false |
_private.Mathlib.RingTheory.Polynomial.Chebyshev.0.Polynomial.Chebyshev.S_eq_U_comp_half_mul_X._simp_1_2 | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {R : Type u} [inst : Semiring R] (n : ℕ), ↑n = Polynomial.C ↑n | null | false |
MvPFunctor.M.Path.inhabited._proof_2 | Mathlib.Data.PFunctor.Multivariate.M | ∀ {n : ℕ} (P : MvPFunctor.{u_1} (n + 1)) (x : P.last.M), x.dest = ⟨x.head, x.children⟩ | null | false |
Filter.eventuallyLE_map | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : Filter α} {m : α → β} [inst : LE γ] {f₁ f₂ : β → γ},
f₁ ≤ᶠ[Filter.map m f] f₂ ↔ f₁ ∘ m ≤ᶠ[f] f₂ ∘ m | null | true |
Std.Rci.forIn'_eq_forIn'_toList | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rci α} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.PRange.LawfulUpwardEnumerableLE α] [inst_3 : Std.Rxi.IsAlwaysFinite α]
[inst_4 : Std.PRange.LawfulUpwardEnumerable α] {γ : Type u} {init : γ} {m : Type u → Type w} [inst_5 : Monad m]
[LawfulMonad m] {f : (a : α) → ... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric.0._aux_Mathlib_Analysis_CStarAlgebra_ContinuousFunctionalCalculus_Isometric___unexpand_spectrum_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.PrettyPrinter.Unexpander | null | false |
MulOpposite.instNormedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : NormedRing α] (a b : αᵐᵒᵖ), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
Lean.Level.zero._override | Lean.Level | Lean.Level | null | false |
Subtype.mk_le_mk._gcongr_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : α} {hx : p x} {hy : p y}, x ≤ y → ⟨x, hx⟩ ≤ ⟨y, hy⟩ | null | false |
Rat.ofScientific_def_eq_ite | Init.Data.Rat.Lemmas | ∀ {m : ℕ} {s : Bool} {e : ℕ}, OfScientific.ofScientific m s e = if s = true then ↑m / 10 ^ e else ↑m * 10 ^ e | null | true |
Fin.sum_neg_one_pow_eq_zero | Mathlib.Algebra.BigOperators.Fin | ∀ {α : Type u_3} [inst : AddCommGroup α] {n : ℕ} (d : Fin (n + 2) → α) (r : Fin (n + 1) → α),
d 0 = r 0 →
(∀ (i : Fin n), d i.succ.castSucc = r i.castSucc + r i.succ) →
d (Fin.last (n + 1)) = r (Fin.last n) → ∑ i, (-1) ^ ↑i • d i = 0 | This is a classic "telescoping sum" lemma. It says:
`r₀ - (r₀ + r₁) + (r₁ + r₂) - (r₂+ r₃) + ⋯ ± (rₙ₋₁ + rₙ) ∓ rₙ = 0`.
The chosen spelling, which gives definitional power over `d`, is influenced by downstream
applications such as `Module.sum_neg_one_pow_finrank_eq_zero_of_exact`. | true |
CategoryTheory.uliftYonedaOpCompCoyoneda._proof_1 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] (X : Cᵒᵖ)
{X_1 Y : CategoryTheory.Functor Cᵒᵖ (Type (max u_2 u_1))} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.uliftYoneda.{u_2, u_1, u_3}.op.comp CategoryTheory.coyoneda).obj X).map f)
(CategoryTheory.uliftYonedaEqu... | null | false |
BoundedOrderHom.symm_dual_comp | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] [inst_4 : Preorder γ] [inst_5 : BoundedOrder γ] (g : BoundedOrderHom βᵒᵈ γᵒᵈ)
(f : BoundedOrderHom αᵒᵈ βᵒᵈ),
BoundedOrderHom.dual.symm (g.comp f) = (BoundedOrderHom.dual.sym... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.relation_add_coe | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair) (x : ℂ) (l : ↥L.lattice), PeriodPair.relation✝ L (x + ↑l) = PeriodPair.relation✝ L x | null | true |
Nat.stirlingSecond_self | Mathlib.Combinatorics.Enumerative.Stirling | ∀ (n : ℕ), n.stirlingSecond n = 1 | null | true |
FixedDetMatrices.reduce._proof_2 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | ∀ {m : ℤ} (a : FixedDetMatrix (Fin 2) ℤ m),
¬↑a 1 0 = 0 → InvImage (fun x1 x2 => x1 < x2) (fun x => (↑x 1 0).natAbs) (FixedDetMatrices.reduceStep a) a | null | false |
Tactic.ComputeAsymptotics.MultiseriesExpansion.trimmed_iff_seq_trimmed | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Trimming | ∀ {basis_hd : ℝ → ℝ} {basis_tl : Tactic.ComputeAsymptotics.Basis}
(ms : Tactic.ComputeAsymptotics.MultiseriesExpansion (basis_hd :: basis_tl)), ms.Trimmed ↔ ms.seq.Trimmed | null | true |
WeierstrassCurve.Projective.instSetoidForallFinOfNatNat | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | {R : Type r} → [CommRing R] → Setoid (Fin 3 → R) | The equivalence setoid for a projective point representative on a Weierstrass curve. | true |
_private.Init.Data.Iterators.Lemmas.Producers.Monadic.List.0.Std.IterM.toArray_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Producers.Monadic.List | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3)
(h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
... | null | true |
Lean.Elab.ConfigEval.ConfigItem.value | Lean.Elab.ConfigEval.Types | Lean.Elab.ConfigEval.ConfigItem → Lean.Syntax | The configuration value. Usually this is a `Term`, but user-defined configuration items
can use arbitrary syntax. For `+`/`-` booleans, this syntax is synthetic. | true |
CategoryTheory.preadditiveYonedaMap.congr_simp | Mathlib.CategoryTheory.Abelian.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v, u₁} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.Additive] (X : C), CategoryTheory.preadditiveYonedaMap F X = CategoryTheory... | null | true |
CategoryTheory.Limits.limitIsoSwapCompLim_hom_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
(G : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (X : K),
(CategoryTheor... | null | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.instRankFiniteMap.match_1 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {M : Matroid α} (motive : (∃ B, M.IsBase B) → Prop) (x : ∃ B, M.IsBase B),
(∀ (w : Set α) (hB : M.IsBase w), motive ⋯) → motive x | null | false |
CategoryTheory.CommSq.shortComplex_X₂ | Mathlib.Algebra.Homology.CommSq | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {X₁ X₂ X₃ X₄ : C}
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X₂ X₃] {f : X₁ ⟶ X₂} {g : X₁ ⟶ X₃} {inl : X₂ ⟶ X₄} {inr : X₃ ⟶ X₄}
(sq : CategoryTheory.CommSq f g inl inr), sq.shortComplex.X₂ = (X₂ ⊞ X₃) | null | true |
DoubleCentralizer.instNormedRing._proof_1 | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_2} {A : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A],
Function.Injective ⇑DoubleCentralizer.toProdMulOppositeHom | null | false |
Module.End.isSemisimple_sub_algebraMap_iff._simp_1 | Mathlib.LinearAlgebra.Semisimple | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, (f - (algebraMap R (Module.End R M)) μ).IsSemisimple = f.IsSemisimple | null | false |
Set.ZSMul | Mathlib.Algebra.Group.Pointwise.Set.Basic | {α : Type u_2} → [Zero α] → [Add α] → [Neg α] → SMul ℤ (Set α) | Repeated pointwise addition/subtraction (not the same as pointwise repeated
addition/subtraction!) of a `Set`. See note [pointwise nat action]. | true |
Lean.Grind.Linarith.instBEqExpr.beq._sparseCasesOn_3 | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Expr → Sort u} →
(t : Lean.Grind.Linarith.Expr) →
((a b : Lean.Grind.Linarith.Expr) → motive (a.add b)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.