name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
WeierstrassCurve.a₁_of_isCharNeTwoNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [W.IsCharNeTwoNF], W.a₁ = 0 | null | true |
pow_succ_nonneg._f | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [PosMulMono M₀],
0 ≤ a → ∀ (x : ℕ) (f : Nat.below x), 0 ≤ a ^ (x + 1) | null | false |
CategoryTheory.IsReflexivePair.mk | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B},
(∃ s,
CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B ∧
CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B) →
CategoryTheory.IsReflexivePair f g | null | true |
WType.rec | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{motive : WType β → Sort u} →
((a : α) → (f : β a → WType β) → ((a : β a) → motive (f a)) → motive (WType.mk a f)) → (t : WType β) → motive t | null | false |
_private.Init.Data.Array.InsertIdx.0.Array.getElem?_insertIdx_self._proof_1_1 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {xs : Array α} {i : ℕ}, i < i → False | null | false |
MeasureTheory.IsSeparable | Mathlib.MeasureTheory.Measure.SeparableMeasure | {X : Type u_1} → [m : MeasurableSpace X] → MeasureTheory.Measure X → Prop | A measure `μ` is separable if there exists a countable and measure-dense family of sets.
The term "separable" is justified by the fact that the definition translates to the usual notion
of separability in the metric space made by constant indicators equipped with the `Lᵖ` norm. | true |
ContinuousMul.casesOn | Mathlib.Topology.Algebra.Monoid.Defs | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : Mul M] →
{motive : ContinuousMul M → Sort u} →
(t : ContinuousMul M) → ((continuous_mul : Continuous fun p => p.1 * p.2) → motive ⋯) → motive t | null | false |
CategoryTheory.Limits.isLimitConeOfHasLimitCurryCompLim._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_6} {K : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(G : CategoryTheory.Functor (J × K) C) [CategoryTheory.Limits.HasLimitsOfShape K C] (j : J),
CategoryTheory.Limits.HasLimit (... | null | false |
MvPolynomial.weightedDecomposition | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | (R : Type u_1) →
{M : Type u_2} →
[inst : CommSemiring R] →
{σ : Type u_3} →
(w : σ → M) →
[inst_1 : AddCommMonoid M] →
[inst_2 : DecidableEq M] → DirectSum.Decomposition (MvPolynomial.weightedHomogeneousSubmodule R w) | Given a weight `w`, the decomposition of `MvPolynomial σ R` into weighted homogeneous
submodules | true |
WeierstrassCurve.Projective.addXYZ | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → Fin 3 → R | The coordinates of a representative of `P + Q` for two distinct projective point representatives
`P` and `Q` on a Weierstrass curve.
If the representatives of `P` and `Q` are equal, then this returns the value `![0, 0, 0]`. | true |
ContinuousMultilinearMap.continuousMapClass | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂],
ContinuousMapClass (Conti... | null | true |
one_lt_leOnePart._simp_2 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a : α} [MulLeftMono α], a < 1 → (1 < a⁻ᵐ) = True | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.meta.formatter_21 | Lean.Parser.Command | IO Unit | null | false |
Affine.Simplex.incenter_notMem_affineSpan_faceOpposite | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.incenter ∉ affineSpan ℝ (Set.range (s.faceOpposite i).points) | null | true |
_private.Lean.Elab.Util.0.Lean.Elab.nestedExceptionToMessageData.match_1 | Lean.Elab.Util | (motive : Option String.Pos.Raw → Sort u_1) →
(x : Option String.Pos.Raw) → (Unit → motive none) → ((exPos : String.Pos.Raw) → motive (some exPos)) → motive x | null | false |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_comp_assoc | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'}
(φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {X'' Y'' : C} {h : X'' ⟶ Y''}
(ψ : CategoryTheory.Arrow.mk g ⟶... | null | true |
AddMonoid.End.coe_one | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M], ⇑1 = id | null | true |
String.Slice.Pos.startInclusive_le_str | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, s.startInclusive ≤ pos.str | null | true |
CategoryTheory.IsExponentiable | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.ChosenPullbacks C] → CategoryTheory.MorphismProperty C | A morphism `f : I ⟶ J` is exponentiable if the pullback functor `Over J ⥤ Over I`
has a right adjoint. | true |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.sub_scalar_sq_eq_discr._simp_1_6 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
AddCommMonoid.zmodModule._proof_1 | Mathlib.Algebra.Module.ZMod | ∀ {n : ℕ} {M : Type u_1} [inst : AddCommMonoid M],
(∀ (x : M), n • x = 0) → ∀ (c : ℕ) (x : M), (c % n + c / n * n) • x = c • x → (c % n) • x = c • x | null | false |
Vector.getElem?_extract | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {as : Vector α n} {start stop : ℕ},
(as.extract start stop)[i]? = if i < min stop n - start then as[start + i]? else none | null | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.card_fixedPoints_modEq._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
_private.Batteries.Data.AssocList.0.cond.match_1.eq_2 | Batteries.Data.AssocList | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | null | true |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.uncurry_ofArrows._simp_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | null | false |
SummableUniformlyOn.exists | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α], SummableUniformlyOn f s → ∃ g, HasSumUniformlyOn f g s | null | true |
_private.Init.Grind.ToInt.0.Lean.Grind.instBEqIntInterval.beq.eq_4 | Init.Grind.ToInt | Lean.Grind.instBEqIntInterval.beq Lean.Grind.IntInterval.ii Lean.Grind.IntInterval.ii = true | null | true |
Filter.limsSup | Mathlib.Order.LiminfLimsup | {α : Type u_1} → [ConditionallyCompleteLattice α] → Filter α → α | The `limsSup` of a filter `f` is the infimum of the `a` such that the inequality
`x ≤ a` eventually holds for `f`. | true |
CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasCoproduct I.left]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) {Z : C} (h : ∐ I.right ⟶ Z),
CategoryTheory.Catego... | null | true |
Equiv.prodShear._proof_2 | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : Type u_1} {β₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : α₁ → β₁ ≃ β₂),
Function.LeftInverse (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) fun x => (e₁ x.1, (e₂ x.1) x.2) | null | false |
CategoryTheory.braiding_rightUnitor_aux₂ | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(β_ (... | null | true |
Std.Internal.USquash.rec | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
[small : Std.Internal.Small α] →
{motive : Std.Internal.USquash α → Sort u_1} →
((inner : Std.Internal.ComputableSmall.Target α) → motive { inner := inner }) →
(t : Std.Internal.USquash α) → motive t | null | false |
Std.Internal.Do.WPMonad.liftWith_StateT_wp | Std.Internal.Do.WP.Lemmas | ∀ {Pred : Type u_1} {EPred : Type u_2} {m : Type u → Type v} [inst : Monad m] [inst_1 : Std.Internal.Do.Assertion Pred]
[inst_2 : Std.Internal.Do.Assertion EPred] [inst_3 : Std.Internal.Do.WPMonad m Pred EPred] {σ α : Type u}
{post : α → σ → Pred} {epost : EPred} {s : σ} (f : ({β : Type u} → StateT σ m β → m (β × σ... | null | true |
RCLike.continuous_ofReal | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous RCLike.ofReal | null | true |
_private.Mathlib.Order.Filter.Lift.0.Filter.lift'_neBot_iff._simp_1_1 | Mathlib.Order.Filter.Lift | ∀ {α : Type u} {s : Set α}, (Filter.principal s).NeBot = s.Nonempty | null | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.Internal.toList_eq_toList_iter | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.IsAlwaysFinite α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α] {r : Std.Rco α},
r.toList = (Std.Rco.Internal.iter r).toList | null | true |
CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP_comp_pullback_snd | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₀X₂ToP (CategoryTheory.Limits.pullback.snd S.L₁.g S.v₀₁.τ₃) = S.L₀.g | null | true |
coe_toIdeal | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι] [inst_5 : GradedRing 𝒜]
(I : HomogeneousIdeal 𝒜), ↑I.toIdeal = ↑I | null | true |
AddEquiv.opOp | Mathlib.Algebra.Group.Equiv.Opposite | (M : Type u_3) → [inst : Add M] → M ≃+ Mᵃᵒᵖᵃᵒᵖ | An additive monoid is isomorphic to the opposite of its opposite. | true |
Aesop.Script.TacticState.getVisibleGoalIndex? | Aesop.Script.TacticState | Aesop.Script.TacticState → Lean.MVarId → Option ℕ | null | true |
Finset.Nontrivial.instDecidablePred._proof_3 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (h : Multiset.Nodup ⟦[]⟧), ¬{ val := ⟦[]⟧, nodup := h }.Nontrivial | null | false |
CategoryTheory.Cokleisli.Hom._sizeOf_inst | Mathlib.CategoryTheory.Monad.Kleisli | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{U : CategoryTheory.Comonad C} → (c c' : CategoryTheory.Cokleisli U) → [SizeOf C] → SizeOf (c.Hom c') | null | false |
_private.Mathlib.Topology.UniformSpace.Equicontinuity.0.Filter.HasBasis.uniformEquicontinuous_iff._simp_1_1 | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
_private.Init.Data.Array.Find.0.Array.idxOf.eq_1 | Init.Data.Array.Find | ∀ {α : Type u} [inst : BEq α] (a : α), Array.idxOf a = Array.findIdx fun x => x == a | null | true |
rootsOfUnityEquivNthRoots._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (R : Type u_1) (k : ℕ) [inst : NeZero k] [inst_1 : CommRing R] [inst_2 : IsDomain R]
(x : { x // x ∈ Polynomial.nthRoots k 1 }),
{ val := ↑x, inv := ↑x ^ (k - 1), val_inv := ⋯, inv_val := ⋯ } ∈ rootsOfUnity k R | null | false |
Action.diagonalSuccIsoTensorTrivial._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u_1) [inst : Group G] (n : ℕ) (x : G),
CategoryTheory.CategoryStruct.comp
((Action.trivial G
(CategoryTheory.MonoidalCategoryStruct.tensorObj (Action.leftRegular G) (Action.trivial G (Fin n → G))).V).ρ
x)
(Fin.insertNthEquiv (fun x => G) 0).toIso.hom =
CategoryTheory.Ca... | null | false |
Matrix.toBilin' | Mathlib.LinearAlgebra.Matrix.BilinearForm | {R₁ : Type u_1} →
[inst : CommSemiring R₁] →
{n : Type u_5} → [Fintype n] → [DecidableEq n] → Matrix n n R₁ ≃ₗ[R₁] LinearMap.BilinForm R₁ (n → R₁) | The linear equivalence between `n × n` matrices and bilinear forms on `n → R` | true |
PowerSeries.coeff_expand_mul | Mathlib.RingTheory.PowerSeries.Expand | ∀ {R : Type u_2} [inst : CommRing R] (p : ℕ) (hp : p ≠ 0) (φ : PowerSeries R) (m : ℕ),
(PowerSeries.coeff (p * m)) ((PowerSeries.expand p hp) φ) = (PowerSeries.coeff m) φ | null | true |
Std.DTreeMap.size_add_size_eq_size_union_add_size_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t₁.size + t₂.size = (t₁ ∪ t₂).size + (t₁ ∩ t₂).size | null | true |
Lean.Meta.TransparencyMode._sizeOf_1 | Init.MetaTypes | Lean.Meta.TransparencyMode → ℕ | null | false |
instAddCommGroupUniformOnFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : AddCommGroup β],
instAddCommGroupUniformOnFun = { toAddGroup := instAddGroupUniformOnFun, add_comm := ⋯ } | null | true |
Order.Ioo_succ_right_eq_insert | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α} [NoMaxOrder α],
a < b → Set.Ioo a (Order.succ b) = insert b (Set.Ioo a b) | null | true |
HomologicalComplex.dgoToHomologicalComplex._proof_4 | Mathlib.Algebra.Homology.DifferentialObject | ∀ {β : Type u_3} [inst : AddCommGroup β] (b : β) (V : Type u_2) [inst_1 : CategoryTheory.Category.{u_1, u_2} V]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V]
{X Y : CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V)} (f : X ⟶ Y) (i j : β),
(ComplexShape.up' b).Rel i j →
Categ... | null | false |
SupBotHom.instSemilatticeSup | Mathlib.Order.Hom.BoundedLattice | {α : Type u_2} →
{β : Type u_3} →
[inst : Max α] →
[inst_1 : Bot α] → [inst_2 : SemilatticeSup β] → [inst_3 : OrderBot β] → SemilatticeSup (SupBotHom α β) | null | true |
Lex.instZero | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [Zero α] → Zero (Lex α) | null | true |
IsRealClosed.mk._flat_ctor | Mathlib.FieldTheory.IsRealClosed.Basic | ∀ {R : Type u_1} [inst : Field R],
(∀ {s : R}, IsSumSq s → 1 + s ≠ 0) →
(∀ (x : R), IsSquare x ∨ IsSquare (-x)) → (∀ {f : Polynomial R}, Odd f.natDegree → ∃ x, f.IsRoot x) → IsRealClosed R | null | false |
CategoryTheory.WithTerminal.inclLift._proof_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z)
(hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) ⦃X Y : C⦄ (f : X ⟶ Y),
Categor... | null | false |
_private.Mathlib.RingTheory.AdicCompletion.Noetherian.0.IsHausdorff.of_le_jacobson._simp_1_1 | Mathlib.RingTheory.AdicCompletion.Noetherian | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x : M}, (x ≡ 0 [SMOD U]) = (x ∈ U) | null | false |
OrderIso.limsup_apply | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_6} [inst : ConditionallyCompleteLattice β]
[inst_1 : ConditionallyCompleteLattice γ] {f : Filter α} {u : α → β} (g : β ≃o γ),
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) OrderIso.limsup_apply._auto_1 →
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => ... | null | true |
HasCompactSupport.enorm_le_lintegral_Ici_deriv | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {F : Type u_2} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {f : ℝ → F},
ContDiff ℝ 1 f → HasCompactSupport f → ∀ (x : ℝ), ‖f x‖ₑ ≤ ∫⁻ (y : ℝ) in Set.Iic x, ‖deriv f y‖ₑ | null | true |
starRingAut._proof_3 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] (x y : R),
starMulAut.toFun (x * y) = starMulAut.toFun x * starMulAut.toFun y | null | false |
Stream'.WSeq.findIndexes.match_1 | Mathlib.Data.WSeq.Defs | {α : Type u_1} → (motive : α × ℕ → Sort u_2) → (x : α × ℕ) → ((a : α) → (n : ℕ) → motive (a, n)) → motive x | null | false |
HomologicalComplex.prepathObject._proof_5 | Mathlib.Algebra.Homology.Precylinder | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_1}
{c : ComplexShape ι} [inst_2 : DecidableRel c.Rel] (K : HomologicalComplex C c)
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)] [inst_4 : K.HasPathObject],
CategoryT... | null | false |
Int.natAbs_natCast_sub_natCast_of_ge | Mathlib.Data.Int.NatAbs | ∀ {a b : ℕ}, b ≤ a → (↑a - ↑b).natAbs = a - b | null | true |
RightAddCosetEquivalence | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [Add α] → Set α → α → α → Prop | Equality of two right cosets `s + a` and `s + b`. | true |
LinearMap.lcompₛₗ.eq_1 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_14} {R₂ : Type u_15} {R₃ : Type u_16} (R₅ : Type u_18) {M : Type u_19} {N : Type u_20} (P : Type u_21)
[inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : Semiring R₅] {σ₁₂ : R →+* R₂}
(σ₂₃ : R₂ →+* R₃) {σ₁₃ : R →+* R₃} [inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid N] [ins... | null | true |
CategoryTheory.Adjunction.Quadruple.epi_leftTriple_rightToLeft_iff_mono_rightTriple_leftToRight | Mathlib.CategoryTheory.Adjunction.Quadruple | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor D C} {G : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor D C} (q : CategoryTheory.Adjunction.Quadruple L F G R) [inst_2 : F.Fu... | For an adjoint quadruple `L ⊣ F ⊣ G ⊣ R` where `F` (and hence also `R`) is fully faithful and
its domain / codomain has all pushouts resp. pullbacks, the natural transformation `G ⟶ L` is an
epimorphism iff the natural transformation `F ⟶ R` is a monomorphism. | true |
CategoryTheory.Limits.WalkingMulticospan.instSmallCategory._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {W X Y Z : CategoryTheory.Limits.WalkingMulticospan J} (f : W.Hom X)
(g : X.Hom Y) (h : Y.Hom Z), (f.comp g).comp h = f.comp (g.comp h) | null | false |
HomologicalComplex.natTransHomologyπ_app | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} (c : ComplexShape ι) (i : ι) [inst_2 : CategoryTheory.CategoryWithHomology C]
(K : HomologicalComplex C c), (HomologicalComplex.natTransHomologyπ C c i).app K = K.homologyπ i | null | true |
PSigma.Lex.le | Mathlib.Data.PSigma.Order | {ι : Type u_1} → {α : ι → Type u_2} → [LT ι] → [(i : ι) → LE (α i)] → LE (Σₗ' (i : ι), α i) | The lexicographical `≤` on a sigma type. | true |
Subsemiring.topologicalClosure._proof_5 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [inst_2 : IsSemitopologicalSemiring R]
(s : Subsemiring R) {a b : R},
a ∈ s.toAddSubmonoid.topologicalClosure.carrier →
b ∈ s.toAddSubmonoid.topologicalClosure.carrier → a + b ∈ s.toAddSubmonoid.topologicalClosure.carrier | null | false |
Mathlib.Linter.Style.lambdaSyntax.findLambdaSyntax | Mathlib.Tactic.Linter.Style | Lean.Syntax → Array Lean.Syntax | `findLambdaSyntax stx` extracts from `stx` all syntax nodes of `kind` `Term.fun`. | true |
CategoryTheory.endofunctorMonoidalCategory_associator_hom_app | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (F G H : CategoryTheory.Functor C C) (X : C),
(CategoryTheory.MonoidalCategoryStruct.associator F G H).hom.app X =
CategoryTheory.CategoryStruct.id
((CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj F G)... | null | true |
zero_zpow | Mathlib.Algebra.GroupWithZero.Basic | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] (n : ℤ), n ≠ 0 → 0 ^ n = 0 | null | true |
ContinuousWithinAt.vsub | Mathlib.Topology.Algebra.Group.Torsor | ∀ {V : Type u_1} {P : Type u_2} {α : Type u_3} [inst : AddGroup V] [inst_1 : TopologicalSpace V]
[inst_2 : AddTorsor V P] [inst_3 : TopologicalSpace P] [IsTopologicalAddTorsor P] [inst_5 : TopologicalSpace α]
{f g : α → P} {x : α} {s : Set α},
ContinuousWithinAt f s x → ContinuousWithinAt g s x → ContinuousWithin... | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt._simp_1_8 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
IsLocalization.mk'_self | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x : R} (hx : x ∈ M), IsLocalization.mk' S x ⟨x, hx⟩ = 1 | null | true |
CategoryTheory.GlueData.f_hasPullback | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v, u₁} C] (self : CategoryTheory.GlueData C) (i j k : self.J),
CategoryTheory.Limits.HasPullback (self.f i j) (self.f i k) | null | true |
Submodule.isIdempotentElem_projection._simp_1 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q), IsIdempotentElem (p.projection q hpq) = True | null | false |
lowerCentralSeries_length_eq_nilpotencyClass | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [hG : Group.IsNilpotent G], Nat.find ⋯ = Group.nilpotencyClass G | **Alias** of `Subgroup.lowerCentralSeries_length_eq_nilpotencyClass`.
---
The nilpotency class of a nilpotent `G` is equal to the length of the lower central series. | true |
Bool.not_bijective | Mathlib.Logic.Equiv.Bool | Function.Bijective not | null | true |
ContinuousLinearMap.rangeRestrict._proof_1 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Restrict | ∀ {R₁ : Type u_3} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
{M₂ : Type u_1} [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] [inst_4 : Module R₁ M₁]
[inst_5 : TopologicalSpace M₂] [inst_6 : AddCommMonoid M₂] [inst_7 : Module R₂ M₂] [inst_8 : RingHomSurje... | null | false |
_private.Mathlib.Topology.MetricSpace.Ultra.Basic.0.IsUltrametricDist.isOpen_closedBall._simp_1_2 | Mathlib.Topology.MetricSpace.Ultra.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, (Metric.ball x ε ⊆ Metric.closedBall x ε) = True | null | false |
IsRegularLocalRing.spanFinrank_maximalIdeal | Mathlib.RingTheory.RegularLocalRing.Defs | ∀ {R : Type u_1} {inst : CommRing R} [self : IsRegularLocalRing R],
↑(Submodule.spanFinrank (IsLocalRing.maximalIdeal R)) = ringKrullDim R | null | true |
CategoryTheory.Limits.instDecidableEqWalkingParallelFamily._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1}, CategoryTheory.Limits.WalkingParallelFamily.zero = CategoryTheory.Limits.WalkingParallelFamily.zero | null | false |
not_lt_of_ge | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → ¬b < a | null | true |
groupCohomology.cochainsMap_id_f_map_mono | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B : Rep.{u, u, u} k G} (φ : A ⟶ B) [CategoryTheory.Mono φ]
(i : ℕ), CategoryTheory.Mono ((groupCohomology.cochainsMap (MonoidHom.id G) φ).f i) | null | true |
CochainComplex.isoHomologyπ₀._proof_1 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : CochainComplex C ℕ), K.d ((ComplexShape.up ℕ).prev 0) 0 = 0 | null | false |
Std.Ric.Sliceable.mkSlice | Init.Data.Slice.Notation | {α : Type u} → {β : outParam (Type v)} → {γ : outParam (Type w)} → [self : Std.Ric.Sliceable α β γ] → α → Std.Ric β → γ | Slices `carrier` up to `range.upper` \(inclusive\).
| true |
Std.LawfulOrderLeftLeaningMax | Init.Data.Order.Classes | (α : Type u) → [Max α] → [LE α] → Prop | This typeclass states that `max a b = if b ≤ a then a else b` (for any `DecidableLE α` instance).
| true |
_private.Mathlib.Topology.DiscreteSubset.0.isDiscrete_of_codiscreteWithin._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, (f ⊓ Filter.principal sᶜ = ⊥) = (s ∈ f) | null | false |
Mathlib.Tactic._aux_Mathlib_Tactic_Cases___elabRules_Mathlib_Tactic_induction'_1 | Mathlib.Tactic.Cases | Lean.Elab.Tactic.Tactic | `induction' x` applies induction on the variable `x` of the inductive type `t` to the main goal,
producing one goal for each constructor of `t`, in which `x` is replaced by that constructor
applied to newly introduced variables. `induction'` adds an inductive hypothesis for
each recursive argument to the constructor. T... | false |
CategoryTheory.ComposableArrows.Precomp.map_zero_one' | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C}
(f : X ⟶ F.left), CategoryTheory.ComposableArrows.Precomp.map F f 0 ⟨0 + 1, ⋯⟩ ⋯ = f | null | true |
map_prod | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : CommMonoid M] [inst_1 : CommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [MonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
g (∏ x ∈ s, f x) = ∏ x ∈ s, g (f x) | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_extractLsb._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w hi lo i : ℕ},
i < hi - lo + 1 →
lo + (hi - lo + 1 - 1 - i) < w →
w - 1 - (lo + (hi - lo + 1 - 1 - i)) = w - 1 - (max hi lo - i) → ¬(i < hi - lo + 1 ∧ max hi lo - i < w) → False | null | false |
NonUnitalSeminormedCommRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
[toNonUnitalSeminormedRing : NonUnitalSeminormedRing α] → (∀ (a b : α), a * b = b * a) → NonUnitalSeminormedCommRing α | null | true |
Std.Http.Header.ContentLength.length | Std.Http.Data.Headers.Basic | Std.Http.Header.ContentLength → ℕ | The content length in bytes.
| true |
_private.Mathlib.Control.Fix.0.Part.Fix.approx.match_1.eq_2 | Mathlib.Control.Fix | ∀ (motive : ℕ → Sort u_1) (i : ℕ) (h_1 : Unit → motive 0) (h_2 : (i : ℕ) → motive i.succ),
(match i.succ with
| 0 => h_1 ()
| i.succ => h_2 i) =
h_2 i | null | true |
card_vector | Mathlib.Data.Fintype.BigOperators | ∀ {α : Type u_1} [inst : Fintype α] (n : ℕ), Fintype.card (List.Vector α n) = Fintype.card α ^ n | null | true |
CochainComplex.shiftFunctorObjXIso.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : CochainComplex C ℤ) (n i m : ℤ) (hm : m = i + n), K.shiftFunctorObjXIso n i m hm = K.shiftFunctorObjXIso n i m hm | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.