name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.IsIsotypic.submodule_linearEquiv_fun.match_1_1 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m : Submodule R M}
(motive : (∃ n, ∃ (_ : NeZero n), ∃ S, IsSimpleModule R ↥S ∧ Nonempty (↥m ≃ₗ[R] Fin n → ↥S)) → Prop)
(x : ∃ n, ∃ (_ : NeZero n), ∃ S, IsSimpleModule R ↥S ∧ Nonempty (↥m ≃ₗ[R] Fin n → ↥S)),
(∀ (n : ℕ... | null | false |
TruncatedWittVector.zmodEquivTrunc | Mathlib.RingTheory.WittVector.Compare | (p : ℕ) → [hp : Fact (Nat.Prime p)] → (n : ℕ) → ZMod (p ^ n) ≃+* TruncatedWittVector p n (ZMod p) | The unique isomorphism between `ZMod p^n` and `TruncatedWittVector p n (ZMod p)`.
This isomorphism exists, because `TruncatedWittVector p n (ZMod p)` is a finite ring
with characteristic and cardinality `p^n`.
| true |
Int.Linear.Poly.num.injEq | Init.Data.Int.Linear | ∀ (k k_1 : ℤ), (Int.Linear.Poly.num k = Int.Linear.Poly.num k_1) = (k = k_1) | null | true |
AddGrpCat.addGroupObj._proof_10 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddGrpCat) (j : J),
autoParam (∀ (x : (F.comp (CategoryTheory.forget AddGrpCat)).obj j), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
Polynomial.nthRootsFinset.congr_simp | Mathlib.Algebra.Polynomial.Roots | ∀ (n n_1 : ℕ),
n = n_1 →
∀ {R : Type u_1} (a a_1 : R),
a = a_1 →
∀ [inst : CommRing R] [inst_1 : IsDomain R], Polynomial.nthRootsFinset n a = Polynomial.nthRootsFinset n_1 a_1 | null | true |
CategoryTheory.Functor.OplaxRightLinear.δᵣ_unitality_hom | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | ∀ {D : Type u_1} {D' : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} D]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D'] (F : CategoryTheory.Functor D D') {C : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] [inst_3 : CategoryTheory.MonoidalCategory C]
[inst_4 : CategoryTheory.MonoidalCategory.Mo... | null | true |
Lean.Grind.CommRing.Expr.pow.noConfusion | Init.Grind.Ring.CommSolver | {P : Sort u} →
{a : Lean.Grind.CommRing.Expr} →
{k : ℕ} → {a' : Lean.Grind.CommRing.Expr} → {k' : ℕ} → a.pow k = a'.pow k' → (a = a' → k = k' → P) → P | null | false |
Finpartition.bind._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a),
P.parts.attach.sup Subtype.val = a | null | false |
SubAddAction.fixingAddSubgroupInsertEquiv._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_2} {α : Type u_1} [inst : AddGroup M] [inst_1 : AddAction M α] (a : α)
(s : Set ↥(SubAddAction.ofStabilizer M a)) (m : ↥(fixingAddSubgroup M (insert a (Subtype.val '' s)))), ↑m +ᵥ a = a | null | false |
CategoryTheory.IsRegularEpi.of_epi_of_exists | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X B : C} {f : X ⟶ B}
[inst_1 : CategoryTheory.Limits.HasPullback f f] [CategoryTheory.Epi f],
(∀ ⦃Z : C⦄ ⦃g : X ⟶ Z⦄,
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst f f) g =
CategoryTheory.CategoryStruct.comp (Categ... | null | true |
CategoryTheory.Prod.swap_obj | Mathlib.CategoryTheory.Products.Basic | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : C × D), (CategoryTheory.Prod.swap C D).obj X = (X.2, X.1) | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_div_toNat_lt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {y : BitVec w}, y.toNat = 0 → ¬0 < 2 ^ w → False | null | false |
CategoryTheory.Limits.IsLimit.mk.injEq | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F}
(lift : (s : CategoryTheory.Limits.Cone F) → s.pt ⟶ t.pt)
(fac :
autoParam
(∀ (s : CategoryTheory.Limits.Cone F) (j ... | null | true |
SSet.Subcomplex.Pairing.instFiniteSubtypeElemNIIAncestralRel | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RankNat | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) (y : ↑P.II), Finite { x // P.AncestralRel x y } | null | true |
Multiset.toDFinsupp_replicate | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (n : ℕ), Multiset.toDFinsupp (Multiset.replicate n a) = fun₀ | a => n | null | true |
Matrix.trace_blockDiagonal' | Mathlib.LinearAlgebra.Matrix.Trace | ∀ {p : Type u_4} {R : Type u_6} [inst : Fintype p] [inst_1 : AddCommMonoid R] [inst_2 : DecidableEq p]
{m : p → Type u_8} [inst_3 : (i : p) → Fintype (m i)] (M : (i : p) → Matrix (m i) (m i) R),
(Matrix.blockDiagonal' M).trace = ∑ i, (M i).trace | null | true |
Std.Sat.AIG.ShiftTarget.rec | Std.Sat.AIG.Basic | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : aig.ShiftTarget w → Sort u} →
((vec : aig.RefVec w) → (distance : ℕ) → motive { vec := vec, distance := distance }) →
(t : aig.ShiftTarget w) → motive t | null | false |
RingCon.quotientKerEquivRangeₐ._proof_5 | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_2} {R : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring M] [inst_2 : Algebra R M]
[inst_3 : Semiring P] [inst_4 : Algebra R P] (f : M →ₐ[R] P) (x y : (RingCon.ker f.toRingHom).Quotient),
(↑↑((RingCon.kerLiftₐ f).codRestrict f.range ⋯).toRingHom).toFun (x + y) =
(↑↑((RingCon.ker... | null | false |
Lat.ofHom_id | Mathlib.Order.Category.Lat | ∀ {X : Type u} [inst : Lattice X], Lat.ofHom (LatticeHom.id X) = CategoryTheory.CategoryStruct.id (Lat.of X) | null | true |
Lean.Meta.SorryLabelView.casesOn | Lean.Meta.Sorry | {motive : Lean.Meta.SorryLabelView → Sort u} →
(t : Lean.Meta.SorryLabelView) →
((module? : Option Lean.DeclarationLocation) → motive { module? := module? }) → motive t | null | false |
Action.forget_linear | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G]
[inst_2 : CategoryTheory.Preadditive V] {R : Type u_3} [inst_3 : Semiring R] [inst_4 : CategoryTheory.Linear R V],
CategoryTheory.Functor.Linear R (Action.forget V G) | null | true |
Std.Internal.List.containsKey_filter_containsKey_iff | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)}
{hl₁ : Std.Internal.List.DistinctKeys l₁} {k : α},
Std.Internal.List.containsKey k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) = true ↔
Std.Internal.List.containsKey k l₁ = true ∧ Std.Internal.List.... | null | true |
CategoryTheory.Sieve.bind | Mathlib.CategoryTheory.Sites.Sieves | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} →
(S : CategoryTheory.Presieve X) → (⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Sieve Y) → CategoryTheory.Sieve X | Given a presieve on `X`, and a sieve on each domain of an arrow in the presieve, we can bind to
produce a sieve on `X`.
| true |
_private.Mathlib.Data.Finset.Prod.0.Finset.product_eq_biUnion._proof_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq (α × β)] (s : Finset α) (t : Finset β),
s ×ˢ t = s.biUnion fun a => Finset.image (fun b => (a, b)) t | null | false |
MulArchimedeanClass.mk_monotoneOn | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M],
MonotoneOn MulArchimedeanClass.mk (Set.Iic 1) | null | true |
Set.div_subset_div_left | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Div α] {s t₁ t₂ : Set α}, t₁ ⊆ t₂ → s / t₁ ⊆ s / t₂ | null | true |
DirectSum.sigmaUncurry._proof_2 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type u_1} [inst : DecidableEq ι] {α : ι → Type u_3} {δ : (i : ι) → α i → Type u_2}
[inst_1 : (i : ι) → (j : α i) → AddCommMonoid (δ i j)] (f g : Π₀ (i : ι) (j : α i), δ i j),
(f + g).sigmaUncurry = f.sigmaUncurry + g.sigmaUncurry | null | false |
BoxIntegral.Integrable.convergenceR_cond | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {f : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤}
(h : Bo... | null | true |
Submodule.Quotient.seminormedAddCommGroup._proof_19 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] {R : Type u_2} [inst_1 : Ring R] [inst_2 : Module R M]
(S : Submodule R M), Submodule.Quotient.seminormedAddCommGroup._aux_17 S ≤ Filter.cofinite | null | false |
_private.Mathlib.Analysis.CStarAlgebra.GelfandDuality.0.IsStarNormal.norm_add_eq_max._proof_1_5 | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A], ContinuousConstSMul ℂ A | null | false |
Std.Do.ExceptConds.imp_intro | Std.Do.PostCond | ∀ {ps : Std.Do.PostShape} {P Q R : Std.Do.ExceptConds ps}, (P ∧ₑ Q).entails R → P.entails (Q →ₑ R) | null | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.TopologicalSpace.Compacts.instCompleteSpace.match_5 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] (U : SetRel α α) (motive : U ∈ uniformity α ∧ IsClosed U → Prop)
(h : U ∈ uniformity α ∧ IsClosed U), (∀ (hU₁ : U ∈ uniformity α) (hU₂ : IsClosed U), motive ⋯) → motive h | null | false |
Nonneg.coe_add | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] (a b : { x // 0 ≤ x }),
↑(a + b) = ↑a + ↑b | null | true |
UpperHalfPlane.num_scalar | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (u : ℝˣ) (z : UpperHalfPlane), UpperHalfPlane.num ((Matrix.GeneralLinearGroup.scalar (Fin 2)) u) ↑z = ↑↑u * ↑z | null | true |
CategoryTheory.NonemptyParallelPairPresentationAux.isColimit₁._proof_1 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
(f g : A ⟶ B) (P₁ : CategoryTheory.Limits.IndObjectPresentation A)
(P₂ : CategoryTheory.Limits.IndObjectPresentation B),
(CategoryTheory.Comma.fst
((P₁.toCostructuredArrow.comp (CategoryTheory.Costru... | null | false |
Lean.Grind.Linarith.Expr.recOn | Init.Grind.Ordered.Linarith | {motive : Lean.Grind.Linarith.Expr → Sort u} →
(t : Lean.Grind.Linarith.Expr) →
motive Lean.Grind.Linarith.Expr.zero →
((i : Lean.Grind.Linarith.Var) → motive (Lean.Grind.Linarith.Expr.var i)) →
((a b : Lean.Grind.Linarith.Expr) → motive a → motive b → motive (a.add b)) →
((a b : Lean.Grin... | null | false |
Nat.succ_ne_self | Init.Data.Nat.Basic | ∀ (n : ℕ), n.succ ≠ n | null | true |
Group.isFinitelyPresented_iff | Mathlib.GroupTheory.FinitelyPresentedGroup | ∀ (G : Type u_5) [inst : Group G],
Group.IsFinitelyPresented G ↔ ∃ n φ, Function.Surjective ⇑φ ∧ φ.ker.IsFinitelyNormallyGenerated | null | true |
AlgebraicGeometry.Proj.pullbackAwayιIso._proof_4 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | ∀ {m : ℕ}, 0 < m → ∀ {m' : ℕ}, 0 < m + m' | null | false |
NNReal.instConditionallyCompleteLinearOrderBot._proof_10 | Mathlib.Data.NNReal.Defs | ∀ (a : ℝ) (h₁ : 0 ≤ a) (b : ℝ) (h₂ : 0 ≤ b), a = b → ⟨a, h₁⟩ = ⟨b, h₂⟩ | null | false |
Representation.IntertwiningMap.mk.congr_simp | 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 toLinearMap_1 : V →ₗ[A] W)
(e_toLinearMap : toL... | null | true |
LinearAlgebra.FreeProduct.ι'.eq_1 | Mathlib.LinearAlgebra.FreeProduct.Basic | ∀ {I : Type u} [inst : DecidableEq I] (R : Type v) [inst_1 : CommSemiring R] (A : I → Type w)
[inst_2 : (i : I) → Semiring (A i)] [inst_3 : (i : I) → Algebra R (A i)],
LinearAlgebra.FreeProduct.ι' R A = (LinearAlgebra.FreeProduct.mkAlgHom R A).toLinearMap ∘ₗ TensorAlgebra.ι R | null | true |
fst_hnot | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : HNot α] [inst_1 : HNot β] (a : α × β), (￢a).1 = ￢a.1 | null | true |
groupHomology.IsCycle₂.eq_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Mul G] [inst_1 : Inv G] [inst_2 : AddCommGroup A] [inst_3 : SMul G A]
(x : G × G →₀ A),
groupHomology.IsCycle₂ x =
((x.sum fun g a => (fun₀ | g.2 => g.1⁻¹ • a) + fun₀ | g.1 => a) = x.sum fun g a => fun₀ | g.1 * g.2 => a) | null | true |
CategoryTheory.Limits.chosenEnd.π_apply | Mathlib.CategoryTheory.Limits.Types.End | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J]
{F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J (Type (max w u)))} (j : J)
(x : CategoryTheory.Limits.Types.end_ F),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.chosenEnd.π F j)) x = ↑x j | null | true |
Std.Time.Day.instSubOffset._aux_1 | Std.Time.Date.Unit.Day | Std.Time.Day.Offset → Std.Time.Day.Offset → Std.Time.Day.Offset | null | false |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.core0.elim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_11 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof) →
t.ctorIdx = 0 →
((a zero : Lean.Expr) → motive_11 (Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.core0 a zero)) → motive_11 t | null | false |
Polynomial.exists_natDegree_eq_of_mem_lifts | Mathlib.Algebra.Polynomial.Lifts | ∀ {R : Type u} [inst : Semiring R] {S : Type v} [inst_1 : Semiring S] {f : R →+* S} {p : Polynomial S},
p ∈ Polynomial.lifts f → ∃ q, Polynomial.map f q = p ∧ q.natDegree = p.natDegree | null | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.op_smul_eq_iff_mem._simp_1_1 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_1} [inst : Group α] {s : Set α} {x : α} (a : α), (x ∈ MulOpposite.op a • s) = (x * a⁻¹ ∈ s) | null | false |
Std.Internal.List.isEmpty_filter_not_contains_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α},
l₁.isEmpty = true → (List.filter (fun p => !l₂.contains p.fst) l₁).isEmpty = true | null | true |
Std.DTreeMap.Const.size_insertMany_list_le | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{l : List (α × β)}, (Std.DTreeMap.Const.insertMany t l).size ≤ t.size + l.length | null | true |
UniformSpace.nhds_basis_clopens | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} [inst : UniformSpace X] [IsUltraUniformity X] (x : X),
(nhds x).HasBasis (fun s => x ∈ s ∧ IsClopen s) id | null | true |
Action.leftRegularTensorIso._proof_1 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u_1) [inst : Group G] (X : Action (Type u_1) G)
(x : (CategoryTheory.MonoidalCategoryStruct.tensorObj (Action.leftRegular G) X).V),
((fun g => (g.1, (CategoryTheory.ConcreteCategory.hom (X.ρ g.1)) g.2))
((fun g => (g.1, (CategoryTheory.ConcreteCategory.hom (X.ρ g.1⁻¹)) g.2)) x)).2 =
x.2 | null | false |
_private.Batteries.Data.List.Lemmas.0.List.dropInfix?.go.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : Option (List α) → Sort u_2) (h_1 : Unit → motive none)
(h_2 : (s : List α) → motive (some s)),
(match none with
| none => h_1 ()
| some s => h_2 s) =
h_1 () | null | true |
_private.Mathlib.Data.Fin.Tuple.NatAntidiagonal.0.List.Nat.antidiagonalTuple.match_1.splitter | Mathlib.Data.Fin.Tuple.NatAntidiagonal | (motive : ℕ → ℕ → Sort u_1) →
(x x_1 : ℕ) → (Unit → motive 0 0) → ((n : ℕ) → motive 0 n.succ) → ((k n : ℕ) → motive k.succ n) → motive x x_1 | null | true |
PLift.instLawfulApplicative_mathlib | Mathlib.Control.ULift | LawfulApplicative PLift | null | true |
UInt64.lt_iff_toFin_lt | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a < b ↔ a.toFin < b.toFin | null | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_26 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β) (lrs : ℕ)
(lrl lrr : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(lrl.Balanced ∧
lrr.Bala... | null | false |
IsOfFinOrder.fst | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_4} {β : Type u_5} [inst : Monoid α] [inst_1 : Monoid β] {x : α × β}, IsOfFinOrder x → IsOfFinOrder x.1 | null | true |
Matrix.isNilpotent_iff | Mathlib.RingTheory.Finiteness.Nilpotent | ∀ {R : Type u_1} [inst : CommSemiring R] {ι : Type u_3} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι]
{A : Matrix ι ι R}, IsNilpotent A ↔ ∀ (v : ι → R), ∃ n, (A ^ n).mulVec v = 0 | null | true |
Algebra.SubmersivePresentation.free_cotangent | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ),
Module.Free S P.toExtension.Cotangent | [Stacks Tag 00T7](https://stacks.math.columbia.edu/tag/00T7) ((3)) | true |
deriv_pos_left_of_sign_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {x₀ : ℝ},
(∀ᶠ (x : ℝ) in nhdsWithin x₀ {x₀}ᶜ, SignType.sign (deriv f x) = SignType.sign (x₀ - x)) →
∀ᶠ (b : ℝ) in nhdsWithin x₀ (Set.Iio x₀), deriv f b > 0 | null | true |
PowerBasis.equivOfMinpoly | Mathlib.RingTheory.PowerBasis | {S : Type u_2} →
[inst : Ring S] →
{A : Type u_4} →
[inst_1 : CommRing A] →
[inst_2 : Algebra A S] →
{S' : Type u_7} →
[inst_3 : Ring S'] →
[inst_4 : Algebra A S'] →
(pb : PowerBasis A S) → (pb' : PowerBasis A S') → minpoly A pb.gen = minpoly A pb'... | `pb.equivOfMinpoly pb' h` is an equivalence of algebras with the same power basis,
where "the same" means that they have identical minimal polynomials.
See also `PowerBasis.equivOfRoot` which takes the hypothesis that each generator is a root of the
other basis' minimal polynomial; `PowerBasis.equivOfRoot` is more gen... | true |
Module.forall_dual_apply_eq_zero_iff | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {V : Type uV} [inst : AddCommMonoid V] (R : Type u_1) [inst_1 : Semiring R] [inst_2 : Module R V]
[Module.Projective R V] (v : V), (∀ (φ : Module.Dual R V), φ v = 0) ↔ v = 0 | null | true |
UniformSpaceCat.completionFunctor._proof_4 | Mathlib.Topology.Category.UniformSpace | ∀ (X : UniformSpaceCat), T0Space (UniformSpace.Completion X.carrier) | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updatePapImp.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.LetValue pu → Sort u_1) →
(e : Lean.Compiler.LCNF.LetValue pu) →
((declName : Lean.Name) →
(args : Array (Lean.Compiler.LCNF.Arg pu)) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.pap ... | null | false |
ext_nat' | Mathlib.Algebra.Group.Nat.Hom | ∀ {A : Type u_2} {F : Type u_4} [inst : FunLike F ℕ A] [inst_1 : AddZeroClass A] [AddMonoidHomClass F ℕ A] (f g : F),
f 1 = g 1 → f = g | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_eq._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct | Mathlib.CategoryTheory.Monoidal.Action.Basic | (C : Type u_1) →
(D : Type u_2) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Category.{v_2, u_2} D] →
[CategoryTheory.MonoidalCategoryStruct C] → Type (max (max (max u_1 u_2) v_1) v_2) | A class that carries the non-Prop data required to define a left action of a
monoidal category `C` on a category `D`, to set up notations. | true |
HahnEmbedding.ArchimedeanStrata.stratum' | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
... | `ArchimedeanStrata.stratum` as a submodule of
`ArchimedeanStrata.baseDomain`. | true |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.SimpHaveResult.ctorIdx | Lean.Meta.HaveTelescope | Lean.Meta.SimpHaveResult✝ → ℕ | null | false |
HurwitzKernelBounds.F_int | Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds | ℕ → UnitAddCircle → ℝ → ℝ | The sum to be bounded (`ℤ` version). | true |
_private.Mathlib.Analysis.Distribution.SchwartzSpace.Basic.0.SchwartzMap.seminormAux_nonneg.match_1_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (k n : ℕ) (f : SchwartzMap E F) (x : ℝ)
(motive : x ∈ {c | 0 ≤ c ∧ ∀ (x : E), ‖x‖ ^ k * ‖iteratedFDeriv ℝ n (⇑f) x‖ ≤ c} → Prop)
(x_1 : x ∈ {c | 0 ≤ c ∧ ∀ (x : E), ‖x... | null | false |
summable_pow_mul_jacobiTheta₂_term_bound | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (S : ℝ) {T : ℝ}, 0 < T → ∀ (k : ℕ), Summable fun n => ↑|n| ^ k * Real.exp (-Real.pi * (T * ↑n ^ 2 - 2 * S * ↑|n|)) | The uniform bound we have given is summable, and remains so after multiplying by any fixed
power of `|n|` (we shall need this for `k = 0, 1, 2`). | true |
Std.TreeMap.containsThenInsertIfNew_snd | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α} {v : β},
(t.containsThenInsertIfNew k v).2 = t.insertIfNew k v | null | true |
SheafOfModules.Presentation.casesOn | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
{M : SheafOfModule... | null | false |
_private.Lean.DocString.Extension.0.Lean.initFn._@.Lean.DocString.Extension.2096677768._hygCtx._hyg.4 | Lean.DocString.Extension | IO (Lean.Option Bool) | null | false |
SSet.horn.ι_ι_assoc | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ} (i j : Fin (n + 2)) (hij : j ≠ i) {Z : SSet} (h : SSet.stdSimplex.obj { len := n + 1 } ⟶ Z),
CategoryTheory.CategoryStruct.comp (SSet.horn.ι i j hij)
(CategoryTheory.CategoryStruct.comp (SSet.horn (n + 1) i).ι h) =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) h | null | true |
Lean.Meta.ACLt.ReduceMode.none.elim | Lean.Meta.ACLt | {motive : Lean.Meta.ACLt.ReduceMode → Sort u} →
(t : Lean.Meta.ACLt.ReduceMode) → t.ctorIdx = 2 → motive Lean.Meta.ACLt.ReduceMode.none → motive t | null | false |
HomologicalComplex.dTo_eq | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.dTo j = CategoryTheory.CategoryStruct.comp (C.xPrevIso r).hom (C.d i j) | null | true |
groupCohomology.H0_induction_on | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) {C : ↑(groupCohomology.H0 A) → Prop}
(x : ↑(groupCohomology.H0 A)),
(∀ (x : ↥A.ρ.invariants), C ((CategoryTheory.ConcreteCategory.hom (groupCohomology.H0Iso A).inv) x)) → C x | null | true |
instNontrivialSubtypeMemSubmoduleValSetIsotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(c : ↑(isotypicComponents R M)), Nontrivial ↥↑c | null | true |
Aesop.RuleTerm.const | Aesop.RuleTac.RuleTerm | Lean.Name → Aesop.RuleTerm | null | true |
DirichletCharacter.LFunctionTrivChar_isBigO_near_one_horizontal | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {N : ℕ} [inst : NeZero N],
(fun x => DirichletCharacter.LFunctionTrivChar N (1 + ↑x)) =O[nhdsWithin 0 (Set.Ioi 0)] fun x => 1 / ↑x | null | true |
ModelWithCorners.convex_range | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)
[inst_4 : NormedSpace ℝ E], Convex ℝ (Set.range ↑I) | null | true |
MulAction.aestabilizer.congr_simp | Mathlib.MeasureTheory.Group.AEStabilizer | ∀ (G : Type u_1) {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {x : MeasurableSpace α}
(μ μ_1 : MeasureTheory.Measure α) (e_μ : μ = μ_1) [inst_2 : MeasureTheory.SMulInvariantMeasure G α μ] (s s_1 : Set α),
s = s_1 → MulAction.aestabilizer G μ s = MulAction.aestabilizer G μ_1 s_1 | null | true |
Equiv.Perm.SameCycle.symm_apply_right | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α}, f.SameCycle x y → f.SameCycle x ((Equiv.symm f) y) | **Alias** of the reverse direction of `Equiv.Perm.sameCycle_symm_apply_right`. | true |
MulEquiv.withOneCongr.eq_1 | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Mul α] [inst_1 : Mul β] (e : α ≃* β),
e.withOneCongr =
{ toFun := ⇑(WithOne.mapMulHom e.toMulHom), invFun := ⇑(WithOne.mapMulHom e.symm.toMulHom), left_inv := ⋯,
right_inv := ⋯, map_mul' := ⋯ } | null | true |
CategoryTheory.Functor.fromLeftDerivedZero._proof_1 | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.HasProjectiveResolutions C] [inst_4 : CategoryTheory.Abelian D]
(F : CategoryTheory.Functor C D) [inst_5 : F.Additive] {X Y : C... | null | false |
finFunctionFinEquiv._proof_4 | Mathlib.Algebra.BigOperators.Fin | ∀ {m n : ℕ}, Fintype.card (Fin n → Fin m) ≤ Fintype.card (Fin (m ^ n)) | null | false |
Matrix.frobenius_norm_transpose | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (A : Matrix m n α), ‖A.transpose‖ = ‖A‖ | null | true |
LieAlgebra.IsKilling.exists_isSl2Triple_of_weight_isNonZero | Mathlib.Algebra.Lie.Weights.Killing | ∀ {K : Type u_2} {L : Type u_3} [inst : LieRing L] [inst_1 : Field K] [inst_2 : LieAlgebra K L] [FiniteDimensional K L]
{H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] [LieAlgebra.IsKilling K L]
[LieModule.IsTriangularizable K (↥H) L] [CharZero K] {α : LieModule.Weight K (↥H) L},
α.IsNonZero → ∃ h e f, Is... | null | true |
Set.infs_singleton | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] {s : Set α} {b : α}, s ⊼ {b} = (fun a => a ⊓ b) '' s | null | true |
AlgCat.sectionsSubalgebra | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u} →
[inst : CommRing R] →
{J : Type v} →
[inst_1 : CategoryTheory.Category.{t, v} J] →
(F : CategoryTheory.Functor J (AlgCat R)) → Subalgebra R ((j : J) → ↑(F.obj j)) | The flat sections of a functor into `AlgCat R` form a submodule of all sections.
| true |
_private.Mathlib.Order.CompleteLattice.Basic.0.iInf_and.match_1_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {p q : Prop} (motive : p ∧ q → Prop) (x : p ∧ q), (∀ (i : p) (h : q), motive ⋯) → motive x | null | false |
AddMonoid.Coprod.inr._proof_1 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
AddMonoid.Coprod.mk (FreeAddMonoid.of (Sum.inr 0)) = AddMonoid.Coprod.mk 0 | null | false |
MonoidHom.coe_toMultiplicative_range | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {A : Type u_7} {A' : Type u_8} [inst : AddGroup A] [inst_1 : AddGroup A'] (f : A →+ A'),
(AddMonoidHom.toMultiplicative f).range = AddSubgroup.toSubgroup f.range | null | true |
Representation.IntertwiningMap.lTensor_apply | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A... | null | true |
_private.Init.Data.Dyadic.Basic.0.Dyadic.add.match_3.eq_3 | Init.Data.Dyadic.Basic | ∀ (motive : Dyadic → Dyadic → Sort u_1) (n₁ k₁ : ℤ) (hn₁ : n₁ % 2 = 1) (n₂ k₂ : ℤ) (hn₂ : n₂ % 2 = 1)
(h_1 : (y : Dyadic) → motive Dyadic.zero y) (h_2 : (x : Dyadic) → motive x Dyadic.zero)
(h_3 :
(n₁ k₁ : ℤ) →
(hn₁ : n₁ % 2 = 1) → (n₂ k₂ : ℤ) → (hn₂ : n₂ % 2 = 1) → motive (Dyadic.ofOdd n₁ k₁ hn₁) (Dyadic... | null | true |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.completedLFunction_one_sub_even._simp_1_3 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.