name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddSubsemigroup.centerCongr | Mathlib.GroupTheory.Submonoid.Center | {M : Type u_2} →
{N : Type u_1} →
[inst : Add M] → [inst_1 : Add N] → M ≃+ N → ↥(AddSubsemigroup.center M) ≃+ ↥(AddSubsemigroup.center N) | The center of isomorphic additive magmas are isomorphic. | true |
SuccChain.eq_1 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} (r : α → α → Prop) (s : Set α),
SuccChain r s = if h : ∃ t, IsChain r s ∧ SuperChain r s t then h.choose else s | null | true |
CategoryTheory.NatTrans.CommShift₂ | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] →
[inst_2 : CategoryTheory.Category.{v_5, u_5} D] →
{M : Type u_6} →
[inst_3 : AddCommMonoid M] →
... | If `τ : G₁ ⟶ G₂` is a natural transformation between two bifunctors
which commute shifts on both variables, this typeclass asserts a compatibility of `τ`
with these shifts. | true |
HOrElse.recOn | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HOrElse α β γ → Sort u_1} →
(t : HOrElse α β γ) → ((hOrElse : α → (Unit → β) → γ) → motive { hOrElse := hOrElse }) → motive t | null | false |
_private.Mathlib.Computability.RE.0.Computable.find._simp_1_1 | Mathlib.Computability.RE | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (H : ∃ n, p n), p (Nat.find H) = True | null | false |
Sylow.le_center_or_le_commutator | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} [inst : Group G] {p : ℕ} [Fact (Nat.Prime p)] [Finite G] (P : Sylow p G) [IsCyclic ↥↑P] [(↑P).Normal],
↑P ≤ Subgroup.center G ∨ ↑P ≤ commutator G | A normal cyclic Sylow subgroup is either central or contained in the commutator subgroup. | true |
UInt64.ofNatTruncate | Init.Data.UInt.BasicAux | ℕ → UInt64 | Converts a natural number to a 64-bit unsigned integer, returning the largest representable value if
the number is too large.
Returns `2^64 - 1` for natural numbers greater than or equal to `2^64`.
| true |
String.Slice.Pos.skipWhile_char_eq_self_iff_get | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos}, pos.skipWhile c = pos ↔ ∀ (h : pos ≠ s.endPos), pos.get h ≠ c | null | true |
DomAddAct.vadd_aeeqFun_const | Mathlib.MeasureTheory.Function.AEEqFun.DomAct | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace β] [inst_2 : VAdd M α] [inst_3 : MeasurableConstVAdd M α]
[inst_4 : MeasureTheory.VAddInvariantMeasure M α μ] (c : Mᵈᵃᵃ) (b : β),
c +ᵥ MeasureTheory.AEEqFun.const α b = MeasureTheory.... | null | true |
Representation.IntertwiningMap.mk.inj | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {inst : Semiring A} {inst_1 : Monoid G}
{inst_2 : AddCommMonoid V} {inst_3 : AddCommMonoid W} {inst_4 : Module A V} {inst_5 : Module A W}
{ρ : Representation A G V} {σ : Representation A G W} {toLinearMap : V →ₗ[A] W}
{isIntertwining' : ∀ (g : G), toLi... | null | true |
TensorProduct.quotientTensorQuotientEquiv._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_2} {M : Type u_1} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (m : Submodule R M) (n : Submodule R N),
∀ x ∈ m,
x ∈
(n.liftQ
((TensorProduct.mk R M N).flip.compr₂
((TensorProduct.... | null | false |
SSet.stdSimplex.faceRepresentableBy._proof_10 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (S : Finset (Fin (n + 1))) (m : ℕ) (e : Fin (m + 1) ≃o ↥S) {j : SimplexCategory} (f : j ⟶ { len := m }),
(fun x =>
match x with
| ⟨x, hx⟩ =>
SimplexCategory.Hom.mk
{ toFun := fun i => e.symm ⟨(SimplexCategory.Hom.toOrderHom (SSet.stdSimplex.objEquiv x)) i, ⋯⟩,
... | null | false |
BoundedContinuousFunction.restrict | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] → BoundedContinuousFunction α β → (s : Set α) → BoundedContinuousFunction (↑s) β | **Alias** of `BoundedContinuousFunction.domRestrict`.
---
Restrict the domain of a bounded continuous function to a set. | true |
Lean.Syntax.Ident | Init.Meta.Defs | Type | Syntax that represents an identifier.
| true |
Lean.JsonRpc.ErrorCode.requestCancelled | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode | The client has canceled a request and a server as detected the cancel. | true |
NonUnitalStarSubalgebra.inclusion.congr_simp | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] {S T : NonUnitalStarSubalgebra R A} (h : S ≤ T),
NonUnitalStarSubalgebra.inclusion h = NonUnitalStarSubalgebra.inclusion h | null | true |
AddMonoidHom.extension._proof_6 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [inst_2 : IsUniformAddGroup α]
[inst_3 : UniformSpace β] [inst_4 : AddGroup β] [IsUniformAddGroup β] [CompleteSpace β] [T0Space β] (f : α →+ β),
UniformContinuous ⇑f →
∀ (a b : UniformSpace.Completion α),
UniformSpace.Completion... | null | false |
AffineSubspace.WSameSide.trans | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y z : P}, s.WSameSide x y → s.WSameSide y z → y ∉ s → s.WSameSide x z | null | true |
HomologicalComplex.isIso_quotient_map_iff_homotopyEquivalences | Mathlib.Algebra.Homology.HomotopyCategory | ∀ {ι : Type u_3} {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{c : ComplexShape ι} {K L : HomologicalComplex V c} (f : K ⟶ L),
CategoryTheory.IsIso ((HomotopyCategory.quotient V c).map f) ↔ HomologicalComplex.homotopyEquivalences V c f | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.ElabLink.mk | Lean.Elab.DocString | Lean.StrLit → Lean.Doc.ElabLink✝ | null | true |
Topology.CWComplex.skeletonLT_top | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D],
↑(Topology.RelCWComplex.skeletonLT C ⊤) = C | **Alias** of `Topology.RelCWComplex.skeletonLT_top`. | true |
_private.Mathlib.Topology.Algebra.Group.Pointwise.0.IsClosed.vadd_left_of_isCompact.match_1_1 | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} (motive : (x : ↑s × β) → x ∈ Prod.snd ⁻¹' t → Prop) (x : ↑s × β)
(hx : x ∈ Prod.snd ⁻¹' t),
(∀ (g : α) (hg : g ∈ s) (x : β) (hx : (⟨g, hg⟩, x) ∈ Prod.snd ⁻¹' t), motive (⟨g, hg⟩, x) hx) → motive x hx | null | false |
StieltjesFunction.casesOn | Mathlib.MeasureTheory.Measure.Stieltjes | {R : Type u_1} →
[inst : LinearOrder R] →
[inst_1 : TopologicalSpace R] →
{motive : StieltjesFunction R → Sort u} →
(t : StieltjesFunction R) →
((toFun : R → ℝ) →
(mono' : Monotone toFun) →
(right_continuous' : ∀ (x : R), ContinuousWithinAt toFun (Set.Ici x) x... | null | false |
Irrational.of_intCast_mul | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (m : ℤ), Irrational (↑m * x) → Irrational x | null | true |
IsBezout.of_isPrincipalIdealRing | Mathlib.RingTheory.PrincipalIdealDomain | ∀ (R : Type u) [inst : Semiring R] [IsPrincipalIdealRing R], IsBezout R | null | true |
PUnit.addCommGroup | Mathlib.Algebra.Group.PUnit | AddCommGroup PUnit.{u_1 + 1} | null | true |
EisensteinSeries.norm_eq_max_natAbs | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (x : Fin 2 → ℤ), ‖x‖ = ↑(max (x 0).natAbs (x 1).natAbs) | null | true |
CategoryTheory.CosimplicialObject.equivalenceLeftToRight._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePushout f.left (fun x => f.right) fun x => f.hom]
(F : CategoryTheory.Arrow C) (X : CategoryTheory.CosimplicialObject.Augmented C) (G : F.augmentedCechConerve ⟶ X),... | null | false |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.contains'.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.lt) (h_2 : Unit → motive Ordering.gt)
(h_3 : Unit → motive Ordering.eq),
(match Ordering.lt with
| Ordering.lt => h_1 ()
| Ordering.gt => h_2 ()
| Ordering.eq => h_3 ()) =
h_1 () | null | true |
genLoopHomeoOfIsEmpty._proof_5 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] (N : Type u_2) (x : X) [inst_1 : IsEmpty N],
Continuous fun x_1 => ⟨ContinuousMap.const'.toFun x_1, ⋯⟩ | null | false |
Basis.piTensorProduct_repr_tprod_apply | Mathlib.LinearAlgebra.PiTensorProduct.Basis | ∀ {ι : Type u_1} {R : Type u_2} {M : ι → Type u_3} {κ : ι → Type u_4} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Fintype ι]
(b : (i : ι) → Module.Basis (κ i) R (M i)) (x : (i : ι) → M i) (p : (i : ι) → κ i),
((Basis.piTensorProduct b).repr ((PiTe... | null | true |
RingHom.Smooth.eq_1 | Mathlib.RingTheory.RingHom.Smooth | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S), f.Smooth = Algebra.Smooth R S | null | true |
GrpCat.SurjectiveOfEpiAuxs.g_ne_h | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B),
∀ x ∉ (GrpCat.Hom.hom f).range, GrpCat.SurjectiveOfEpiAuxs.g f ≠ GrpCat.SurjectiveOfEpiAuxs.h f | null | true |
Subgroup.IsComplement.equiv_mul_right_of_mem | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {K : Subgroup G} {S : Set G} (hSK : Subgroup.IsComplement S ↑K) {g k : G} (h : k ∈ K),
hSK.equiv (g * k) = ((hSK.equiv g).1, (hSK.equiv g).2 * ⟨k, h⟩) | null | true |
Module.bijOn_reflection_of_mapsTo | Mathlib.LinearAlgebra.Reflection | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x : M}
{f : Module.Dual R M} {Φ : Set M} (h : f x = 2),
Set.MapsTo (⇑(Module.reflection h)) Φ Φ → Set.BijOn (⇑(Module.reflection h)) Φ Φ | null | true |
BitVec.sdiv | Init.Data.BitVec.Basic | {n : ℕ} → BitVec n → BitVec n → BitVec n | Signed T-division (using the truncating rounding convention) for bitvectors. This function obeys the
Lean convention that division by zero returns zero.
Examples:
* `(7#4).sdiv 2 = 3#4`
* `(-8#4).sdiv 2 = -4#4`
* `(5#4).sdiv -2 = -2#4`
* `(-7#4).sdiv (-2) = 3#4`
| true |
CategoryTheory.Pretriangulated.Triangle.π₂Toπ₃_app | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(T : CategoryTheory.Pretriangulated.Triangle C), CategoryTheory.Pretriangulated.Triangle.π₂Toπ₃.app T = T.mor₂ | null | true |
LieAlgebra.subsingleton_of_hasTrivialRadical_lie_abelian | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[LieAlgebra.HasTrivialRadical R L] [h : IsLieAbelian L], Subsingleton L | An abelian Lie algebra with trivial radical is trivial. | true |
Nat.IsCarmichael.not_prime | Mathlib.NumberTheory.CarmichaelNumber | ∀ {n : ℕ}, n.IsCarmichael → ¬Nat.Prime n | null | true |
AddMonoidHom.mkNormedAddGroupHom._proof_1 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_2} {W : Type u_1} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W] (f : V →+ W)
(x y : V), (↑f).toFun (x + y) = (↑f).toFun x + (↑f).toFun y | null | false |
Lean.Order.CCPO.recOn | Init.Internal.Order.Basic | {α : Sort u} →
{motive : Lean.Order.CCPO α → Sort u_1} →
(t : Lean.Order.CCPO α) →
([toPartialOrder : Lean.Order.PartialOrder α] →
(has_csup : ∀ {c : α → Prop}, Lean.Order.chain c → Exists (Lean.Order.is_sup c)) →
motive { toPartialOrder := toPartialOrder, has_csup := has_csup }) →
... | null | false |
_private.Mathlib.Data.List.Dedup.0.List.headI_dedup.match_1_1 | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} (motive : List α → Prop) (l : List α),
(∀ (_ : Unit), motive []) → (∀ (a : α) (l : List α), motive (a :: l)) → motive l | null | false |
CategoryTheory.Coyoneda.colimitCoconeIsColimit._proof_1 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : Cᵒᵖ)
(s : CategoryTheory.Limits.Cocone (CategoryTheory.coyoneda.obj X)) (Y : C),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Coyoneda.colimitCocone X).ι.app Y)
(TypeCat.ofHom fun x =>
(CategoryTheory.ConcreteCategory.hom (s.ι.... | null | false |
Std.HashMap.Raw.get.congr_simp | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (m m_1 : Std.HashMap.Raw α β) (e_m : m = m_1)
(a a_1 : α) (e_a : a = a_1) (h : a ∈ m), m.get a h = m_1.get a_1 ⋯ | null | true |
HasOpenLowerSectionsOn.inter | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f g : α → Set β} {s : Set α},
HasOpenLowerSectionsOn f s → HasOpenLowerSectionsOn g s → HasOpenLowerSectionsOn (fun x => f x ∩ g x) s | null | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.casesOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
((e : Lean.Expr) → motive_7 (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.core e)) →
((e thm : Lean.Expr) →
(d : ℕ) →
(a : Int.Internal.Linear.Expr) →
motiv... | null | false |
Nat.choose_succ_left | Mathlib.Data.Nat.Choose.Basic | ∀ (n k : ℕ), 0 < k → (n + 1).choose k = n.choose (k - 1) + n.choose k | null | true |
Finset.mulOneClass._proof_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulOneClass α] (s t : Finset α), ↑(s * t) = ↑s * ↑t | null | false |
SimpleGraph.card_commonNeighbors_lt_card_verts | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj] (v w : V),
Fintype.card ↑(G.commonNeighbors v w) < Fintype.card V | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.le₁₂' | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (pq' : κ) {i₁ i₂ : ι},
i₁ = data.i₁ pq' → i₂ = data.i₂ pq' → i₁ ≤ i₂ | null | true |
ULift.down_injective | Mathlib.Logic.Function.ULift | ∀ {α : Type u_1}, Function.Injective ULift.down | null | true |
Field.Emb.Cardinal.embFunctor | Mathlib.FieldTheory.CardinalEmb | (F : Type u) →
(E : Type v) →
[inst : Field F] →
[inst_1 : Field E] →
[inst_2 : Algebra F E] →
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] →
[inst_3 : Algebra.IsAlgebraic F E] →
⦃i j : WithTop (Module.rank F E).ord.ToType⦄ →
i ≤ j →
... | The functor on `WithTop ι` given by embeddings of `E⟮<i⟯` into `Ē` | true |
BitVec.carry_succ_one | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (i : ℕ) (x : BitVec w), 0 < w → BitVec.carry (i + 1) x (1#w) false = decide (∀ j ≤ i, x.getLsbD j = true) | null | true |
Ordnode.rotateL_node | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (l : Ordnode α) (x : α) (sz : ℕ) (m : Ordnode α) (y : α) (r : Ordnode α),
l.rotateL x (Ordnode.node sz m y r) = if m.size < Ordnode.ratio * r.size then l.node3L x m y r else l.node4L x m y r | null | true |
AlgebraicGeometry.Scheme.PartialIso.trans._proof_3 | Mathlib.AlgebraicGeometry.Birational.Birational | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X.PartialIso Y) (g : Y.PartialIso Z), f.target ⊓ g.source ≤ g.source | null | false |
CategoryTheory.Abelian.SpectralObject.instMonoICycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (n : ℤ),
CategoryTheory.Mono (X.iCycles f g n) | null | true |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.lowerLet.lowerNonObjectFields._unsafe_rec | Lean.Compiler.LCNF.ToImpure | Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Lean.Compiler.LCNF.CtorInfo →
Array Lean.Compiler.LCNF.CtorFieldInfo →
Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.impure) →
Lean.Compiler.LCNF.ToImpureM✝ (Lean.... | null | false |
CategoryTheory.Functor.OneHypercoverDenseData.sieve_mem | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} [CategoryTheory.Functor.IsDenseSubsite J₀ J F] {X : C}
(data : F.OneHyp... | null | true |
CategoryTheory.NatTrans.mapSquare_app_τ₁ | Mathlib.CategoryTheory.Square | ∀ {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} (τ : F ⟶ G) (sq : CategoryTheory.Square C),
((CategoryTheory.NatTrans.mapSquare τ).app sq).τ₁ = τ.app sq.X₁ | null | true |
CliffordAlgebra.EquivEven.e0 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (Q : QuadraticForm R M) → CliffordAlgebra (CliffordAlgebra.EquivEven.Q' Q) | The unit vector in the new dimension | true |
CategoryTheory.Sigma.SigmaHom._sizeOf_inst | Mathlib.CategoryTheory.Sigma.Basic | {I : Type w₁} →
{C : I → Type u₁} →
{inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)} →
(a a_1 : (i : I) × C i) → [SizeOf I] → [(a : I) → SizeOf (C a)] → SizeOf (CategoryTheory.Sigma.SigmaHom a a_1) | null | false |
instShiftRightInt8 | Init.Data.SInt.Basic | ShiftRight Int8 | null | true |
Submonoid.mem_bot._simp_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] {x : M}, (x ∈ ⊥) = (x = 1) | null | false |
Submodule.coe_mapAlgHom_apply | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_3} {B : Type u_4} [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (p : Submodule R A),
↑((Submodule.mapAlgHom f) p) = ⇑f '' ↑p | null | true |
SSet.PtSimplex.RelStruct.refl._proof_10 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} (f : X.PtSimplex n x) (i : Fin (n + 1)) (j : Fin (n + 2)),
i.succ < j →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j)
(CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.σ i) f.map) =
SSet.const x | null | false |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : TopologicalSpace R] [IsTopologicalSemiring R], ContinuousConstSMul R R | null | false |
map_intCast | Mathlib.Data.Int.Cast.Lemmas | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : NonAssocRing α] [inst_1 : NonAssocRing β]
[inst_2 : FunLike F α β] [RingHomClass F α β] (f : F) (n : ℤ), f ↑n = ↑n | null | true |
DegLex.forall_iff | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} {p : DegLex α → Prop}, (∀ (a : DegLex α), p a) ↔ ∀ (a : α), p (toDegLex a) | null | true |
AddSubmonoid.LocalizationMap.mk'_sec | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {N : Type u_2} [inst_1 : AddCommMonoid N]
(f : S.LocalizationMap N) (z : N), f.mk' (f.sec z).1 (f.sec z).2 = z | Given a localization map `f : M →+ N` for an AddSubmonoid `S ⊆ M`, for all `z : N`
we have that if `x : M, y ∈ S` are such that `z + f y = f x`, then `f x - f y = z`. | true |
hasDerivAt_finCons | Mathlib.Analysis.Calculus.Deriv.Prod | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {n : ℕ} {F' : Fin n.succ → Type u_1}
[inst_1 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_2 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : 𝕜 → F' 0} {φs : 𝕜 → (i : Fin n) → F' i.succ} {φ' : (i : Fin n.succ) → F' i},
HasDerivAt (fun x => Fin... | null | true |
Sym2.diagElem._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (a b a' b' : α) (h : Sym2.Rel α (a, b) (a', b')) (hx : a' = b'),
Eq.ndrec (motive := fun x => x.IsDiag → α) (fun x => a) ⋯ hx = a' | null | false |
Option.head?_toList | Init.Data.Option.List | ∀ {α : Type u_1} {o : Option α}, o.toList.head? = o | null | true |
TensorAlgebra.instSMulCommClass | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ {R : Type u_3} {S : Type u_4} {A : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid M] [inst_3 : CommSemiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
[inst_6 : Module A M], SMulCommClass R S (TensorAlgebra A M) | null | true |
Module.FaithfullyFlat.lTensor_surjective_iff_surjective._simp_1 | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u) (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_4}
{N' : Type u_5} [inst_3 : AddCommGroup N] [inst_4 : AddCommGroup N'] [inst_5 : Module R N] [inst_6 : Module R N']
(f : N →ₗ[R] N') [Module.FaithfullyFlat R M], Function.Surjective ⇑(LinearMap.lTensor M f) ... | null | false |
Complex.cos_int_mul_two_pi_sub_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (n : ℤ), Complex.cos (↑n * (2 * ↑Real.pi) - ↑Real.pi) = -1 | null | true |
Std.DHashMap.Internal.Raw₀.Const.get!_eq_get!_get? | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α] [inst_4 : Inhabited β],
(↑m).WF → ∀ {a : α}, Std.DHashMap.Internal.Raw₀.Const.get! m a = (Std.DHashMap.Internal.Raw₀.Const.get? m a).get! | null | true |
Real.instNormedAddCommGroupAngle._aux_26 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Real.Angle → Real.Angle → ℝ | null | false |
Lean.Compiler.LCNF.instInhabitedCtorFieldInfo | Lean.Compiler.LCNF.ToImpureType | Inhabited Lean.Compiler.LCNF.CtorFieldInfo | null | true |
Std.Http.Protocol.H1.RedirectBodyAction._sizeOf_inst | Std.Http.Protocol.H1.Redirect | SizeOf Std.Http.Protocol.H1.RedirectBodyAction | null | false |
SetRel.preimage_empty_left | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2} (t : Set β), ∅.preimage t = ∅ | null | true |
List.forM._sunfold | Init.Data.List.Control | {m : Type u → Type v} → [Monad m] → {α : Type w} → List α → (α → m PUnit.{u + 1}) → m PUnit.{u + 1} | null | false |
Nat.getD_toList_roo | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i fallback : ℕ}, (m<...n).toList.getD i fallback = if i < n - (m + 1) then m + 1 + i else fallback | null | true |
DerivingHelpers.tacticDeriving_ReflEq_tactic | Init.LawfulBEqTactics | Lean.ParserDescr | null | true |
ExpGrowth.expGrowthInf_mul_le | Mathlib.Analysis.Asymptotics.ExpGrowth | ∀ {u v : ℕ → ENNReal},
ExpGrowth.expGrowthSup u ≠ ⊥ ∨ ExpGrowth.expGrowthInf v ≠ ⊤ →
ExpGrowth.expGrowthSup u ≠ ⊤ ∨ ExpGrowth.expGrowthInf v ≠ ⊥ →
ExpGrowth.expGrowthInf (u * v) ≤ ExpGrowth.expGrowthSup u + ExpGrowth.expGrowthInf v | See `expGrowthInf_mul_le'` for a version with swapped argument `u` and `v`. | true |
CategoryTheory.SubmonoidFunctor.image._proof_2 | Mathlib.CategoryTheory.Subfunctor.SubmonoidFunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {M M' : CategoryTheory.Functor C MonCat} (x : C),
MonoidHomClass (↑(M.obj x) →* ↑(M'.obj x)) ↑(M.obj x) ↑(M'.obj x) | null | false |
VectorField.mlieBracketWithin_swap | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {V W : (x : M) → TangentSpa... | null | true |
HasStrictFDerivAt.tendsto_implicitFunction | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : CompleteSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : CompleteSpace E] {F : Type u_3}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] [inst_7 : FiniteDimensional 𝕜 F] {f : E → F}
{f' : E →... | null | true |
_private.Batteries.Lean.LawfulMonadLift.0.EIO.adapt.eq_1 | Batteries.Lean.LawfulMonadLift | ∀ {ε ε' α : Type} (f : ε → ε') (m : EIO ε α) (s : Void IO.RealWorld),
EIO.adapt f m s =
match m s with
| EST.Out.ok a s => EST.Out.ok a s
| EST.Out.error e s => EST.Out.error (f e) s | null | true |
Matrix.piAlgEquiv._proof_4 | Mathlib.Data.Matrix.Basic | ∀ {n : Type u_3} {ι : Type u_1} {β : ι → Type u_2} (R : Type u_4) [inst : CommSemiring R]
[inst_1 : (i : ι) → Semiring (β i)] [inst_2 : (i : ι) → Algebra R (β i)] [inst_3 : Fintype n] [inst_4 : DecidableEq n]
(r : R),
(AlgHom.mk' Matrix.piRingEquiv.toRingHom ⋯) ((algebraMap R (Matrix n n ((i : ι) → β i))) r) =
... | null | false |
GenContFract.IntFractPair.mk.noConfusion | Mathlib.Algebra.ContinuedFractions.Computation.Basic | {K : Type u_1} →
{P : Sort u} →
{b : ℤ} →
{fr : K} → {b' : ℤ} → {fr' : K} → { b := b, fr := fr } = { b := b', fr := fr' } → (b = b' → fr ≍ fr' → P) → P | null | false |
Substring.Raw.all | Init.Data.String.Substring | Substring.Raw → (Char → Bool) → Bool | Checks whether the Boolean predicate `p` returns `true` for every character in a substring.
Short-circuits at the first character for which `p` returns `false`.
| true |
CategoryTheory.Enriched.HasConicalLimit.of_iso | Mathlib.CategoryTheory.Enriched.Limits.HasConicalLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] (V : Type u') [inst_1 : CategoryTheory.Category.{v', u'} V]
[inst_2 : CategoryTheory.MonoidalCategory V] {C : Type u} [inst_3 : CategoryTheory.Category.{v, u} C]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] {F G : CategoryTheory.Functor J C}
[C... | If a functor `F` has a conical limit, so does any naturally isomorphic functor. | true |
FirstOrder.Language.Formula.equivSentence_not | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} (φ : L.Formula α),
FirstOrder.Language.Formula.equivSentence φ.not =
FirstOrder.Language.Formula.not (FirstOrder.Language.Formula.equivSentence φ) | null | true |
CompHausLike.concreteCategory._proof_5 | Mathlib.Topology.Category.CompHausLike.Basic | ∀ (P : TopCat → Prop),
autoParam
(∀ {X Y : CompHausLike P} (f : C(↑X.toTop, ↑Y.toTop)),
CompHausLike.concreteCategory._aux_1 P (CompHausLike.concreteCategory._aux_3 P f) = f)
CategoryTheory.ConcreteCategory.hom_ofHom._autoParam | null | false |
CategoryTheory.equivYoneda | Mathlib.CategoryTheory.Sites.Types | (S : CategoryTheory.Functor Type uᵒᵖ (Type u)) →
CategoryTheory.Presheaf.IsSheaf CategoryTheory.typesGrothendieckTopology S →
(S ≅ CategoryTheory.yoneda.obj (S.obj (Opposite.op PUnit.{u + 1}))) | Given a sheaf `S`, construct an isomorphism `S ≅ [-, S(*)]`. | true |
BitVec.concat_or_concat | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w) (a b : Bool), x.concat a ||| y.concat b = (x ||| y).concat (a || b) | null | true |
_private.Batteries.Data.Array.Basic.0.Array.scanlM_loop_eq_scanlMFast_loop._simp_1_5 | Batteries.Data.Array.Basic | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | null | false |
PiLp.sub_apply | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {p : ENNReal} {ι : Type u_2} (β : ι → Type u_4) [inst : (i : ι) → SeminormedAddCommGroup (β i)] (x y : PiLp p β)
(i : ι), (x - y).ofLp i = x.ofLp i - y.ofLp i | null | true |
SSet.horn.edge | Mathlib.AlgebraicTopology.SimplicialSet.Horn | (n : ℕ) → (i a b : Fin (n + 1)) → a ≤ b → {i, a, b}.card ≤ n → (SSet.horn n i).toSSet.obj (Opposite.op { len := 1 }) | The edge of `Λ[n, i]` with endpoints `a` and `b`.
This edge only exists if `{i, a, b}` has cardinality less than `n`. | true |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.ConnectionState.mk.sizeOf_spec | Std.Http.Server.Connection | ∀ {β : Type} [inst : SizeOf β] (machine : Std.Http.Protocol.H1.Machine Std.Http.Protocol.H1.Direction.receiving)
(requestStream : Std.Http.Body.Stream) (keepAliveTimeout : Option Std.Time.Millisecond.Offset)
(currentTimeout : Std.Time.Millisecond.Offset) (headerTimeout : Option Std.Time.Timestamp)
(response : Std... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.