name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.SignatureInformation.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureInformation → ℕ | null | false |
PresheafOfModules.Monoidal.tensorObj._proof_12 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat}
{X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : Y ⟶ Z) (x y : ↑((R.comp (CategoryTheory.forget₂ CommRingCat RingCat)).obj X)),
((RingCat.Hom.hom ((R.comp (CategoryTheory.forget₂ CommRingCat RingCat)).map g)).toNonUnitalRingHo... | null | false |
CategoryTheory.Functor.HasLeftDerivedFunctor.casesOn | Mathlib.CategoryTheory.Functor.Derived.LeftDerived | {C : Type u_1} →
{H : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_5, u_2} H] →
{F : CategoryTheory.Functor C H} →
{W : CategoryTheory.MorphismProperty C} →
{motive : F.HasLeftDerivedFunctor W → Sort u} →
(t : F.... | null | false |
CategoryTheory.Oplax.StrongTrans.whiskerLeft_naturality_id_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {G H : CategoryTheory.OplaxFunctor B CategoryTheory.Cat}
(θ : CategoryTheory.Oplax.StrongTrans G H) {a : B} {a' : CategoryTheory.Cat} (f : a' ⟶ G.obj a) (X : ↑a'),
CategoryTheory.CategoryStruct.comp
((θ.naturality (CategoryTheory.CategoryStruct.id a)).hom.... | null | true |
AddSubgroup.surjective_normedMk | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] (S : AddSubgroup M), Function.Surjective ⇑S.normedMk | `S.normedMk` is surjective. | true |
ENNReal.coe_comp_toNNReal_comp | Mathlib.Data.ENNReal.Basic | ∀ {ι : Type u_2} {f : ι → ENNReal}, (∀ (x : ι), f x ≠ ⊤) → (fun x => ↑x) ∘ ENNReal.toNNReal ∘ f = f | null | true |
AddOpposite.instMetricSpace | Mathlib.Topology.MetricSpace.Basic | {α : Type u_2} → [MetricSpace α] → MetricSpace αᵃᵒᵖ | null | true |
Dynamics.IsDynNetIn.of_le | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} {T : X → X} {U : SetRel X X} {m n : ℕ} {F s : Set X},
m ≤ n → Dynamics.IsDynNetIn T F U m s → Dynamics.IsDynNetIn T F U n s | null | true |
lp.evalₗ._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_1} (E : α → Type u_2) [inst : (i : α) → NormedAddCommGroup (E i)] (p : ENNReal) (i : α)
(x x_1 : ↥(lp E p)), ↑(x + x_1) i = ↑(x + x_1) i | null | false |
Batteries.RunningStats.recOn | Batteries.Data.RunningStats | {motive : Batteries.RunningStats → Sort u} →
(t : Batteries.RunningStats) →
((count : ℕ) → (mean var : Float) → motive { count := count, mean := mean, var := var }) → motive t | null | false |
Array.size_flatten | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xss : Array (Array α)}, xss.flatten.size = (Array.map Array.size xss).sum | null | true |
Array.any_eq_true | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α}, as.any p = true ↔ ∃ i, ∃ (x : i < as.size), p as[i] = true | null | true |
CategoryTheory.Arrow.hasLimitsOfShape | Mathlib.CategoryTheory.Limits.Comma | ∀ {J : Type w} [inst : CategoryTheory.Category.{w', w} J] {T : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} T]
[CategoryTheory.Limits.HasLimitsOfShape J T], CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Arrow T) | null | true |
Lean.Meta.instHashableOrigin | Lean.Meta.Tactic.Simp.SimpTheorems | Hashable Lean.Meta.Origin | null | true |
FiniteGaloisIntermediateField.instMax._proof_2 | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(L₁ L₂ : FiniteGaloisIntermediateField k K), FiniteDimensional k ↥(L₁.toIntermediateField ⊔ L₂.toIntermediateField) | null | false |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.tendsto_densityProcess_fst_atTop_univ_of_monotone._simp_1_4 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
CategoryTheory.Comma.mapRightId_inv_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} B] {A : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
(L : CategoryTheory.Functor A T) (X : CategoryTheory.Comma L R),
((CategoryTheory.Comma.mapRightId R ... | null | true |
SpecialLinearGroup.instCoeFunForall | Mathlib.LinearAlgebra.SpecialLinearGroup | {R : Type u_1} →
{V : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup V] → [inst_2 : Module R V] → CoeFun (SpecialLinearGroup R V) fun x => V → V | The coercion from `SpecialLinearGroup R V` to the function type `V → V` | true |
LinearOrderedAddCommMonoidWithTop.top_add' | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_3} [self : LinearOrderedAddCommMonoidWithTop α] (x : α), ⊤ + x = ⊤ | In a `LinearOrderedAddCommMonoidWithTop`, the `⊤` element is invariant under addition. | true |
Polynomial.isIntegral_coeff_of_factors | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Polynomial S),
IsIntegral R p.leadingCoeff →
p.Splits → (∀ (x : S), p.IsRoot x → IsIntegral R x) → ∀ (i : ℕ), IsIntegral R (p.coeff i) | null | true |
Set.Pairwise.subtype | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), s.Pairwise r → Pairwise fun x y => r ↑x ↑y | **Alias** of the reverse direction of `pairwise_subtype_iff_pairwise_set`. | true |
ContinuousAlgHom.copy_eq | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(f : A →A[R] B) (f' : A → B) (h : f' = ⇑f), f.copy f' h = f | null | true |
_private.Mathlib.Algebra.IsPrimePow.0.isPrimePow_nat_iff_bounded_log_minFac._proof_1_2 | Mathlib.Algebra.IsPrimePow | ∀ (n : ℕ), n ≠ 1 → Nat.Prime n.minFac | null | false |
Nat.getElem!_toArray_rio | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i : ℕ}, (*...n).toArray[i]! = if i < n then i else 0 | null | true |
PartialEquiv.isImage_source_target | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β), e.IsImage e.source e.target | null | true |
String.length_data | Init.Data.String.Length | ∀ {b : String}, b.toList.length = b.length | null | true |
Monotone.map_limsSup_of_continuousAt._auto_3 | Mathlib.Topology.Order.LiminfLimsup | Lean.Syntax | null | false |
ONote.add.match_1 | Mathlib.SetTheory.Ordinal.Notation | (motive : ONote → ONote → Sort u_1) →
(x x_1 : ONote) →
((o : ONote) → motive ONote.zero o) →
((e : ONote) → (n : ℕ+) → (a o : ONote) → motive (e.oadd n a) o) → motive x x_1 | null | false |
CategoryTheory.Monoidal.transportStruct.eq_1 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] (e : C ≌ D),
CategoryTheory.Monoidal.transportStruct e =
{
tensorObj := fun X Y =>
e.functor.obj (CategoryTheory.MonoidalCategoryStru... | null | true |
_private.Mathlib.Tactic.ErwQuestion.0.Mathlib.Tactic.Erw?._aux_Mathlib_Tactic_ErwQuestion___elabRules_Mathlib_Tactic_Erw?_erw?_1.match_1 | Mathlib.Tactic.ErwQuestion | (motive : Bool × Array (Unit → Lean.MessageData) → Sort u_1) →
(x : Bool × Array (Unit → Lean.MessageData)) →
((fst : Bool) → (msgs : Array (Unit → Lean.MessageData)) → motive (fst, msgs)) → motive x | null | false |
analyticOn_empty._simp_1 | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F},
AnalyticOn 𝕜 f ∅ = True | null | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Sigma.0.Finset.prod_comm'._simp_1_3 | Mathlib.Algebra.BigOperators.Group.Finset.Sigma | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
Std.DTreeMap.Raw.getKeyD_filter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Bool} {k fallback : α} (h : t.WF),
(Std.DTreeMap.Raw.filter f t).getKeyD k fallback = ((t.getKey? k).pfilter fun x h' => f x (t.get x ⋯)).getD fallbac... | null | true |
CategoryTheory.Injective.injective_under | Mathlib.CategoryTheory.Preadditive.Injective.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.EnoughInjectives C] (X : C),
CategoryTheory.Injective (CategoryTheory.Injective.under X) | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalNat._proof_17 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r r' : ℤ) (pq pq' : ℕ × ℕ),
r + 1 = r' →
↑pq.1 + r = ↑pq'.1 ∧ ↑pq.2 + (1 - r) = ↑pq'.2 → WithBotTop.coe (↑pq'.2 + r' - 1) = WithBotTop.coe (↑pq.2 + 1) | null | false |
Int.natAbs_le_lcm_right | Init.Data.Int.Gcd | ∀ {a : ℤ} (b : ℤ), a ≠ 0 → b.natAbs ≤ a.lcm b | null | true |
Uniformity.«_aux_Mathlib_Topology_UniformSpace_Defs___macroRules_Uniformity_termUniformContinuous[_,_]_1» | Mathlib.Topology.UniformSpace.Defs | Lean.Macro | null | false |
_private.Init.Grind.Ring.CommSolver.0.Ordering.then.match_1.splitter._sparseCasesOn_2 | Init.Grind.Ring.CommSolver | {motive : Ordering → Sort u} → (t : Ordering) → motive Ordering.eq → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.ShortComplex.ShortExact.gIsCokernel._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.ShortExact → CategoryTheory.Epi S.g | null | false |
continuousAt_subtype_val | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {p : X → Prop} {x : Subtype p}, ContinuousAt Subtype.val x | null | true |
SSet.Subcomplex.N.eq_iff_sMk_eq | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | ∀ {X : SSet} {A : X.Subcomplex} (x y : A.N),
x = y ↔ { dim := x.dim, simplex := x.simplex } = { dim := y.dim, simplex := y.simplex } | null | true |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing._proof_3 | Mathlib.RingTheory.Regular.RegularSequence | ∀ (α : Type u_1) (x : CommRing α) (r : α), (Ideal.span {r}).IsTwoSided | null | false |
InvImage.irreflexive | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} {β : Sort u_2} (r : β → β → Prop) (f : α → β) [Std.Irrefl r], Std.Irrefl (InvImage r f) | **Alias** of `InvImage.irrefl`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_eq_some_minKey._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Array.mapFinIdx_push._proof_3 | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {xs : Array α} {a : α}, xs.size < (xs.push a).size | null | false |
Turing.PartrecToTM2.tr_respects | Mathlib.Computability.TuringMachine.ToPartrec | StateTransition.Respects Turing.ToPartrec.step (Turing.TM2.step Turing.PartrecToTM2.tr) Turing.PartrecToTM2.TrCfg | null | true |
EReal.mul_inv | Mathlib.Data.EReal.Inv | ∀ (a b : EReal), (a * b)⁻¹ = a⁻¹ * b⁻¹ | null | true |
AddMonoid.Coprod.range_inl_sup_range_inr | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H],
AddMonoid.Coprod.inl.range ⊔ AddMonoid.Coprod.inr.range = ⊤ | null | true |
MeasureTheory.measurableCylinders.set | Mathlib.MeasureTheory.Constructions.Cylinders | {ι : Type u_1} →
{α : ι → Type u_2} →
[inst : (i : ι) → MeasurableSpace (α i)] →
{t : Set ((i : ι) → α i)} →
(ht : t ∈ MeasureTheory.measurableCylinders α) →
Set ((i : ↥(MeasureTheory.measurableCylinders.finset ht)) → α ↑i) | A set `S` such that `t = cylinder s S`. `s` is given by `measurableCylinders.finset`. | true |
CategoryTheory.SubobjectRepresentableBy._root.CategoryTheory.Classifier.SubobjectRepresentableBy.homEquiv_eq | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.SubobjectRepresentableBy Ω) {X : C} (f : X ⟶ Ω),
h.homEquiv f = (CategoryTheory.Subobject.pullback f).obj h.Ω₀ | **Alias** of `CategoryTheory.SubobjectRepresentableBy.homEquiv_eq`.
---
`h.homEquiv` acts like an "object comprehension" operator: it maps any characteristic map
`f : X ⟶ Ω` to the associated subobject of `X`, obtained by pulling back `h.Ω₀` along `f`. | false |
CategoryTheory.Pretriangulated.binaryProductTriangle_obj₁ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X₁ X₂ : C)
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasBinaryProduct X₁ X₂],
(CategoryTheory.Pretriangulated.binaryProductTriangle X₁ X₂).obj₁ = X₁ | null | true |
ComplexShape.embeddingUp'Add_f | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {A : Type u_3} [inst : AddCommSemigroup A] [inst_1 : IsRightCancelAdd A] (a b x : A),
(ComplexShape.embeddingUp'Add a b).f x = x + b | null | true |
AlgebraicGeometry.Scheme.ι_toIso_inv | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme),
CategoryTheory.CategoryStruct.comp ⊤.ι X.topIso.inv = CategoryTheory.CategoryStruct.id ↑⊤ | null | true |
Std.Iter.mapWithPostcondition | Init.Data.Iterators.Combinators.FilterMap | {α β γ : Type w} →
[Std.Iterator α Id β] →
{m : Type w → Type w'} → [inst : Monad m] → (f : β → Std.Iterators.PostconditionT m γ) → Std.Iter β → Std.IterM m γ | *Note: This is a very general combinator that requires an advanced understanding of monads,
dependent types and termination proofs. The variants `map` and `mapM` are easier to use and
sufficient for most use cases.*
If `it` is an iterator, then `it.mapWithPostcondition f` is another iterator that applies a monadic
fun... | true |
IccLeftChart._proof_6 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) [h : Fact (x < y)] ⦃x_1 : EuclideanHalfSpace 1⦄,
x_1 ∈ {z | (↑z).ofLp 0 < y - x} → ⟨min ((↑x_1).ofLp 0 + x) y, ⋯⟩ ∈ {z | ↑z < y} | null | false |
Erased.OutType | Mathlib.Data.Erased | Erased (Sort u) → Sort u | Extracts the erased value, if it is a type.
Note: `(mk a).OutType` is not definitionally equal to `a`.
| true |
Mathlib.Tactic.Algebra.evalSMulCast | Mathlib.Tactic.Algebra.Basic | {u u' v : Lean.Level} →
{R : Q(Type u)} →
{R' : Q(Type u')} →
{A : Q(Type v)} →
{sR : Q(CommSemiring «$R»)} →
{sA : Q(CommSemiring «$A»)} →
(sAlg : Q(Algebra «$R» «$A»)) →
(smul : Q(SMul «$R'» «$A»)) →
(r' : Q(«$R'»)) → Lean.MetaM ((r : Q(«$R»)) × ... | Handle scalar multiplication when the scalar ring `R'` doesn't match the base ring `R`.
Assumes `R` is an `R'`-algebra (i.e., `R'` is smaller), and casts the scalar using `algebraMap`. | true |
GroupTopology.instInfSet._proof_1 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u_1} [inst : Group α] (S : Set (GroupTopology α)), IsTopologicalGroup α | null | false |
ClassGroup.mkMMem | Mathlib.NumberTheory.ClassNumber.Finite | {R : Type u_1} →
{S : Type u_2} →
[inst : EuclideanDomain R] →
[inst_1 : CommRing S] →
[inst_2 : IsDomain S] →
[inst_3 : Algebra R S] →
{abv : AbsoluteValue R ℤ} →
{ι : Type u_5} →
[inst_4 : DecidableEq ι] →
[inst_5 : Fintype ι] →... | `ClassGroup.mkMMem` is a specialization of `ClassGroup.mk0` to (the finite set of)
ideals that contain `M := ∏ m ∈ finsetApprox L f abs, m`.
By showing this function is surjective, we prove that the class group is finite. | true |
MulActionHomClass | Mathlib.GroupTheory.GroupAction.Hom | (F : Type u_8) →
(M : outParam (Type u_9)) →
(X : outParam (Type u_10)) → (Y : outParam (Type u_11)) → [SMul M X] → [SMul M Y] → [FunLike F X Y] → Prop | `MulActionHomClass F M X Y` states that `F` is a type of
morphisms which are equivariant with respect to actions of `M`
This is an abbreviation of `MulActionSemiHomClass`. | true |
NNReal.agm.eq_1 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ (x y : NNReal), x.agm y = ⨅ n, (x.agmSequences y n).2 | null | true |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.withBotCoe_subset_iff._simp_1_2 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (I J : BoxIntegral.Box ι), (I ≤ J) = ∀ x ∈ I, x ∈ J | null | false |
Lean.Meta.Match.logIncorrectNumberOfPatternsAt | Lean.Meta.Match.Match | {α : Type} → [Lean.ToMessageData α] → Lean.Syntax → String → ℕ → ℕ → List α → Lean.MetaM Unit | Logs an error indicating that the alternative at `ref` contains an unexpected number of patterns.
Remark: we allow `α` to be arbitrary because this error may be thrown before or after elaborating
pattern syntax.
| true |
Std.DHashMap.Internal.Raw₀.getD_emptyWithCapacity | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α] {a : α} {fallback : β a}
{c : ℕ}, (Std.DHashMap.Internal.Raw₀.emptyWithCapacity c).getD a fallback = fallback | null | true |
_private.Mathlib.FieldTheory.KummerExtension.0.isCyclic_tfae.match_1_3 | Mathlib.FieldTheory.KummerExtension | ∀ (K : Type u_2) (L : Type u_1) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : (∃ α, α ^ Module.finrank K L ∈ Set.range ⇑(algebraMap K L) ∧ K⟮α⟯ = ⊤) → Prop)
(x : ∃ α, α ^ Module.finrank K L ∈ Set.range ⇑(algebraMap K L) ∧ K⟮α⟯ = ⊤),
(∀ (α : L) (a : K) (ha : (algebraMap K L) a = α ^ Module.f... | null | false |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor_obj | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] (A : CategoryTheory.Comon (CategoryTheory.Functor C D)),
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functor.obj A =
CategoryTheory.Mon... | null | true |
CategoryTheory.Abelian.SpectralObject.dHomologyData._proof_18 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{u_3, u_4} ι] (X : CategoryTheory.Abelian.SpectralObject C ι) {i₁ i₃ i₄ i₅ i₆ : ι}
(f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₆ : i₅ ⟶ i₆) (f₂₃ : i₁ ⟶ i₃) (f₅₆ : i₄ ⟶ i₆)
(h₅₆ :... | null | false |
CliffordAlgebra.changeForm | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | {R : Type u1} →
[inst : CommRing R] →
{M : Type u2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q Q' : QuadraticForm R M} →
{B : LinearMap.BilinForm R M} →
LinearMap.BilinMap.toQuadraticMap B = Q' - Q → CliffordAlgebra Q →ₗ[R] CliffordAlgebra Q' | Convert between two algebras of different quadratic forms, sending vectors to vectors, scalars
to scalars, and adjusting products by a contraction term.
This is $\lambda_B$ from [bourbaki2007] §9 Lemma 2. | true |
OrderedFinpartition.extendMiddle | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | {n : ℕ} → (c : OrderedFinpartition n) → Fin c.length → OrderedFinpartition (n + 1) | Extend an ordered partition of `n` entries, by adding to the `i`-th part a new point to the
left. | true |
Std.Async.UDP.Socket.noConfusionType | Std.Async.UDP | Sort u → Std.Async.UDP.Socket → Std.Async.UDP.Socket → Sort u | null | false |
HXor.hXor | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HXor α β γ] → α → β → γ | `a ^^^ b` computes the bitwise XOR of `a` and `b`.
The meaning of this notation is type-dependent.
Conventions for notations in identifiers:
* The recommended spelling of `^^^` in identifiers is `xor`. | true |
GrpCat.groupObj._proof_10 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J GrpCat) (j : J),
autoParam (∀ (x : (F.comp (CategoryTheory.forget GrpCat)).obj j), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
Option.orElse_eq_none | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} (o o' : Option α), (o <|> o') = none ↔ o = none ∧ o' = none | null | true |
CategoryTheory.CartesianMonoidalCategory.prodComparison_inv_natural_whiskerRight | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {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) {A B A' : C}
[inst_4 : CategoryTheory.IsIso (CategoryThe... | If the product comparison morphism is an iso, its inverse is natural in the left argument. | true |
RingFilterBasis.submodulesBasisIsBasis | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(BR : RingFilterBasis R) {B : ι → Submodule R M}, BR.SubmodulesBasis B → SubmodulesBasis B | null | true |
CategoryTheory.sheafHom'._proof_2 | Mathlib.CategoryTheory.Sites.SheafHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{A : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} A] (F G : CategoryTheory.Sheaf J A) {X Y Z : Cᵒᵖ}
(f : X ⟶ Y) (g : Y ⟶ Z),
TypeCat.ofHom (J.overMapPullback A (CategoryTheory.CategoryStruct.comp f... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.free_bot.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_1} {β : Type u_2} {A : SimpleGraph α} (motive : A.IsContained ⊥ → Prop) (h : A.IsContained ⊥),
(∀ (f : A →g ⊥) (hf : Function.Injective ⇑f), motive ⋯) → motive h | null | false |
DoldKan.«_aux_Mathlib_AlgebraicTopology_DoldKan_Notations___macroRules_DoldKan_termK[_]_1» | Mathlib.AlgebraicTopology.DoldKan.Notations | Lean.Macro | null | false |
AffineSubspace.instSetLike | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_3} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] → [inst_2 : Module k V] → [inst_3 : AddTorsor V P] → SetLike (AffineSubspace k P) P | null | true |
_private.Lean.Meta.WHNF.0.Lean.Meta.getStuckMVar?.match_15 | Lean.Meta.WHNF | (motive : Lean.Expr → Sort u_1) →
(f : Lean.Expr) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((fName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const fName us)) →
((typeName : Lean.Name) → (idx : ℕ) → (e : Lean.Expr) → motive (Lean.Expr.proj typeName idx e)) →
... | null | false |
CategoryTheory.Abelian.subobjectIsoSubobjectOp._proof_1 | Mathlib.CategoryTheory.Abelian.Subobject | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] (X : C) ⦃A : Cᵒᵖ⦄
(f : A ⟶ Opposite.op X) [hf : CategoryTheory.Mono f],
(CategoryTheory.CategoryStruct.comp
{
hom :=
(CategoryTheory.Abelian.epiDesc f.unop
(Category... | null | false |
_private.Mathlib.RingTheory.QuasiFinite.Weakly.0.Algebra.WeaklyQuasiFiniteAt.of_restrictScalars._simp_1_1 | Mathlib.RingTheory.QuasiFinite.Weakly | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {T : Type u_3} [inst_2 : Semiring T] {I : Ideal R}
(f : R →+* S) (g : S →+* T), Ideal.map (g.comp f) I = Ideal.map g (Ideal.map f I) | null | false |
Height.mulHeight₁ | Mathlib.NumberTheory.Height.Basic | {K : Type u_1} → [inst : Field K] → [Height.AdmissibleAbsValues K] → K → ℝ | The multiplicative height of an element of `K`. | true |
CompleteLat.dualEquiv._proof_1 | Mathlib.Order.Category.CompleteLat | ∀ {X Y : CompleteLat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id CompleteLat).map f)
(CompleteLat.Iso.mk (OrderIso.dualDual ↑Y)).hom =
CategoryTheory.CategoryStruct.comp (CompleteLat.Iso.mk (OrderIso.dualDual ↑X)).hom
((CompleteLat.dual.comp CompleteLat.dual).map f) | null | false |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.Bounded.match_1.splitter._sparseCasesOn_2 | Mathlib.Data.Ordmap.Ordset | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
cfc_commute_cfc | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
UInt64.toFin_ofNatTruncate_of_le | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, UInt64.size ≤ n → (UInt64.ofNatClamp n).toFin = ⟨UInt64.size - 1, UInt64.toFin_ofNatClamp_of_le._proof_1⟩ | null | true |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.star_rmatch_iff._simp_1_13 | Mathlib.Computability.RegularExpressions | ∀ {α : Sort u_1} {a' : α} {P Q : α → Prop}, (∀ (a : α), a = a' ∨ Q a → P a) = (P a' ∧ ∀ (a : α), Q a → P a) | null | false |
CategoryTheory.Functor.mapMonIdIso.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.Functor.mapMonIdIso =
CategoryTheory.NatIso.ofComponents
(fun X => CategoryTheory.Mon.mkIso (CategoryTheory.Iso.refl ((CategoryTheory.Functor.id C).mapMon.obj X).X) ⋯ ⋯) ⋯ | null | true |
Std.Time.WallTime.subMinutes | Std.Time.DateTime.WallTime | Std.Time.WallTime → Std.Time.Minute.Offset → Std.Time.WallTime | Subtracts a `Minute.Offset` from the given `WallTime`.
| true |
_private.Mathlib.Analysis.Convex.Deriv.0.StrictAntiOn.strictConcaveOn_of_deriv._simp_1_1 | Mathlib.Analysis.Convex.Deriv | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, -deriv f x = deriv (-f) x | null | false |
TotalComplexShape.symmSymmetry._proof_4 | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_2} {I₂ : Type u_1} {I₁₂ : Type u_3} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] (x : I₁) (x_1 : I₂) {i₂' : I₂},
c₂.Rel x_1 i₂' → 1 * c₁.ε₂ c₂ c₁₂ (x, x_1) = c₂.ε₁ c₁ c₁₂ (x_1, x) * 1 | null | false |
_private.Lean.Meta.Tactic.Grind.MatchCond.0.PSigma.casesOn._arg_pusher | Lean.Meta.Tactic.Grind.MatchCond | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
Mathlib.Explode.Entry.ctorIdx | Mathlib.Tactic.Explode.Datatypes | Mathlib.Explode.Entry → ℕ | null | false |
ContinuousAlternatingMap.addCommMonoid._proof_2 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_4} [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] [inst_7 : ContinuousAdd N] (a : M [⋀^ι]→L[R] N), 0 + a = a | null | false |
_private.Lean.Elab.Deriving.Basic.0.Lean.Elab.Term.mkInst.go._unsafe_rec | Lean.Elab.Deriving.Basic | Lean.Name →
Lean.Expr →
Lean.Expr →
Array Lean.Expr →
Array Lean.BinderInfo →
Lean.Expr →
Lean.Name → Lean.Expr → Array Lean.MVarId → Lean.Expr → Lean.Elab.TermElabM Lean.Elab.Term.MkInstResult✝ | null | false |
CategoryTheory.PreOneHypercover.p₁_sigmaOfIsColimit_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} (E : CategoryTheory.PreOneHypercover S)
{c : CategoryTheory.Limits.Cofan E.X} (hc : CategoryTheory.Limits.IsColimit c) {d : CategoryTheory.Limits.Cofan E.Y'}
(hd : CategoryTheory.Limits.IsColimit d) (i : E.I₁') {a b : PUnit.{w + 1}} (r : (E.sigmaOfIsC... | null | true |
Std.Time.Minute.instLTOrdinal | Std.Time.Time.Unit.Minute | LT Std.Time.Minute.Ordinal | null | true |
MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image_aux1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] {s : Set E}
{f : E → E} {f' : E → E →L[ℝ] E} [inst_3 : MeasurableSpace E] [BorelSpace E] (μ : MeasureTheory.Measure E)
[μ.IsAddHaarMeasure],
MeasurableSet s →
(∀ x ∈ s, HasFDerivWithinAt f (f' x) s x) →
Set... | null | true |
ContinuousAt.comp₂ | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : Y × Z → W} {g : X → Y} {h : X → Z} {x : X},
ContinuousAt f (g x, h x) → ContinuousAt g x → ContinuousAt h x → ContinuousAt (fun x => f ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.