name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BitVec.slt_eq_sle_and_ne | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x.slt y = (x.sle y && x != y) | null | true |
AlgebraicGeometry.PresheafedSpace.Hom.ext._proof_1 | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : AlgebraicGeometry.PresheafedSpace C}
(α β : X.Hom Y), α.base = β.base → (TopologicalSpace.Opens.map α.base).op = (TopologicalSpace.Opens.map β.base).op | null | false |
CategoryTheory.Limits.Cocone.precomposeEquivalence._proof_10 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F G : CategoryTheory.Functor J C} (α : F ≅ G)
(X : CategoryTheory.Limits.Cocone F),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.NatIso.ofComponents'
(fun s =>
... | null | false |
CategoryTheory.Localization.Construction.LocQuiver.mk.injEq | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C} (obj obj_1 : C),
({ obj := obj } = { obj := obj_1 }) = (obj = obj_1) | null | true |
LeftCancelMonoid.groupOfFinite | Mathlib.GroupTheory.OrderOfElement | {G : Type u_1} → [LeftCancelMonoid G] → [Finite G] → Group G | Every finite left cancellative monoid is a group. | true |
CategoryTheory.Limits.isIsoZeroEquiv | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) →
CategoryTheory.IsIso 0 ≃ CategoryTheory.CategoryStruct.id X = 0 ∧ CategoryTheory.CategoryStruct.id Y = 0 | A zero morphism `0 : X ⟶ Y` is an isomorphism if and only if
the identities on both `X` and `Y` are zero.
| true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.Term.listEncode.match_1.splitter | Mathlib.ModelTheory.Encoding | {L : FirstOrder.Language} →
{α : Type u_3} →
(motive : L.Term α → Sort u_4) →
(x : L.Term α) →
((i : α) → motive (FirstOrder.Language.var i)) →
((l : ℕ) → (f : L.Functions l) → (ts : Fin l → L.Term α) → motive (FirstOrder.Language.func f ts)) → motive x | null | true |
tprod_mulIndicator_of_mem_union_disjoint | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] (s : γ → Set β)
(f : β → α), Pairwise (Function.onFun Disjoint s) → ∀ i ∈ ⋃ d, s d, ∏' (d : γ), (s d).mulIndicator f i = f i | null | true |
Int.emod_abs | Mathlib.Algebra.Order.Group.Unbundled.Int | ∀ (a b : ℤ), a % |b| = a % b | null | true |
RootPairing.pairingIn_lt_zero_iff | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (S : Type u_5)
[inst_5 : CommRing S] [inst_6 : LinearOrder S] [IsStrictOrderedRing S] [inst_8 : Algebra S R] [Fa... | null | true |
ContinuousLinearMap.inl | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | (R : Type u_1) →
[inst : Semiring R] →
(M₁ : Type u_2) →
[inst_1 : TopologicalSpace M₁] →
[inst_2 : AddCommMonoid M₁] →
[inst_3 : Module R M₁] →
(M₂ : Type u_3) →
[inst_4 : TopologicalSpace M₂] → [inst_5 : AddCommMonoid M₂] → [inst_6 : Module R M₂] → M₁ →L[R] M₁ ×... | The left injection into a product is a continuous linear map. | true |
HasDerivWithinAt.finsetProd | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {ι : Type u_2} [inst_1 : DecidableEq ι]
{𝔸' : Type u_3} [inst_2 : NormedCommRing 𝔸'] [inst_3 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'}
{f' : ι → 𝔸'},
(∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) →
HasDerivWithinAt (∏ ... | null | true |
FiniteIndexNormalSubgroup.comap_id | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : Group G] (K : FiniteIndexNormalSubgroup G),
FiniteIndexNormalSubgroup.comap (MonoidHom.id G) K = K | null | true |
_private.Init.Data.Iterators.Lemmas.Basic.0.Std.Iter.inductSteps._proof_2 | Init.Data.Iterators.Lemmas.Basic | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] [inst_1 : Std.Iterators.Finite α Id] (it : Std.Iter β)
{it' : Std.Iter β} {x : β},
it.IsPlausibleStep (Std.IterStep.yield it' x) →
(invImage (fun x => x.finitelyManySteps) Std.IterM.TerminationMeasures.instWellFoundedRelationFinite).1 it' it | null | false |
Complex.instTietzeExtension | Mathlib.Analysis.Complex.Tietze | TietzeExtension ℂ | null | true |
AlgebraicGeometry.QuasiSeparated | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | A morphism is `QuasiSeparated` if diagonal map is quasi-compact. | true |
Quiver.Path.length_comp._f | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] {a b : V} (p : Quiver.Path a b) (x : V) (x_1 : Quiver.Path b x)
(f : Quiver.Path.below x_1), (p.comp x_1).length = p.length + x_1.length | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.mem_range_left._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {n d : ℕ} (s : (SSet.stdSimplex.obj { len := n }).obj (Opposite.op { len := d })) (i : Fin (n + 1)),
(s ∈ (SSet.horn n i).obj (Opposite.op { len := d })) = ∃ j, ∃ (_ : j ≠ i), j ∉ Set.range ⇑s | null | false |
Std.DTreeMap.Internal.Impl.insert.congr_simp | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (v v_1 : β k),
v = v_1 →
∀ (t : Std.DTreeMap.Internal.Impl α β) (hl : t.Balanced),
Std.DTreeMap.Internal.Impl.insert k v t hl = Std.DTreeMap.Internal.Impl.insert k v_1 t hl | null | true |
HNNExtension.NormalWord.cons_toList | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (g : G)
(u : ℤˣ) (w : HNNExtension.NormalWord d) (h1 : w.head ∈ d.set u)
(h2 : ∀ u' ∈ Option.map Prod.fst w.toList.head?, w.head ∈ HNNExtension.toSubgroup A B u → u = u'),
(HNNExtension.NormalWord.cons g u w h... | null | true |
NumberField.mixedEmbedding.commMap._proof_2 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] (m : ℝ) (x : (K →+* ℂ) → ℂ),
(fun w => ((m • x) (↑w).embedding).re, fun w => (m • x) (↑w).embedding) =
(RingHom.id ℝ) m • (fun w => (x (↑w).embedding).re, fun w => x (↑w).embedding) | null | false |
Set.iInter₂_vadd_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_3} {κ : ι → Sort u_4} [inst : VAdd α β] (s : (i : ι) → κ i → Set α)
(t : Set β), (⋂ i, ⋂ j, s i j) +ᵥ t ⊆ ⋂ i, ⋂ j, s i j +ᵥ t | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.String.0.String.Slice.startsWith_slice_iff._simp_1_7 | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {α : Type u_1} {l₁ l₂ : List α}, (l₁ <+: l₂) = ∃ l₃, l₁ ++ l₃ = l₂ | null | false |
Polynomial.derivative_ofNat | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : Semiring R] (n : ℕ) [inst_1 : n.AtLeastTwo], Polynomial.derivative (OfNat.ofNat n) = 0 | null | true |
CategoryTheory.Limits.Cofork.unop.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᵒᵖ} {f g : X ⟶ Y}
(c : CategoryTheory.Limits.Cofork f g),
c.unop =
((CategoryTheory.Limits.Cocone.precompose (CategoryTheory.Limits.opParallelPairIso f.unop g.unop).hom).obj
(CategoryTheory.Limits.Cocone.whisker CategoryTheory.Limits.wa... | null | true |
LightDiagram'._sizeOf_inst | Mathlib.Topology.Category.LightProfinite.Basic | SizeOf LightDiagram' | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftLeftZeroExtend._proof_1_4 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} (n : ℕ), ¬x.toNat < 2 ^ w → False | null | false |
Inclusion.IntervalDyadicReal.mem_Ici | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.Basic | ∀ {a x : ℝ} {I J : Inclusion.Interval Dyadic}, a ∈ I → x ∈ J → (x ∈ Set.Ici a) ∈ I.le J | null | true |
SSet.Truncated.Edge.CompStruct.comp_unique | Mathlib.AlgebraicTopology.Quasicategory.TwoTruncated | ∀ {A : SSet.Truncated 2} [A.Quasicategory₂]
{x y z : A.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Quasicategory₂._proof_1 })}
{f f' : SSet.Truncated.Edge x y} {g g' : SSet.Truncated.Edge y z} {h h' : SSet.Truncated.Edge x z}
(s : f.CompStruct g h) (s' : f'.CompStruct g' h'),
SSet.Truncat... | Given `CompStruct f g h` and `CompStruct f' g' h'` with the same vertices and edges such
that `f` ≃ `f'` and `g` ≃ `g'`, then the long diagonal edges `h` and `h'` are also homotopic.
| true |
Aesop.SimpResult.ctorElim | Aesop.Search.Expansion.Simp | {motive : Aesop.SimpResult → Sort u} →
(ctorIdx : ℕ) → (t : Aesop.SimpResult) → ctorIdx = t.ctorIdx → Aesop.SimpResult.ctorElimType ctorIdx → motive t | null | false |
HomotopicalAlgebra.BifibrantObject.HoCat.ιCofibrantObject._proof_2 | Mathlib.AlgebraicTopology.ModelCategory.BifibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.BifibrantObject C) (x_2 x_3 : x ⟶ x_1),
HomotopicalAlgebra.BifibrantObject.homRel C x_2 x_3 →
(HomotopicalAlgebra.BifibrantObject.ιCofibrantObject.comp HomotopicalAlgebra.Cofi... | null | false |
instReprExcept | Init.Data.ToString.Basic | {ε : Type u_1} → {α : Type u_2} → [Repr ε] → [Repr α] → Repr (Except ε α) | null | true |
_private.Mathlib.Basic.Logic.Basic.0.forall_imp_iff_exists_imp.match_1_1 | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} (motive : Nonempty α → Prop) (ha : Nonempty α), (∀ (a : α), motive ⋯) → motive ha | null | false |
RestrictedProduct.instPow.eq_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)],
RestrictedProduct.instPow R = { pow := fun x n => ⟨fun i => x i ^ n, ⋯⟩ } | null | true |
Batteries.Tactic.Lint.instReprLintVerbosity | Batteries.Tactic.Lint.Frontend | Repr Batteries.Tactic.Lint.LintVerbosity | null | true |
Lean.Grind.CommRing.denoteInt | Init.Grind.Ring.CommSolver | {α : Type u_1} → [Lean.Grind.Ring α] → ℤ → α | null | true |
Lean.Meta.Sym.Arith.instInhabitedCommRing.default | Lean.Meta.Sym.Arith.Types | Lean.Meta.Sym.Arith.CommRing | null | true |
NumberField.InfinitePlace.IsUnramified.comap | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] (K : Type u_2) [inst_1 : Field K] {F : Type u_3} [inst_2 : Field F]
[inst_3 : Algebra k K] [inst_4 : Algebra k F] [inst_5 : Algebra K F] [IsScalarTower k K F]
{w : NumberField.InfinitePlace F},
NumberField.InfinitePlace.IsUnramified k w → NumberField.InfinitePlace.IsUnramified k ... | null | true |
CategoryTheory.TwoSquare.op | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
... | The opposite of a `2`-square. | true |
Subgroup.le_comap_map | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] (f : G →* N) (H : Subgroup G),
H ≤ Subgroup.comap f (Subgroup.map f H) | null | true |
ContinuousMap.ctorIdx | Mathlib.Topology.ContinuousMap.Defs | {X : Type u_1} → {Y : Type u_2} → {inst : TopologicalSpace X} → {inst_1 : TopologicalSpace Y} → C(X, Y) → ℕ | null | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore.mk.inj | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_2} {κ : Type u_3} {inst : Preorder ι} {c : ℤ → ComplexShape κ} {r₀ : ℤ} {deg : κ → ℤ}
{i₀ : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_1 → ι}
{i₁ i₂ : κ → ι}
{i₃ : (r : ℤ) → κ → autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.Spectr... | null | true |
dist_prod_prod_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {ι : Type u_3} {E : Type u_4} [inst : SeminormedCommGroup E] (s : Finset ι) (f a : ι → E),
dist (∏ b ∈ s, f b) (∏ b ∈ s, a b) ≤ ∑ b ∈ s, dist (f b) (a b) | null | true |
Real.partialOrder._proof_3 | Mathlib.Basic.Real.Basic | ∀ (a b c : ℝ), a ≤ b → b ≤ c → a ≤ c | null | false |
LocallyConstant.constₐ_apply_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (R : Type u_6) [inst_1 : CommSemiring R]
[inst_2 : Semiring Y] [inst_3 : Algebra R Y] (y : Y) (a : X), ((LocallyConstant.constₐ R) y) a = y | null | true |
dotProductBilin._proof_5 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {m : Type u_2} (R : Type u_3) {A : Type u_1} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Fintype m] (x : R) (x_1 x_2 x_3 : m → A),
x • x_1 ⬝ᵥ (x_2 + x_3) = x • x_1 ⬝ᵥ x_2 + x • x_1 ⬝ᵥ x_3 | null | false |
_private.Mathlib.Tactic.Linter.TextBased.UnicodeLinter.0.Mathlib.Linter.TextBased.UnicodeLinter.ASCII.allowed | Mathlib.Tactic.Linter.TextBased.UnicodeLinter | Char → Bool | Allowed (by the linter) ASCII characters | true |
CategoryTheory.yonedaGrpObjRepresentableBy | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
(G : C) →
[inst_2 : CategoryTheory.GrpObj G] →
((CategoryTheory.yonedaGrpObj G).comp (CategoryTheory.forget GrpCat)).RepresentableBy G | If `G` is a monoid object, then `Hom(-, G)` as a presheaf of monoids is represented by `G`. | true |
_private.Init.Data.List.ToArray.0.List.zipWithAll_go_toArray._proof_1_7 | Init.Data.List.ToArray | ∀ {α : Type u_1} {β : Type u_2} (as : List α) (bs : List β) (i : ℕ),
max as.length bs.length ≤ i → ¬bs.length ≤ i → False | null | false |
mem_nhdsWithin | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {t : Set α} {a : α} {s : Set α},
t ∈ nhdsWithin a s ↔ ∃ u, IsOpen u ∧ a ∈ u ∧ u ∩ s ⊆ t | null | true |
_private.Init.Data.PLift.0.instDecidableEqPLift.decEq.match_1 | Init.Data.PLift | {α : Sort u_1} →
(motive : PLift α → PLift α → Sort u_2) →
(x x_1 : PLift α) → ((a b : α) → motive { down := a } { down := b }) → motive x x_1 | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.not_isG2_iff_isNotG2._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.IsCrystallographic] [P.IsReduced] [P.IsIrreducible],
P.IsNotG2 = ∀ (i j : ι), P.pairingIn ℤ i j ∈ ... | null | false |
Lean.warnIfUsesSorry | Lean.AddDecl | Lean.Declaration → Lean.CoreM Unit | If the `warn.sorry` option is set to true and there are no errors in the log already,
logs a warning if the declaration uses `sorry`.
| true |
CategoryTheory.ComposableArrows.Precomp.map_zero_one'._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ}, 0 + 1 < n + 1 + 1 | null | false |
cauchy_davenport_mul_of_linearOrder_isCancelMul | Mathlib.Combinatorics.Additive.CauchyDavenport | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : Mul α] [IsCancelMul α] [MulLeftMono α] [MulRightMono α]
{s t : Finset α}, s.Nonempty → t.Nonempty → s.card + t.card - 1 ≤ (s * t).card | The **Cauchy-Davenport Theorem** for linearly ordered cancellative semigroups. The size of
`s * t` is lower-bounded by `|s| + |t| - 1`. | true |
PartialEquiv.toEquiv.match_1 | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (e : PartialEquiv α β) (motive : ↑e.source → Prop) (x : ↑e.source),
(∀ (val : α) (hx : val ∈ e.source), motive ⟨val, hx⟩) → motive x | null | false |
_private.Mathlib.Topology.UniformSpace.AbstractCompletion.0.AbstractCompletion._aux_Mathlib_Topology_UniformSpace_AbstractCompletion___macroRules__private_Mathlib_Topology_UniformSpace_AbstractCompletion_0_AbstractCompletion_termι_1 | Mathlib.Topology.UniformSpace.AbstractCompletion | Lean.Macro | null | false |
CategoryTheory.equivToOverUnit._proof_8 | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Over.forget (CategoryTheory.MonoidalCategoryStruct.tensorUnit... | null | false |
Module.Invertible.rTensor_bijective_iff | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} (M : Type v) {N : Type u_1} {P : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] [Module.Invertible R M] {f : N →ₗ[R] P},
Function.Bijective ⇑(LinearMap.rTensor M f) ... | null | true |
Finset.sum_range_succ'._f | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] (f : ℕ → M) (x : ℕ) (f_1 : Nat.below x),
∑ k ∈ Finset.range (x + 1), f k = ∑ k ∈ Finset.range x, f (k + 1) + f 0 | null | false |
Matrix.toLinearEquivRight'OfInv | Mathlib.LinearAlgebra.Matrix.ToLin | {R : Type u_1} →
[inst : Semiring R] →
{m : Type u_3} →
{n : Type u_4} →
[inst_1 : Fintype m] →
[inst_2 : DecidableEq m] →
[inst_3 : Fintype n] →
[inst_4 : DecidableEq n] →
{M : Matrix m n R} → {M' : Matrix n m R} → M * M' = 1 → M' * M = 1 → (n → R... | If `M` and `M'` are each other's inverse matrices, they provide an equivalence between `n → A`
and `m → A` corresponding to `M.vecMul` and `M'.vecMul`. | true |
Std.DHashMap.get!_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
[inst_1 : Inhabited (β k)] {f : β k → β k}, (m.modify k f).get! k = (Option.map f (m.get? k)).get! | null | true |
smul_eq_self_of_preimage_zpow_eq_self | Mathlib.Dynamics.FixedPoints.Prufer | ∀ {G : Type u_1} [inst : CommGroup G] {n : ℤ} {s : Set G},
(fun x => x ^ n) ⁻¹' s = s → ∀ {g : G} {j : ℕ}, g ^ n ^ j = 1 → g • s = s | Let `n : ℤ` and `s` a subset of a commutative group `G` that is invariant under preimage for
the map `x ↦ x^n`. Then `s` is invariant under the pointwise action of the subgroup of elements
`g : G` such that `g^(n^j) = 1` for some `j : ℕ`. (This subgroup is called the Prüfer subgroup when
`G` is the `Circle` and `n` is ... | true |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.homotopy_h | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : CategoryTheory.SimplicialObject.Augmented C}
(ed : X.ExtraDegeneracy) {n : ℕ} (i : Fin (n + 1)),
ed.homotopy.h i = CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.homotopy.h ed i | null | true |
Derivation.liftKaehlerDifferential._proof_7 | Mathlib.RingTheory.Kaehler.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {M : Type u_3}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(D : Derivation R S M) ⦃x : ↥(KaehlerDifferential.ideal R S)⦄,
x ∈ Submodule.restrictScalars S (Kaehl... | null | false |
Filter.pi_neBot | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)}, (Filter.pi f).NeBot ↔ ∀ (i : ι), (f i).NeBot | null | true |
ProbabilityTheory.exists_integrable_exp_sq_of_map_rotation_eq_self | Mathlib.Probability.Distributions.Fernique | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [SecondCountableTopology E]
[inst_3 : MeasurableSpace E] [BorelSpace E] {μ : MeasureTheory.Measure E} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.Measure.map (⇑(ContinuousLinearMap.rotation (-(Real.pi / 4)))) (μ.prod μ) = μ.prod μ →
... | **Fernique's theorem** for finite measures whose product is invariant by rotation: there exists
`C > 0` such that the function `x ↦ exp (C * ‖x‖ ^ 2)` is integrable. | true |
JordanHolderLattice.IsMaximal | Mathlib.Order.JordanHolder | {X : Type u} → {inst : Lattice X} → [self : JordanHolderLattice X] → X → X → Prop | null | true |
Rat.num_divInt | Init.Data.Rat.Lemmas | ∀ (a b : ℤ), (Rat.divInt a b).num = b.sign * a / ↑(b.gcd a) | null | true |
Std.ExtDHashMap.Const.ofList_eq_insertMany_empty | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{l : List (α × β)}, Std.ExtDHashMap.Const.ofList l = Std.ExtDHashMap.Const.insertMany ∅ l | null | true |
Lean.Compiler.LCNF.LitValue.uint32.noConfusion | Lean.Compiler.LCNF.Basic | {P : Sort u} →
{val val' : UInt32} →
Lean.Compiler.LCNF.LitValue.uint32 val = Lean.Compiler.LCNF.LitValue.uint32 val' → (val = val' → P) → P | null | false |
SuccOrder.ofSuccLeIff.eq_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] (succ : α → α) (hsucc_le_iff : ∀ {a b : α}, succ a ≤ b ↔ a < b),
SuccOrder.ofSuccLeIff succ hsucc_le_iff = { succ := succ, le_succ := ⋯, max_of_succ_le := ⋯, succ_le_of_lt := ⋯ } | null | true |
_private.Mathlib.Order.UpperLower.Relative.0.isUpperSet_subtype_iff_isRelUpperSet._simp_1_3 | Mathlib.Order.UpperLower.Relative | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
CategoryTheory.PreZeroHypercover.isoMk_inv_s₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S}
(s₀ : E.I₀ ≃ F.I₀) (h₀ : (i : E.I₀) → E.X i ≅ F.X (s₀ i))
(w₀ :
autoParam (∀ (i : E.I₀), CategoryTheory.CategoryStruct.comp (h₀ i).hom (F.f (s₀ i)) = E.f i)
CategoryTheory.PreZeroHypercover.isoMk._a... | null | true |
Std.ExtTreeSet.ofList_eq_foldl | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List α},
Std.ExtTreeSet.ofList l cmp = List.foldl (fun acc a => acc.insert a) ∅ l | null | true |
_private.Mathlib.GroupTheory.PGroup.0.ZModModule.isPGroup_multiplicative._simp_1_2 | Mathlib.GroupTheory.PGroup | ∀ {α : Type u} {p : Multiplicative α → Prop}, (∀ (a : Multiplicative α), p a) = ∀ (a : α), p (Multiplicative.ofAdd a) | null | false |
ENNReal.toEReal | Mathlib.Data.EReal.Basic | ENNReal → EReal | The canonical map from nonnegative extended reals to extended reals. | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.map_add_toArray_rcc._proof_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n k : ℕ}, ¬n + 1 + k = n + k + 1 → False | null | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_nonempty._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α}, (a ∈ s.erase b) = (a ≠ b ∧ a ∈ s) | null | false |
Additive.addCommGroup | Mathlib.Algebra.Group.TypeTags.Basic | {α : Type u} → [CommGroup α] → AddCommGroup (Additive α) | null | true |
CategoryTheory.Bicategory.Adj.left_triangle_components_assoc | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {C₁ C₂ : CategoryTheory.Bicategory.Adj CategoryTheory.Cat} (α : C₁ ⟶ C₂) (X : ↑C₁.obj) {Z : ↑C₂.obj}
(h : (CategoryTheory.CategoryStruct.id C₂.obj).toFunctor.obj (α.l.toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp (α.l.toFunctor.map (α.adj.unit.toNatTrans.app X))
(CategoryTheory.CategoryStruct.co... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform.0.integrable_cexp_quadratic'._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Gaussian.FourierTransform | ∀ (x : ℂ), (Complex.exp x = 0) = False | null | false |
AddAction.fixedBy_mem_fixedBy_of_addCommute | Mathlib.GroupTheory.GroupAction.FixedPoints | ∀ {α : Type u_1} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h : G},
AddCommute g h → AddAction.fixedBy α g ∈ AddAction.fixedBy (Set α) h | If `g` and `h` commute, then `g` fixes `h +ᵥ x` iff `g` fixes `x`.
This is equivalent to say that the set `fixedBy α g` is fixed by `h`. | true |
SSet.OneTruncation₂.HoRel₂.of_compStruct | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {V : SSet.Truncated 2}
{x₀ x₁ x₂ : V.obj (Opposite.op { obj := { len := 0 }, property := SSet.OneTruncation₂._proof_1 })}
{e₀₁ : SSet.Truncated.Edge x₀ x₁} {e₁₂ : SSet.Truncated.Edge x₁ x₂} {e₀₂ : SSet.Truncated.Edge x₀ x₂}
(h : e₀₁.CompStruct e₁₂ e₀₂),
SSet.OneTruncation₂.HoRel₂ V
((CategoryTheory.Cat.Fr... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits.0.SimpleGraph.ErdosStone.filter.pi.match_1.eq_1 | Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits | ∀ {n : ℕ} {G : SimpleGraph (Fin n)} [inst : DecidableRel G.Adj] {r t t' : ℕ} (K : G.CompleteEquipartiteSubgraph r t')
(motive : ↥(SimpleGraph.ErdosStone.filter✝ K t) → Sort u_1) (val : Fin n)
(h : val ∈ SimpleGraph.ErdosStone.filter✝ K t)
(h_1 : (val : Fin n) → (h : val ∈ SimpleGraph.ErdosStone.filter✝ K t) → mot... | null | true |
Std.Sat.AIG.RefVec.rec | Std.Sat.AIG.Basic | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : aig.RefVec w → Sort u} →
((refs : Vector Std.Sat.AIG.Fanin w) →
(hrefs : ∀ {i : ℕ} (h : i < w), refs[i].gate < aig.decls.size) →
motive { ... | null | false |
Finpartition.instLE | Mathlib.Order.Partition.Finpartition | {α : Type u_1} → [inst : Lattice α] → [inst_1 : OrderBot α] → {a : α} → LE (Finpartition a) | We say that `P ≤ Q` if `P` refines `Q`: each part of `P` is less than some part of `Q`. | true |
Set.iInter_setOf | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} (P : ι → α → Prop), ⋂ i, {x | P i x} = {x | ∀ (i : ι), P i x} | **Alias** of `Set.iInter_ofPred`. | true |
OrderIso.sortedLT_listMap._simp_1 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) {l : List α},
(List.map (⇑e) l).SortedLT = l.SortedLT | null | false |
Std.DHashMap.Internal.Raw₀.toList_keysArray_eq_keys | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β), (↑m).keysArray.toList = (↑m).keys | null | true |
AlgebraicGeometry.Scheme.isoOfEq_inv_ι | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme) {U V : X.Opens} (e : U = V),
CategoryTheory.CategoryStruct.comp (X.isoOfEq e).inv U.ι = V.ι | null | true |
Lean.Parser.Tactic.Conv.congr | Init.Conv | Lean.ParserDescr | Performs one step of "congruence", which takes a term and produces
subgoals for all the function arguments. For example, if the target is `f x y` then
`congr` produces two subgoals, one for `x` and one for `y`. | true |
Lean.Lsp.ClientInfo.mk.sizeOf_spec | Lean.Data.Lsp.InitShutdown | ∀ (name : String) (version? : Option String),
sizeOf { name := name, version? := version? } = 1 + sizeOf name + sizeOf version? | null | true |
LinearEquiv.ofIsUnitDet.congr_simp | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {M' : Type u_3}
[inst_3 : AddCommGroup M'] [inst_4 : Module R M'] {ι : Type u_4} {inst_5 : DecidableEq ι} [inst_6 : DecidableEq ι]
[inst_7 : Fintype ι] {f f_1 : M →ₗ[R] M'} (e_f : f = f_1) {v v_1 : Module.Basis ι R M... | null | true |
RingHomIsometric.recOn | Mathlib.Analysis.Normed.Ring.Basic | {R₁ : Type u_5} →
{R₂ : Type u_6} →
[inst : Semiring R₁] →
[inst_1 : Semiring R₂] →
[inst_2 : Norm R₁] →
[inst_3 : Norm R₂] →
{σ : R₁ →+* R₂} →
{motive : RingHomIsometric σ → Sort u} →
(t : RingHomIsometric σ) → ((norm_map : ∀ {x : R₁}, ‖σ x‖ = ‖x‖... | null | false |
Finset.instEmptyCollection | Mathlib.Data.Finset.Empty | {α : Type u_1} → EmptyCollection (Finset α) | null | true |
Lean.Lsp.TextEdit.mk.injEq | Lean.Data.Lsp.Basic | ∀ (range : Lean.Lsp.Range) (newText : String) (leanExtSnippet? : Option Lean.Lsp.SnippetString)
(annotationId? : Option String) (range_1 : Lean.Lsp.Range) (newText_1 : String)
(leanExtSnippet?_1 : Option Lean.Lsp.SnippetString) (annotationId?_1 : Option String),
({ range := range, newText := newText, leanExtSnipp... | null | true |
String.Slice.ByteIterator.mk.noConfusion | Init.Data.String.Iterate | {P : Sort u} →
{s : String.Slice} →
{offset : String.Pos.Raw} →
{s' : String.Slice} →
{offset' : String.Pos.Raw} →
{ s := s, offset := offset } = { s := s', offset := offset' } → (s = s' → offset = offset' → P) → P | null | false |
UInt32.decEq._proof_1 | Init.Prelude | ∀ (a b : UInt32), (decide (a.toBitVec = b.toBitVec)).Reflects (a = b) | null | false |
LinearEquiv.map_eq_of_mem_fixingSubgroup | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {R : Type u_1} [inst : Semiring R] {V : Type u_3} [inst_1 : AddCommMonoid V] [inst_2 : Module R V] (e : V ≃ₗ[R] V)
(W : Submodule R V), e ∈ fixingSubgroup (V ≃ₗ[R] V) W.carrier → Submodule.map (↑e) W = W | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.