name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SSet.StrictSegal._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} → X.StrictSegal → ℕ | null | false |
Finset.max'_lt_iff._simp_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty) {x : α}, (s.max' H < x) = ∀ y ∈ s, y < x | null | false |
TopologicalSpace.OpenNhdsOf.mk.sizeOf_spec | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {x : α} [inst_1 : SizeOf α] (toOpens : TopologicalSpace.Opens α)
(mem' : x ∈ toOpens.carrier), sizeOf { toOpens := toOpens, mem' := mem' } = 1 + sizeOf toOpens + sizeOf mem' | null | true |
Std.HashSet.Raw.contains_empty | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α}, ∅.contains a = false | null | true |
Module.DirectLimit.addCommMonoid._proof_3 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] (G : ι → Type u_3)
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
[inst_4 : DecidableEq ι] (a b c : Module.DirectLimit G f), a + b + c = a + (b + c) | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.add_bmod_eq_add_bmod_left._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {n : ℕ} {y : ℤ} (i : ℤ), ((i + x).bmod n = (i + y).bmod n) = (x.bmod n = y.bmod n) | null | false |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.einfsep._simp_1_5 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} {x : α × α} {s : Set α}, (x ∈ s.offDiag) = (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) | null | false |
CategoryTheory.Abelian.Ext.mk₀_smul | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {R : Type t} [inst : Ring R] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] [inst_4 : CategoryTheory.HasExt C] {X Y : C}
(r : R) (f : X ⟶ Y), CategoryTheory.Abelian.Ext.mk₀ (r • f) = r • CategoryTheory.Abelian.Ext.mk₀ f | null | true |
Lean.Widget.DiffTag.willInsert.sizeOf_spec | Lean.Widget.InteractiveCode | sizeOf Lean.Widget.DiffTag.willInsert = 1 | null | true |
Lean.Parser.Term.ensureTypeOf | Lean.Parser.Term | Lean.Parser.Parser | null | true |
List.reduceOption_length_le | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (l : List (Option α)), l.reduceOption.length ≤ l.length | null | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doSeq._regBuiltin.Lean.Parser.Term.doSeqIndent.parenthesizer_29 | Lean.Parser.Do | IO Unit | null | false |
spectralNorm.spectralNorm_pow_natDegree_eq_prod_roots | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ (K : Type u) [inst : NontriviallyNormedField K] (L : Type v) [inst_1 : Field L] [inst_2 : Algebra K L]
[hu : IsUltrametricDist K] [inst_3 : CompleteSpace K] (x : L) {E : Type u_2} [inst_4 : Field E] [inst_5 : Algebra K E]
[inst_6 : Algebra L E] [IsScalarTower K L E] [Polynomial.IsSplittingField L E ((Polynomial.m... | Given an algebraic tower of fields `E/L/K` and an element `x : L` whose minimal polynomial `f`
over `K` splits into linear factors over `E`, the `degree(f)`th power of the spectral norm of `x`,
considered as an element of `E`, is equal to the spectral norm of the product of the `E`-valued
roots of `f`. | true |
Int.tdiv_nonpos_of_nonneg_of_nonpos | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → b ≤ 0 → a.tdiv b ≤ 0 | null | true |
ContinuousNeg.rec | Mathlib.Topology.Algebra.Group.Defs | {G : Type u} →
[inst : TopologicalSpace G] →
[inst_1 : Neg G] →
{motive : ContinuousNeg G → Sort u_1} →
((continuous_neg : Continuous fun a => -a) → motive ⋯) → (t : ContinuousNeg G) → motive t | null | false |
HomotopicalAlgebra.PathObject.weakEquivalence_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
{A : C} (self : HomotopicalAlgebra.PathObject A), HomotopicalAlgebra.WeakEquivalence self.ι | null | true |
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._proof_19 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (X : AlgebraicGeometry.Scheme) (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)] (n : ℕ),
autoParam
(∀ (a : X.EllAdicCohomology ℓ n), AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._aux_17 X ℓ n 0 a = 0)
SubNegMonoid.zsmul_zero'._autoParam | null | false |
Ordnode.erase._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α | null | false |
QuadraticMap.mk.sizeOf_spec | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u} {M : Type v} {N : Type w} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : SizeOf R] [inst_6 : SizeOf M] [inst_7 : SizeOf N]
(toFun : M → N) (toFun_smul : ∀ (a : R) (x : M), toFun (a • x) = (a * a) • toFun x)
(exists... | null | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeInductiveDecl.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{decl : Lean.Declaration} →
{indFvars : Array Lean.Expr} →
{numParams : ℤ} →
{rs : Array Lean.Elab.Command.PreElabHeaderResult} →
{decl' : Lean.Declaration} →
{indFvars' : Array Lean.Expr} →
{numParams' : ℤ} →
{rs' : Array Lean.Elab.... | null | false |
Std.DTreeMap.Raw.get!_inter_of_mem_right | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst_1 : Inhabited (β k)], k ∈ t₂ → (t₁ ∩ t₂).get! k = t₁.get! k | null | true |
AlgebraicGeometry.Scheme.pretopology.congr_simp | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ (P P_1 : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) (e_P : P = P_1) [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative], AlgebraicGeometry.Scheme.pretopology P = AlgebraicGeometry.Scheme.pretopology P_1 | null | true |
OrderIso.sumLexIioIci_symm_apply_of_ge | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α} (h : x ≤ y), (OrderIso.sumLexIioIci x).symm y = toLex (Sum.inr ⟨y, h⟩) | null | true |
DyckWord.insidePart._proof_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord) (h : ¬p = 0),
p.take (p.firstReturn + 1) ⋯ ≠ 0 ∧
∀ ⦃i : ℕ⦄,
0 < i →
i < (↑(p.take (p.firstReturn + 1) ⋯)).length →
List.count DyckStep.D (List.take i ↑(p.take (p.firstReturn + 1) ⋯)) <
List.count DyckStep.U (List.take i ↑(p.take (p.firstReturn + 1) ⋯)) | null | false |
Finset.mul_prod_Ioo_eq_prod_Ico | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] {f : α → M} {a b : α} [inst_1 : PartialOrder α]
[inst_2 : LocallyFiniteOrder α], a < b → f a * ∏ x ∈ Finset.Ioo a b, f x = ∏ x ∈ Finset.Ico a b, f x | null | true |
Std.HashMap.Raw.getKey?_alter | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF →
(m.alter k f).getKey? k' =
if (k == k') = true then if (f m[k]?).isSome = true then some k else none else m.getKey? k' | null | true |
CFC.rpow_mul_rpow_neg | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] {a : A} (x : ℝ),
autoParam (IsStrictlyPositive a) CFC.rpow... | null | true |
_private.Std.Data.DTreeMap.Raw.Lemmas.0.Std.DTreeMap.Raw.Const.contains_of_contains_insertMany_list'._simp_1_1 | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Rat.lt_of_mul_lt_mul_left | Init.Data.Rat.Lemmas | ∀ {a b c : ℚ}, c * a < c * b → 0 ≤ c → a < b | null | true |
List.finIdxOf?_cons | Init.Data.List.Find | ∀ {α : Type u_1} {b : α} [inst : BEq α] {a : α} {xs : List α},
List.finIdxOf? b (a :: xs) =
if (a == b) = true then some ⟨0, ⋯⟩ else Option.map (fun x => x.succ) (List.finIdxOf? b xs) | null | true |
BitVec.sub_neg | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x - -y = x + y | null | true |
CategoryTheory.kleisliCatEquivKleisli._proof_7 | Mathlib.CategoryTheory.Monad.Types | ∀ (m : Type u_1 → Type u_1) [inst : Monad m] [inst_1 : LawfulMonad m] (X : CategoryTheory.KleisliCat m),
CategoryTheory.CategoryStruct.comp
({ obj := fun X => { of := X }, map := fun {X Y} f => { of := TypeCat.ofHom f }, map_id := ⋯, map_comp := ⋯ }.map
((CategoryTheory.NatIso.ofComponents (fun X => Cat... | null | false |
Ordinal.lift_natCast._f | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (x : ℕ) (f : Nat.below x), Ordinal.lift.{u, v} ↑x = ↑x | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_4 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
Lex.instSemigroup.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Semigroup α], Lex.instSemigroup = { toMul := Lex.instMul, mul_assoc := ⋯ } | null | true |
HasProd.congr_cofinite₀ | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {K : Type u_4} [inst : CommGroupWithZero K] [inst_1 : TopologicalSpace K] [SeparatelyContinuousMul K]
{f g : α → K} {c : K},
HasProd f c →
∀ {s : Finset α}, (∀ a ∈ s, f a ≠ 0) → (∀ a ∉ s, f a = g a) → HasProd g (c * ((∏ i ∈ s, g i) / ∏ i ∈ s, f i)) | null | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_iff_pair_subset.match_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u_1} {s : Set α} (motive : (∃ x y, x ≠ y ∧ {x, y} ⊆ s) → Prop) (H : ∃ x y, x ≠ y ∧ {x, y} ⊆ s),
(∀ (w w_1 : α) (hxy : w ≠ w_1) (h : {w, w_1} ⊆ s), motive ⋯) → motive H | null | false |
_private.Mathlib.Topology.Homotopy.LocallyContractible.0.instStronglyLocallyContractibleSpaceProd.match_9 | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (x : X) (y : Y) (Ux : Set X)
(Uy : Set Y)
(motive :
(match (x, y) with
| (x, y) =>
match (Ux, Uy) with
| (Ux, Uy) => (Ux ∈ nhds x ∧ ContractibleSpace ↑Ux) ∧ Uy ∈ nhds y ∧ ContractibleSpace ↑Uy) →
... | null | false |
_private.Mathlib.Order.CompleteLattice.Finset.0.Finset.iInf_insert_update._proof_1_1 | Mathlib.Order.CompleteLattice.Finset | ∀ {α : Type u_1} {x : α} (w : α), w = x → x = w | null | false |
Finite.Set.finite_range | Mathlib.Data.Set.Finite.Range | ∀ {α : Type u} {ι : Sort w} (f : ι → α) [Finite ι], Finite ↑(Set.range f) | null | true |
Submodule.smithNormalFormOfLE._proof_8 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_3} {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (b : Module.Basis ι R M)
(N O : Submodule R M) (N_le_O : N ≤ O),
∃ o,
∃ (hno : Classical.choose ⋯ ≤ o),
∃ bO bN a... | null | false |
Ordinal.card_iSup_le_lift | Mathlib.SetTheory.Cardinal.Ordinal | ∀ {ι : Type u} {c : Cardinal.{v}} {f : ι → Ordinal.{v}},
Cardinal.lift.{v, u} (Cardinal.mk ι) ≤ Cardinal.lift.{u, v} c → (∀ (i : ι), (f i).card ≤ c) → (⨆ i, f i).card ≤ c | null | true |
Array.countP_empty | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool}, Array.countP p #[] = 0 | null | true |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.isLimitFiniteSubproductsCone | Mathlib.CategoryTheory.Limits.Constructions.Filtered | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{α : Type w} →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
(f : α → C) →
[CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C] →
[inst_3 : CategoryTheory.Limits.HasProduct f] →
... | The cone `finiteSubproductsCone` is a limit cone. | true |
BoxIntegral.unitPartition.mem_prepartition_iff | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] [inst_1 : Fintype ι] {B I : BoxIntegral.Box ι},
I ∈ BoxIntegral.unitPartition.prepartition n B ↔
∃ ν ∈ BoxIntegral.unitPartition.admissibleIndex n B, BoxIntegral.unitPartition.box n ν = I | null | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.find?_le_findRev?._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ}, none ≤ none | null | false |
inner_conj_symm | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x y : E), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y | null | true |
Submonoid.isLocalizationMap_of_group | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {S : Submonoid M} {f : M → G},
Function.Injective f → (∀ (g : G), ∃ x, ∃ y ∈ S, g = f x / f y) → S.IsLocalizationMap f | null | true |
Multiset.map_univ_coe | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α), Multiset.map (fun x => x.fst) Finset.univ.val = m | null | true |
NumberField.InfinitePlace.IsRamified.ne_conjugate | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
{w₁ w₂ : NumberField.InfinitePlace K},
NumberField.InfinitePlace.IsRamified k w₂ → w₁.embedding ≠ NumberField.ComplexEmbedding.conjugate w₂.embedding | null | true |
Quotient.hrecOn | Init.Core | {α : Sort u} →
{s : Setoid α} →
{motive : Quotient s → Sort v} →
(q : Quotient s) → (f : (a : α) → motive ⟦a⟧) → (∀ (a b : α), a ≈ b → f a ≍ f b) → motive q | A dependent recursion principle for `Quotient` that uses [heterogeneous
equality](https://lean-lang.org/doc/reference/4.31.0/find/?domain=Verso.Genre.Manual.section&name=HEq), analogous to a [recursor](https://lean-lang.org/doc/reference/4.31.0/find/?domain=Verso.Genre.Manual.section&name=recursors) for
a structure.
`... | true |
Std.Http.Protocol.H1.Machine.failed | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Machine dir → Bool | Returns `true` if the reader is in a failed state.
| true |
CategoryTheory.Cat.opEquivalence._proof_4 | Mathlib.CategoryTheory.Category.Cat.Op | ∀ {X Y : CategoryTheory.Cat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Cat.opFunctor.comp CategoryTheory.Cat.opFunctor).map f)
{ hom := (CategoryTheory.unopUnop ↑Y).toCatHom, inv := (CategoryTheory.opOp ↑Y).toCatHom, hom_inv_id := ⋯,
inv_hom_id := ⋯ }.hom =
CategoryTheory.Ca... | null | false |
Mathlib.Tactic.BicategoryLike.Mor₁.tgt._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Obj | null | false |
SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso_hom_app | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ {X Y : SSet.Truncated 2}
(x : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge.tensor._proof_1 }))
(y : Y.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge.tensor._proof_1 })),
(SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso X Y).hom.app
... | null | true |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.qNF.sub._unary._proof_3 | Mathlib.Tactic.Module | ∀ {u v : Lean.Level} {M : Q(Type v)} {R : Q(Type u)} (a₁ : Q(«$R»)) (x₁ : Q(«$M»)) (k₁ : ℕ)
(t₁ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ) (a₂ : Q(«$R»)) (x₂ : Q(«$M»)) (k₂ : ℕ)
(t₂ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellF... | null | false |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.isBounded_iff_subset_ball.match_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : PseudoMetricSpace α] (c : α) (motive : (∃ r, s ⊆ Metric.ball c r) → Prop)
(x : ∃ r, s ⊆ Metric.ball c r), (∀ (_r : ℝ) (hr : s ⊆ Metric.ball c _r), motive ⋯) → motive x | null | false |
Nat.nth_apply_eq_orderIsoOfNat | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (hf : (setOf p).Infinite) (n : ℕ), Nat.nth p n = ↑((Nat.Subtype.orderIsoOfNat (setOf p)) n) | When `s` is an infinite set, `nth` agrees with `Nat.Subtype.orderIsoOfNat`. | true |
Lean.Grind.CommRing.Expr.intCast | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Expr | null | true |
_private.Mathlib.Data.Set.Function.0.Set.bijOn_singleton._simp_1_2 | Mathlib.Data.Set.Function | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Lean.Parser.Term.configItem.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Array.mkSlice_roi_eq_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Roo.Sliceable.mkSlice xs lo<...xs.size | null | true |
_private.Mathlib.Topology.Separation.Regular.0.SeparatedNhds.of_isCompact_isClosed._simp_1_2 | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [RegularSpace X] {x : X} {s : Set X},
Disjoint (nhds x) (nhdsSet s) = (x ∉ closure s) | null | false |
ProjectiveSpectrum | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] → [inst_2 : AddSubmonoidClass σ A] → (𝒜 : ℕ → σ) → [GradedRing 𝒜] → Type u_1 | The projective spectrum of a graded commutative ring is the subtype of all homogeneous ideals
that are prime and do not contain the irrelevant ideal. | true |
instRingWithIdealFilter._proof_46 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] (x : IdealFilter A),
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
ContinuousMap.abs_mem_subalgebra_closure | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : CompactSpace X] (A : Subalgebra ℝ C(X, ℝ)) (f : ↥A),
|↑f| ∈ A.topologicalClosure | null | true |
mdifferentiableAt_add_left | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : Add G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [ContMDiffAdd I 1 G] {... | null | true |
IsLprojection.instLatticeSubtypeOfFaithfulSMul | Mathlib.Analysis.Normed.Module.MStructure | {X : Type u_1} →
[inst : NormedAddCommGroup X] →
{M : Type u_2} → [inst_1 : Ring M] → [inst_2 : Module M X] → [FaithfulSMul M X] → Lattice { P // IsLprojection X P } | This instance was created as an auxiliary definition when defining `Subtype.distribLattice`
all at once would cause a timeout. That is no longer the case. Keeping this as a useful shortcut.
| true |
Nat.leRecOn_injective | Mathlib.Data.Nat.Basic | ∀ {C : ℕ → Sort u_1} {n m : ℕ} (hnm : n ≤ m) (next : {k : ℕ} → C k → C (k + 1)),
(∀ (n : ℕ), Function.Injective next) → Function.Injective (Nat.leRecOn hnm fun {k} => next) | null | true |
Ordnode.merge_nil_right | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (t : Ordnode α), Ordnode.nil.merge t = t | null | true |
Nat.Prime.dvd_choose_pow | Mathlib.Data.Nat.Multiplicity | ∀ {p n k : ℕ}, Nat.Prime p → k ≠ 0 → k ≠ p ^ n → p ∣ (p ^ n).choose k | null | true |
QuaternionAlgebra.Basis.casesOn | Mathlib.Algebra.QuaternionBasis | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring A] →
[inst_2 : Algebra R A] →
{c₁ c₂ c₃ : R} →
{motive : QuaternionAlgebra.Basis A c₁ c₂ c₃ → Sort u} →
(t : QuaternionAlgebra.Basis A c₁ c₂ c₃) →
((i j k : A) →
... | null | false |
Tactic.ComputeAsymptotics.UnitMonomial.toLogFun.eq_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ (m : Tactic.ComputeAsymptotics.UnitMonomial) (basis : Tactic.ComputeAsymptotics.Basis) (x : ℝ),
m.toLogFun basis x = (List.zipWith (fun exp b => exp * Real.log (b x)) m basis).sum | null | true |
EMetric.NonemptyCompacts.isClosed_in_closeds | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : EMetricSpace α] [CompleteSpace α],
IsClosed (Set.range TopologicalSpace.NonemptyCompacts.toCloseds) | **Alias** of `TopologicalSpace.NonemptyCompacts.isClosed_in_closeds`.
---
The range of `NonemptyCompacts.toCloseds` is closed in a complete space | true |
LinearMap.isNilpotent_mulRight_iff | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ (R : Type u_1) {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A),
IsNilpotent (LinearMap.mulRight R a) ↔ IsNilpotent a | null | true |
Equiv.toIso_hom | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (e : X ≃ Y) (x : X), (CategoryTheory.ConcreteCategory.hom e.toIso.hom) x = e x | **Alias** of `Equiv.toIso_hom_hom_apply`. | true |
_private.Mathlib.Data.Fin.Basic.0.Fin.cast_injective._simp_1_1 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} (a b : Fin n), (a = b) = (↑a = ↑b) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_insert_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lean.Sym.ite_true | Init.Sym.Lemmas | ∀ {α : Sort u} (c : Prop) {inst : Decidable c} (a b : α) {ht : c}, (if c then a else b) = a | null | true |
Fin.instMax_mathlib._proof_1 | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (x y : Fin n), max ↑x ↑y < n | null | false |
Lean.Language.Lean.CommandParsedSnapshot.below_1 | Lean.Language.Lean.Types | {motive_1 : Lean.Language.Lean.CommandParsedSnapshot → Sort u} →
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort u} →
{motive_3 : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot → Sort u} →
{motive_4 : Task Lean.Language.Lean.CommandParsedS... | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq.0.Lean.Meta.Grind.Arith.Linear.updateDiseqs.match_3 | Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq | (motive :
Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr × Array (ℤ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) →
Sort u_1) →
(x : Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr × Array (ℤ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr)) →
((diseqs' : Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCn... | null | false |
AlgHom.FinitePresentation.of_finiteType | Mathlib.RingTheory.FinitePresentation | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [IsNoetherianRing A] {f : A →ₐ[R] B},
f.FiniteType ↔ f.FinitePresentation | null | true |
TensorProduct.finsuppLeft._proof_1 | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [IsScalarTower R S M] (ι : Type u_4),
SMulCommClass R S (ι →₀ M) | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRupUnits._proof_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (li : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), ↑li < n | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne_preserves_strongAssignmentsInvariant.match_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) → Prop)
(x : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)),
(x = none → motive none) →
(∀ (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n), x = some c → motive (some c)) → motive x | null | false |
rieszContentAux_image_nonempty | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (Λ : CompactlySupportedContinuousMap X NNReal →ₗ[NNReal] NNReal)
[T2Space X] [LocallyCompactSpace X] (K : TopologicalSpace.Compacts X), (⇑Λ '' {f | ∀ x ∈ K, 1 ≤ f x}).Nonempty | For any compact subset `K ⊆ X`, there exist some compactly supported continuous nonnegative
functions `f` on `X` such that `f ≥ 1` on `K`. | true |
MeasureTheory.measure_preimage_add_right | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddRightInvariant] (g : G) (A : Set G), μ ((fun h => h + g) ⁻¹' A) = μ A | null | true |
Finset.orderIsoOfFin._proof_4 | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α) {k : ℕ}, s.card = k → k = (s.sort fun x1 x2 => x1 ≤ x2).length | null | false |
Lean.Meta.AbstractNestedProofs.Context | Lean.Meta.AbstractNestedProofs | Type | null | true |
LinearMap.IsPerfPair.restrictScalars_of_field | Mathlib.LinearAlgebra.PerfectPairing.Restrict | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module L M] [inst_6 : Module L N] [inst_7 : Module K M]
[inst_8 : Module K N] [inst_9 : IsScalarTower K L M] (p : M →ₗ[L] N →ₗ[L] L) ... | Simultaneously restrict both the domains and scalars of a perfect pairing with coefficients in a
field. | true |
MeasurableSpace.monotone_map | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Monotone (MeasurableSpace.map f) | null | true |
CategoryTheory.MorphismProperty.shiftLocalizerMorphism | Mathlib.CategoryTheory.Shift.Localization | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(W : CategoryTheory.MorphismProperty C) →
{A : Type w} →
[inst_1 : AddMonoid A] →
[inst_2 : CategoryTheory.HasShift C A] →
[W.IsCompatibleWithShift A] → A → CategoryTheory.LocalizerMorphism W W | The morphism of localizer from `W` to `W` given by the functor `shiftFunctor C a`
when `a : A` and `W` is compatible with the shift by `A`. | true |
groupCohomologyIsoExt | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) →
(n : ℕ) → groupCohomology A n ≅ ((Ext k (Rep.{u, u, u} k G) n).obj (Opposite.op (Rep.trivial k G k))).obj A | The `n`th group cohomology of a `k`-linear `G`-representation `A` is isomorphic to
`Extⁿ(k, A)` (taken in `Rep k G`), where `k` is a trivial `k`-linear `G`-representation. | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.mem_zpowers_zpow_iff._simp_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {n : ℕ}, (n = 1) = (n ∣ 1) | null | false |
SSet.stdSimplex.objMk₁._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplexOne | ∀ {n : ℕ} (i : Fin (n + 2)) (j₁ j₂ : Fin ((Opposite.unop (Opposite.op { len := n })).len + 1)),
j₁ ≤ j₂ → (fun j => if j.castSucc < i then 0 else 1) j₁ ≤ (fun j => if j.castSucc < i then 0 else 1) j₂ | null | false |
Std.ExtTreeMap.maxKey.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeMap α β cmp)
(e_t : t = t_1) (h : t ≠ ∅), t.maxKey h = t_1.maxKey ⋯ | null | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.Mk₁.map_id.match_1_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ (motive : Fin 2 → Prop) (i : Fin 2), (∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → motive i | null | false |
Aesop.Frontend.Parser.featIdent | Aesop.Frontend.RuleExpr | Lean.ParserDescr | null | true |
Lean.Order.instCCPOSTOfNonempty._proof_1 | Init.Internal.Order.MonadTail | ∀ {σ : Type} (s : Void σ), Nonempty (Void σ) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.