name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IntermediateField.extendRight.instIsScalarTowerSubtypeMem_1 | Mathlib.FieldTheory.IntermediateField.ExtendRight | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (F : IntermediateField K L)
(M : Type u_3) [inst_3 : Field M] [inst_4 : Algebra K M] [inst_5 : Algebra L M] [inst_6 : IsScalarTower K L M]
{S : Type u_5} [inst_7 : CommRing S] [inst_8 : Algebra S ↥F] [inst_9 : Algebra S M]
... | null | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.card_product_filter_lt._proof_1_2 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {s : Finset α} [inst : LinearOrder α]
(disj : Disjoint ({x ∈ s ×ˢ s | x.1 < x.2}) ({x ∈ s ×ˢ s | x.2 < x.1})),
{x ∈ s ×ˢ s | x.1 < x.2}.disjUnion ({x ∈ s ×ˢ s | x.2 < x.1}) disj = s.offDiag | null | false |
CategoryTheory.Limits.BinaryBiconeMorphism.wsnd_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} {A B : CategoryTheory.Limits.BinaryBicone P Q} (self : CategoryTheory.Limits.BinaryBiconeMorphism A B)
{Z : C} (h : Q ⟶ Z),
CategoryTheory.CategoryStruct.comp self.hom (CategoryTheory.Categor... | The triangle consisting of the two natural transformations and `hom` commutes | true |
Multiset.noncommSum | Mathlib.Data.Finset.NoncommProd | {α : Type u_3} → [inst : AddMonoid α] → (s : Multiset α) → {x | x ∈ s}.Pairwise AddCommute → α | Sum of a `s : Multiset α` with `[AddMonoid α]`, given a proof that `+` commutes
on all elements `x ∈ s`. | true |
CategoryTheory.Subgroupoid.isWide_iff_objs_eq_univ | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C), S.IsWide ↔ S.objs = Set.univ | null | true |
RestrictedProduct.mk | Mathlib.Topology.Algebra.RestrictedProduct.Basic | {ι : Type u_1} →
{R : ι → Type u_2} →
{A : (i : ι) → Set (R i)} →
{𝓕 : Filter ι} →
(x : (i : ι) → R i) → (∀ᶠ (i : ι) in 𝓕, x i ∈ A i) → RestrictedProduct (fun i => R i) (fun i => A i) 𝓕 | Constructor for `RestrictedProduct`. | true |
_private.Init.Data.List.Count.0.List.countP_eq_zero._simp_1_2 | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (List.filter p l = []) = ∀ a ∈ l, ¬p a = true | null | false |
List.flatMap_eq_foldl | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → List β} {l : List α},
List.flatMap f l = List.foldl (fun acc a => acc ++ f a) [] l | null | true |
id_map' | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} {α : Type u_1} [inst : Functor f] [LawfulFunctor f] (x : f α), (fun a => a) <$> x = x | null | true |
DividedPowers.SubDPIdeal.instCompleteLattice._proof_3 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} (J J' : hI.SubDPIdeal),
⟨(J ⊔ J').carrier, ⋯⟩ = ⟨J.carrier, ⋯⟩ ⊔ ⟨J'.carrier, ⋯⟩ | null | false |
_private.Mathlib.Basic.Denumerable.0.Nat.Subtype.right_inverse_aux._f | Mathlib.Basic.Denumerable | ∀ {s : Set ℕ} [inst : Infinite ↑s] [inst_1 : DecidablePred fun x => x ∈ s] (x : ℕ) (f : Nat.below x),
Nat.Subtype.toFunAux✝ (Nat.Subtype.ofNat s x) = x | null | false |
_private.Mathlib.LinearAlgebra.Eigenspace.Triangularizable.0.Submodule.inf_iSup_genEigenspace._simp_1_2 | Mathlib.LinearAlgebra.Eigenspace.Triangularizable | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ} {x : M}, (x ∈ ((f - μ • 1) ^ k).ker) = (x ∈ (f.genEigenspace μ) ↑k) | null | false |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleFoldingRange.addCommandRange | Lean.Server.FileWorker.RequestHandling | Lean.FileMap → Lean.Syntax → StateT (Array Lean.Lsp.FoldingRange) Lean.Server.RequestM Unit | null | true |
Combinatorics.Additive.«_aux_Mathlib_Combinatorics_Additive_Energy___macroRules_Combinatorics_Additive_termEₘ[_]_1» | Mathlib.Combinatorics.Additive.Energy | Lean.Macro | null | false |
CategoryTheory.Pseudofunctor.DescentData'.instCategory._proof_11 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryT... | null | false |
mul_eq_one_iff_eq_inv' | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a * b = 1 ↔ b = a⁻¹ | Variant of `mul_eq_one_iff_eq_inv` with swapped equality. | true |
DFinsupp.comapDomain._proof_2 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_3} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) (hh : Function.Injective h)
(f : Π₀ (i : ι), β i) (s : { s // ∀ (i : ι), i ∈ s ∨ f.toFun i = 0 }) (x : κ), x ∈ ⋯.toFinset.val ∨ f (h x) = 0 | null | false |
Std.DTreeMap.Internal.Impl.Equiv.inter_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF), m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁.inter m₂ ⋯).Equiv (m₁.inter m₃ ⋯) | null | true |
Lean.Meta.instReduceEvalLiteral | Lean.Meta.ReduceEval | Lean.Meta.ReduceEval Lean.Literal | null | true |
Option.instDecidableMemOfDecidableEq | Init.Data.Option.Instances | {α : Type u_1} → [DecidableEq α] → (j : α) → (o : Option α) → Decidable (j ∈ o) | null | true |
Subgroup.equivMapOfInjective.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] (H : Subgroup G) (f : G →* N)
(hf : Function.Injective ⇑f), H.equivMapOfInjective f hf = { toEquiv := Equiv.Set.image (⇑f) (↑H) hf, map_mul' := ⋯ } | null | true |
Mathlib.Tactic.subscript.parenthesizer | Mathlib.Util.Superscript | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer | Formatter for the subscript parser. | true |
CategoryTheory.PreGaloisCategory.AutGalois.ext | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) {f g : CategoryTheory.PreGaloisCategory.AutGalois F},
(∀ (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(CategoryTheory.PreGaloisCategory.AutGalois.π ... | Equality of elements of `AutGalois F` can be checked on the projections on each pointed
Galois object. | true |
Std.DHashMap.Internal.Raw₀.getThenInsertIfNew?.congr_simp | Std.Data.DHashMap.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
(m m_1 : Std.DHashMap.Internal.Raw₀ α β),
m = m_1 → ∀ (a : α) (b b_1 : β a), b = b_1 → m.getThenInsertIfNew? a b = m_1.getThenInsertIfNew? a b_1 | null | true |
AddSemigroupIdeal.instWellFoundedGT | Mathlib.Algebra.Order.Group.Ideal | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [WellQuasiOrderedLE M] [CanonicallyOrderedAdd M],
WellFoundedGT (AddSemigroupIdeal M) | A canonically ordered and well-quasi-ordered additive monoid, the semigroup ideals
satisfy the ascending chain condition. | true |
ContinuousLinearMap.bilinearComp_zero_left | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E' : Type u_6} {F' : Type u_10} {G' : Type u_14}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : NontriviallyNormedField 𝕜₃]
{σ₂₃ : 𝕜₂ →+* 𝕜₃} {σ₁₃ : 𝕜 →+* 𝕜₃} [inst_3 : AddCommGroup E'] [inst_4 : Module 𝕜 E'] [inst_5 : ... | null | true |
Lean.Elab.Term.LetConfig.recOn | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetConfig → Sort u} →
(t : Lean.Elab.Term.LetConfig) →
((nondep usedOnly zeta postponeValue generalize : Bool) →
(eq? : Option Lean.Ident) →
motive
{ nondep := nondep, usedOnly := usedOnly, zeta := zeta, postponeValue := postponeValue,
generaliz... | null | false |
CategoryTheory.createsLimitOfReflectsIso._proof_2 | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{K : CategoryTheory.Functor J C} {F : CategoryTheory.Functor C D} [F.ReflectsIsomorphisms]
(h :
(c : CategoryTheory.Limit... | null | false |
NonUnitalSeminormedRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
[toNorm : Norm α] →
[toNonUnitalRing : NonUnitalRing α] →
[toPseudoMetricSpace : PseudoMetricSpace α] →
(∀ (x y : α), dist x y = ‖-x + y‖) → (∀ (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖) → NonUnitalSeminormedRing α | null | true |
AlgebraicGeometry.Scheme.instFullOppositeIdealSheafDataOverSubschemeFunctor | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {Y : AlgebraicGeometry.Scheme}, (AlgebraicGeometry.Scheme.IdealSheafData.subschemeFunctor Y).Full | null | true |
BoundedContinuousFunction.probCharDual._proof_5 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | SMulCommClass ℝ ℝ ℝ | null | false |
CategoryTheory.ObjectProperty.SerreClassLocalization.fullyFaithfulWhiskeringLeft | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{D : Type u'} →
[inst_2 : CategoryTheory.Category.{v', u'} D] →
(L : CategoryTheory.Functor C D) →
(P : CategoryTheory.ObjectProperty C) →
[inst_3 : P.IsSerreClass] →
... | When `L : C ⥤ D` is a localization functor with respect to a Serre class
in the abelian category `C`, the functor `whiskeringLeft L P E: (D ⥤ₑ E) ⥤ C ⥤ₑ E`
is fully faithful. | true |
List.head_takeWhile | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {l : List α} (w : List.takeWhile p l ≠ []), (List.takeWhile p l).head w = l.head ⋯ | null | true |
StructureGroupoid.LocalInvariantProp.liftPropWithinAt_of_liftPropAt | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {P : (H → H') → Set H → H → Prop} {g : M → M'}
{s : Set M} {x : M},
(∀... | null | true |
Scott.IsOpen.inter | Mathlib.Topology.OmegaCompletePartialOrder | ∀ (α : Type u) [inst : OmegaCompletePartialOrder α] (s t : Set α),
Scott.IsOpen α s → Scott.IsOpen α t → Scott.IsOpen α (s ∩ t) | null | true |
Submodule.Quotient.seminormedAddCommGroup._aux_17 | 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) → Filter (M ⧸ S) | null | false |
OrderIso.toGaloisInsertion._proof_1 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (g : β), g ≤ e (e.symm g) | null | false |
Fin2.fs.injEq | Mathlib.Data.Fin.Fin2 | ∀ {n : ℕ} (a a_1 : Fin2 n), (a.fs = a_1.fs) = (a = a_1) | null | true |
Array.getElem_zero_filterMap._proof_1 | Init.Data.Array.Find | ∀ {α : Type u_2} {β : Type u_1} {f : α → Option β} {xs : Array α},
0 < (Array.filterMap f xs).size → (Array.findSome? f xs).isSome = true | null | false |
CategoryTheory.Lax.LaxTrans.Modification.vcomp | Mathlib.CategoryTheory.Bicategory.Modification.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ ι : F ⟶ G} →
CategoryTheory.Lax.LaxTrans.Modification η θ →
CategoryTheory.Lax.LaxTrans.Modification θ ι → ... | Vertical composition of modifications. | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Pi.0.Module.End.independent_iInf_maxGenEigenspace_of_forall_mapsTo._simp_1_3 | Mathlib.LinearAlgebra.Eigenspace.Pi | ∀ {α : Type u_2} [inst : CompleteLattice α] [IsCompactlyGenerated α] {ι : Type u_3} {f : ι → α},
iSupIndep f = ∀ (s : Finset ι), s.SupIndep f | null | false |
Finset.right_eq_union | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s = t ∪ s ↔ t ⊆ s | null | true |
IsPrimitiveRoot.norm_pow_sub_one_of_prime_pow_ne_two | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {p : ℕ} {K : Type u} {L : Type v} [inst : Field L] {ζ : L} [inst_1 : Field K] [inst_2 : Algebra K L] {k s : ℕ},
IsPrimitiveRoot ζ (p ^ (k + 1)) →
∀ [hpri : Fact (Nat.Prime p)] [IsCyclotomicExtension {p ^ (k + 1)} K L],
Irreducible (Polynomial.cyclotomic (p ^ (k + 1)) K) →
s ≤ k → p ^ (k - s + 1) ≠... | If `Irreducible (cyclotomic (p ^ (k + 1)) K)` (in particular for `K = ℚ`) and `p` is a prime,
then the norm of `ζ ^ (p ^ s) - 1` is `p ^ (p ^ s)` if `p ^ (k - s + 1) ≠ 2`. See the next lemmas
for similar results. | true |
_private.Lean.Elab.AutoBound.0.Lean.Elab.checkValidAutoBoundImplicitName._sparseCasesOn_1 | Lean.Elab.AutoBound | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
String.offset_posLT_lt._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} {h : 0 < p}, ((s.posLT p h).offset < p) = True | null | false |
WithBot.instNonAssocSemiring._proof_4 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : NonAssocSemiring α] (n : ℕ), ↑(n + 1) = ↑n + 1 | null | false |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.updateLocalSpecParamInfo.match_3 | Lean.Compiler.LCNF.Specialize | (motive : Lean.Compiler.LCNF.SpecParamInfo → Sort u_1) →
(i : Lean.Compiler.LCNF.SpecParamInfo) →
((weak : Bool) → motive (Lean.Compiler.LCNF.SpecParamInfo.fixedInst weak)) →
((x : Lean.Compiler.LCNF.SpecParamInfo) → motive x) → motive i | null | false |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaEven.0.HurwitzZeta.differentiable_hurwitzZetaEven_sub_hurwitzZetaEven._abel_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a b : UnitAddCircle) (x : ℂ),
HurwitzZeta.hurwitzZetaEven a x - HurwitzZeta.hurwitzZetaEven b x =
HurwitzZeta.hurwitzZetaEven a x - 1 / (x - 1) / x.Gammaℝ -
(HurwitzZeta.hurwitzZetaEven b x - 1 / (x - 1) / x.Gammaℝ) | null | false |
Matrix.subsingleton_of_empty_left | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [IsEmpty m], Subsingleton (Matrix m n α) | null | true |
OrthonormalBasis.det_to_matrix_orthonormalBasis_of_same_orientation | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {ι : Type u_2} [inst_2 : Fintype ι]
[inst_3 : DecidableEq ι] (e f : OrthonormalBasis ι ℝ E),
e.toBasis.orientation = f.toBasis.orientation → e.toBasis.det ⇑f = 1 | The change-of-basis matrix between two orthonormal bases with the same orientation has
determinant 1. | true |
Vector.insertIdx._proof_2 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), ∀ i ≤ n, i ≤ xs.toArray.size | null | false |
AddCircle.windingNumberIso._proof_1 | Mathlib.Topology.Covering.FundamentalGroupCircle | ∀ {p : ℝ}, IsAddQuotientCoveringMap QuotientAddGroup.mk ↥(AddSubgroup.zmultiples p) | null | false |
MonomialOrder.degLex_single_le_iff | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {σ : Type u_2} [inst : LinearOrder σ] [inst_1 : WellFoundedGT σ] {a b : σ},
((MonomialOrder.degLex.toSyn fun₀ | a => 1) ≤ MonomialOrder.degLex.toSyn fun₀ | b => 1) ↔ b ≤ a | null | true |
CategoryTheory.Limits.WidePushout.hom_eq_desc._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {objs : J → C}
(arrows : (j : J) → B ⟶ objs j) [inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C}
(g : CategoryTheory.Limits.widePushout B objs arrows ⟶ X) (j : J),
CategoryTheory.CategoryStruct.comp (arrows j... | null | false |
CategoryTheory.Abelian.Preradical.shortExact_shortComplexObj | Mathlib.CategoryTheory.Abelian.Preradical.Colon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Φ : CategoryTheory.Abelian.Preradical C) (X : C), (Φ.shortComplexObj X).ShortExact | null | true |
CategoryTheory.CardinalFilteredPoset.Hom.injective | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ {κ : Cardinal.{u}} [inst : Fact κ.IsRegular] {J₁ J₂ : CategoryTheory.CardinalDirectedPoset κ} (f : J₁ ⟶ J₂),
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom f) | **Alias** of `CategoryTheory.CardinalDirectedPoset.Hom.injective`. | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremWithKind?.go.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Option (List Lean.Expr × List Lean.HeadIndex) → Sort u_1) →
(__x : Option (List Lean.Expr × List Lean.HeadIndex)) →
((patterns : List Lean.Expr) → (symbols : List Lean.HeadIndex) → motive (some (patterns, symbols))) →
((x : Option (List Lean.Expr × List Lean.HeadIndex)) → motive x) → motive __x | null | false |
Mathlib.Tactic.Determinant.Cert.mk.inj | Mathlib.Tactic.Determinant.Bird.Cert | ∀ {u : Lean.Level} {α : Q(Type u)} {rα : Q(CommRing «$α»)} {subject : Q(«$α»)}
{result : Mathlib.Tactic.Determinant.CertResult rα subject} {isZero : Bool} {subject_1 : Q(«$α»)}
{result_1 : Mathlib.Tactic.Determinant.CertResult rα subject_1} {isZero_1 : Bool},
{ subject := subject, result := result, isZero := isZe... | null | true |
BddDistLat.hom_ext | Mathlib.Order.Category.BddDistLat | ∀ {X Y : BddDistLat} {f g : X ⟶ Y}, BddDistLat.Hom.hom f = BddDistLat.Hom.hom g → f = g | null | true |
AlgebraicGeometry.ProjIsoSpecTopComponent.toSpec | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
(f : A) →
↑((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrict ⋯).toPresheafedSpace ... | The continuous function from the basic open set `D(f)` in `Proj`
to the corresponding basic open set in `Spec A⁰_f`. | true |
Mathlib.Meta.FunProp.MaybeFunctionData.recOn | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.MaybeFunctionData → Sort u} →
(t : Mathlib.Meta.FunProp.MaybeFunctionData) →
((f : Lean.Expr) → motive (Mathlib.Meta.FunProp.MaybeFunctionData.letE f)) →
((f : Lean.Expr) → motive (Mathlib.Meta.FunProp.MaybeFunctionData.lam f)) →
((fData : Mathlib.Meta.FunProp.Function... | null | false |
FundamentalGroupoid.map_id | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X],
FundamentalGroupoid.map (ContinuousMap.id X) = CategoryTheory.Functor.id (FundamentalGroupoid X) | null | true |
essSup_map_measure._auto_1 | Mathlib.MeasureTheory.Function.EssSup | Lean.Syntax | null | false |
Lean.Elab.Tactic.EvalTacticFailure.rec | Lean.Elab.Tactic.Basic | {motive : Lean.Elab.Tactic.EvalTacticFailure → Sort u} →
((exception : Lean.Exception) →
(state : Lean.Elab.Tactic.SavedState) → motive { exception := exception, state := state }) →
(t : Lean.Elab.Tactic.EvalTacticFailure) → motive t | null | false |
Lean.Doc.Syntax.linebreak | Lean.DocString.Syntax | Lean.ParserDescr | null | true |
CliffordAlgebra.instStarRing._proof_3 | Mathlib.LinearAlgebra.CliffordAlgebra.Star | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x y : CliffordAlgebra Q),
CliffordAlgebra.reverse (CliffordAlgebra.involute (x + y)) =
CliffordAlgebra.reverse (CliffordAlgebra.involute x) + CliffordAlgebra.reverse (CliffordAlgebra.invo... | null | false |
CategoryTheory.Pseudofunctor.DescentData'.descentDataEquivalence._proof_5 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryT... | null | false |
Polynomial.Chebyshev.irrational_of_isRoot_T_real | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ {n : ℕ} {x : ℝ}, (Polynomial.Chebyshev.T ℝ ↑n).IsRoot x → x ≠ 0 → Irrational x | null | true |
Representation.single_smul | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (t : k) (g : G) (v : ρ.asModule),
MonoidAlgebra.single g t • v = t • (ρ g) (ρ.asModuleEquiv v) | null | true |
CategoryTheory.LocalizerMorphism.homMap_apply_assoc | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C₁ : Type u_2} {C₂ : Type u_3} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_2, u_2} C₁]
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] [inst_2 : CategoryTheory.Category.{v_5, u_5} D₁]
[inst_3 : CategoryTheory.Category.{v_6, u_6} D₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : Catego... | null | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR₂.eq_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (l : List α) (le : α → α → Bool),
List.MergeSort.Internal.mergeSortTR₂ l le = List.MergeSort.Internal.mergeSortTR₂.run✝ le ⟨l, ⋯⟩ | null | true |
Bool.atLeastTwo_false_left | Init.Data.BitVec.Bitblast | ∀ {b c : Bool}, false.atLeastTwo b c = (b && c) | null | true |
List.pairwise_lt_finRange | Init.Data.List.Nat.Pairwise | ∀ (n : ℕ), List.Pairwise (fun x1 x2 => x1 < x2) (List.finRange n) | The list `List.finRange n` is strictly increasing. | true |
SaturatedAddSubmonoid.mem_top._simp_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {x : M}, (x ∈ ⊤) = True | null | false |
CommGrpCat.Forget₂.createsLimit._proof_12 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommGrpCat)
(this : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommGrpCat)).sections)
(this_1 :
Small.{u_2, max u_2 u_3}
↑((F.comp ((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.for... | null | false |
meromorphicOrderAt_const_intCast | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_4} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] (z₀ : 𝕜) (n : ℤ) [inst_3 : Decidable (↑n = 0)],
meromorphicOrderAt (↑n) z₀ = if ↑n = 0 then ⊤ else 0 | The order of a constant function is `⊤` if the constant is zero and `0` otherwise.
| true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.etaPossibilities.isStarWithArg._f | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Lean.Expr → (a : Lean.Expr) → Lean.Expr.below a → Bool | null | false |
Fintype.sum_neg_iff_of_nonpos | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : Fintype ι] [inst_1 : AddCommMonoid M] [inst_2 : PartialOrder M]
[IsOrderedCancelAddMonoid M] {f : ι → M}, f ≤ 0 → (∑ i, f i < 0 ↔ f < 0) | null | true |
Std.Tactic.BVDecide.Gate.eval.eq_4 | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | Std.Tactic.BVDecide.Gate.or.eval = fun x1 x2 => x1 || x2 | null | true |
CategoryTheory.Subobject.Classifier.mkOfTerminalΩ₀_truth | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (Ω₀ : C) (t : CategoryTheory.Limits.IsTerminal Ω₀) (Ω : C)
(truth : Ω₀ ⟶ Ω) (χ : {U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ Ω)
(isPullback :
∀ {U X : C} (m : U ⟶ X) [inst_1 : CategoryTheory.Mono m], CategoryTheory.IsPullback m (t.from U) (χ m... | null | true |
CategoryTheory.yonedaAddGrpObj._proof_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(G : C) [inst_2 : CategoryTheory.AddGrpObj G] (X : Cᵒᵖ),
AddGrpCat.ofHom (AddMonCat.Hom.hom ((CategoryTheory.yonedaAddMonObj G).map (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.Categor... | null | false |
Lean.Meta.Grind.AC.addTermOpId | Lean.Meta.Tactic.Grind.AC.Util | Lean.Expr → Lean.Meta.Grind.AC.ACM Unit | null | true |
Std.Internal.List.getValueCast?_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {k : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCast? k (Std.Internal.List.modifyKey k f l) =
Option.map f (Std.Internal.List.getValueCast? k l) | null | true |
Submodule.adjoint_orthogonalProjection | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (U : Submodule 𝕜 E) [inst_4 : CompleteSpace ↥U],
ContinuousLinearMap.adjoint U.orthogonalProjectionOnto = U.subtypeL | **Alias** of `Submodule.adjoint_orthogonalProjectionOnto`. | true |
TateCohomology.preservesFiniteColimits_tateComplexFunctor | Mathlib.RepresentationTheory.Homological.TateCohomology.Basic | ∀ {R G : Type u} [inst : CommRing R] [inst_1 : Group G] [inst_2 : Fintype G],
CategoryTheory.Limits.PreservesFiniteColimits (tateComplexFunctor R G) | null | true |
MonoidHom.coe_of_map_div | Mathlib.Algebra.Group.Hom.Basic | ∀ {G : Type u_5} [inst : Group G] {H : Type u_8} [inst_1 : Group H] (f : G → H)
(hf : ∀ (x y : G), f (x / y) = f x / f y), ⇑(MonoidHom.ofMapDiv f hf) = f | null | true |
Std.Tactic.BVDecide.BVExpr.Return.recOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
{w : ℕ} →
{motive : Std.Tactic.BVDecide.BVExpr.Return aig w → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.Return aig w) →
((result : aig.ExtendingRefVecEntry w) →
(cache : Std.Tactic.BVDecide.BVExpr.Cache (↑result).aig) → motive { result := r... | null | false |
_private.Mathlib.Data.Finset.Range.0.notMemRangeEquiv._proof_2 | Mathlib.Data.Finset.Range | ∀ (k j : ℕ), k + j ∉ Finset.range k | null | false |
MulZeroMemClass.isCancelMulZero | Mathlib.Algebra.GroupWithZero.Submonoid.CancelMulZero | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] {S : Type u_2} [inst_2 : SetLike S M₀] [inst_3 : MulMemClass S M₀]
[inst_4 : ZeroMemClass S M₀] (s : S) [IsCancelMulZero M₀], IsCancelMulZero ↥s | A submagma with zero of a cancellative magma with zero inherits cancellation. | true |
isCompactElement_iff_le_of_directed_sSup_le | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_4} [inst : CompleteLattice α] (k : α),
IsCompactElement k ↔ ∀ (s : Set α), s.Nonempty → DirectedOn (fun x1 x2 => x1 ≤ x2) s → k ≤ sSup s → ∃ x ∈ s, k ≤ x | An element `k` is compact if and only if any directed set with `sSup` above
`k` already got above `k` at some point in the set. | true |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.AffineSpace.nhds_bind_asymptoticNhds._simp_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {α : Type u_1} {f g : Filter α}, (f ≤ g) = ∀ x ∈ g, x ∈ f | null | false |
Filter.pureAddMonoidHom | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [inst : AddZeroClass α] → α →+ Filter α | `pure` as an `AddMonoidHom`. | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Approximates._proof_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | Lean.Order.monotone fun f {basis} ms =>
basis = [] ∨
(∃ basis_hd basis_tl f,
f =ᶠ[Filter.atTop] 0 ∧
basis = basis_hd :: basis_tl ∧
ms ≍
Tactic.ComputeAsymptotics.MultiseriesExpansion.mk
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.nil f) ∨
... | null | false |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.deleteVerts.eq_1 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_1} {β : Type u_2} (G : Graph α β) (X : Set α), G.deleteVerts X = G.induce (G.vertexSet \ X) | null | true |
CategoryTheory.Enriched.FunctorCategory.enrichedHom_condition_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] (F₁ F₂ : CategoryTheory.Functor J C)... | null | true |
MeasureTheory.sdiff_addFundamentalFrontier | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] (s : Set α),
s \ MeasureTheory.addFundamentalFrontier G s = MeasureTheory.addFundamentalInterior G s | null | true |
Stream'.homomorphism | Mathlib.Data.Stream.Init | ∀ {α : Type u} {β : Type v} (f : α → β) (a : α), Stream'.pure f ⊛ Stream'.pure a = Stream'.pure (f a) | null | true |
_private.Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField.0.AlgebraicGeometry.LocallyRingedSpace.basicOpen_eq_bot_iff_forall_evaluation_eq_zero._simp_1_1 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
DFinsupp.nonempty_neLocus_iff | Mathlib.Data.DFinsupp.NeLocus | ∀ {α : Type u_1} {N : α → Type u_2} [inst : DecidableEq α] [inst_1 : (a : α) → DecidableEq (N a)]
[inst_2 : (a : α) → Zero (N a)] {f g : Π₀ (a : α), N a}, (f.neLocus g).Nonempty ↔ f ≠ g | null | true |
Module.mapEvalEquiv._proof_1 | Mathlib.LinearAlgebra.Dual.Defs | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomSurjective (RingHom.id R) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.