name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
IsLeftRegular.mul_left_eq_zero_iff | Mathlib.Algebra.GroupWithZero.Regular | ∀ {R : Type u_1} [inst : MulZeroClass R] {a b : R}, IsLeftRegular b → (b * a = 0 ↔ a = 0) | null | true |
FreeGroup.lift._proof_1 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Group β] (f : α → β) (a b : FreeGroup α),
Quot.lift (FreeGroup.Lift.aux f) ⋯ (a * b) =
Quot.lift (FreeGroup.Lift.aux f) ⋯ a * Quot.lift (FreeGroup.Lift.aux f) ⋯ b | null | false |
Sym2.coe_lift₂_symm_apply | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (F : Sym2 α → Sym2 β → γ) (a₁ a₂ : α) (b₁ b₂ : β),
↑(Sym2.lift₂.symm F) a₁ a₂ b₁ b₂ = F s(a₁, a₂) s(b₁, b₂) | null | true |
Complex.instNNRatCast | Mathlib.Basic.Complex.Basic | NNRatCast ℂ | null | true |
Booleanisation.instSemilatticeSup | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → SemilatticeSup (Booleanisation α) | null | true |
LocallyFiniteOrder.mk.noConfusion | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
{inst : Preorder α} →
{P : Sort u} →
{finsetIcc finsetIco finsetIoc finsetIoo : α → α → Finset α} →
{finset_mem_Icc : ∀ (a b x : α), x ∈ finsetIcc a b ↔ a ≤ x ∧ x ≤ b} →
{finset_mem_Ico : ∀ (a b x : α), x ∈ finsetIco a b ↔ a ≤ x ∧ x < b} →
{finset_mem_Ioc : ∀ (... | null | false |
GradedMonoid.GradeZero.monoid._proof_3 | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} (A : ι → Type u_2) [inst : AddMonoid ι] [inst_1 : GradedMonoid.GMonoid A] (a b : A 0),
GradedMonoid.mk 0 (a • b) = GradedMonoid.mk 0 a * GradedMonoid.mk 0 b | null | false |
Metric.Snowflaking.image_toSnowflaking_closedEBall | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : PseudoEMetricSpace X] (x : X) (r : ENNReal),
⇑Metric.Snowflaking.toSnowflaking '' Metric.closedEBall x r =
Metric.closedEBall (Metric.Snowflaking.toSnowflaking x) (r ^ α) | null | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.Fintype.linearIndependent_iff'._simp_1_3 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
Inclusion.InclusionExt.derive | Mathlib.Tactic.Inclusion.Core.Extensions | Inclusion.InclusionExt → Lean.Expr → Inclusion.InclusionM Inclusion.ExprInclusionBody | Attempt to construct an `ExprInclusionBody` for `e`. | true |
Polynomial.evalEval_multiset_prod | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (l : Multiset (Polynomial (Polynomial R))),
Polynomial.evalEval x y l.prod = (Multiset.map (Polynomial.evalEval x y) l).prod | null | true |
«term_++_» | Init.Notation | Lean.TrailingParserDescr | `a ++ b` is the result of concatenation of `a` and `b`, usually read "append".
The meaning of this notation is type-dependent.
Conventions for notations in identifiers:
* The recommended spelling of `++` in identifiers is `append`. | true |
MeasureTheory.Measure.hausdorffMeasure_mono | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] {d₁ d₂ : ℝ},
d₁ ≤ d₂ → ∀ (s : Set X), (MeasureTheory.Measure.hausdorffMeasure d₂) s ≤ (MeasureTheory.Measure.hausdorffMeasure d₁) s | Hausdorff measure `μH[d] s` is monotone in `d`. | true |
Finmap.mk.injEq | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} (entries : Multiset (Sigma β)) (nodupKeys : entries.NodupKeys)
(entries_1 : Multiset (Sigma β)) (nodupKeys_1 : entries_1.NodupKeys),
({ entries := entries, nodupKeys := nodupKeys } = { entries := entries_1, nodupKeys := nodupKeys_1 }) =
(entries = entries_1) | null | true |
_private.Mathlib.CategoryTheory.ConnectedComponents.0.CategoryTheory.instIsConnectedComponent._proof_5 | Mathlib.CategoryTheory.ConnectedComponents | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (j₁ j₂ : J)
(hj₁ : CategoryTheory.ConnectedComponents.objectProperty (Quotient.mk'' j₂) j₁) (l : List J)
(hf : ∀ a ∈ l, CategoryTheory.Zigzag a j₂),
({ obj := j₁, property := ⋯ } :: List.pmap (fun x h => { obj := x, property := ⋯ }) l ⋯).length - 1 <
... | null | false |
Homeomorph.subLeft._proof_1 | Mathlib.Topology.Algebra.Group.ContinuousDiv | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] (x : G),
Continuous (Equiv.subLeft x).toFun | null | false |
_private.Mathlib.Analysis.Normed.Module.Ball.Pointwise.0.cthickening_thickening._simp_1_1 | Mathlib.Analysis.Normed.Module.Ball.Pointwise | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {δ : ℝ} {s : Set α} {x : α},
(x ∈ Metric.cthickening δ s) = (Metric.infEDist x s ≤ ENNReal.ofReal δ) | null | false |
Derivative.normalizedDerivOfComplex_E₂ | Mathlib.NumberTheory.ModularForms.RamanujanFormula | Derivative.normalizedDerivOfComplex EisensteinSeries.E2 = 12⁻¹ • (EisensteinSeries.E2 ^ 2 - ⇑ModularForm.E₄) | **Ramanujan's formula for `E₂`**: `D E₂ = (E₂² - E₄) / 12`. | true |
SimpleGraph.completeEquipartiteGraph_adj | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {r t : ℕ} {v w : Fin r × Fin t}, (SimpleGraph.completeEquipartiteGraph r t).Adj v w ↔ v.1 ≠ w.1 | null | true |
SimpleGraph.TripartiteFromTriangles.cliqueFinset_eq_image | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (t : Finset (α × β × γ)) [inst : DecidableEq α] [inst_1 : DecidableEq β]
[inst_2 : DecidableEq γ] [inst_3 : Fintype α] [inst_4 : Fintype β] [inst_5 : Fintype γ]
[SimpleGraph.TripartiteFromTriangles.NoAccidental t],
(SimpleGraph.TripartiteFromTriangles.graph t).clique... | null | true |
SemimoduleCat.Hom.mk | Mathlib.Algebra.Category.ModuleCat.Semi | {R : Type u} → [inst : Semiring R] → {M N : SemimoduleCat R} → (↑M →ₗ[R] ↑N) → M.Hom N | null | true |
CategoryTheory.MorphismProperty.isLeftAdjoint_pushout | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P : CategoryTheory.MorphismProperty T) {X Y : T}
[P.IsStableUnderComposition] (f : X ⟶ Y) [inst_2 : P.HasPushoutsAlong f]
[inst_3 : P.IsStableUnderCobaseChangeAlong f],
P f → (CategoryTheory.MorphismProperty.Under.pushout P ⊤ f).IsLeftAdjoint | null | true |
Pullback.continuous_proj | Mathlib.Topology.FiberBundle.Constructions | ∀ {B : Type u} (F : Type v) (E : B → Type w₁) {B' : Type w₂} [inst : TopologicalSpace B']
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] (f : B' → B), Continuous Bundle.TotalSpace.proj | null | true |
Lean.JsonRpc.ErrorCode.noConfusionType | Lean.Data.JsonRpc | Sort v✝ → Lean.JsonRpc.ErrorCode → Lean.JsonRpc.ErrorCode → Sort v✝ | null | true |
WithVal.ofVal_eq_zero._simp_1 | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_1} {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : Ring R] (v : Valuation R Γ₀)
(x : WithVal v), (x.ofVal = 0) = (x = 0) | null | false |
Lean.LibrarySuggestions.Config.mk.injEq | Lean.LibrarySuggestions.Basic | ∀ (maxSuggestions : ℕ) (caller : Option String) (filter : Lean.Name → Lean.MetaM Bool) (hint : Option String)
(maxSuggestions_1 : ℕ) (caller_1 : Option String) (filter_1 : Lean.Name → Lean.MetaM Bool) (hint_1 : Option String),
({ maxSuggestions := maxSuggestions, caller := caller, filter := filter, hint := hint } =... | null | true |
CategoryTheory.Limits.limitOfTerminal | Mathlib.CategoryTheory.Limits.Shapes.Terminal | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} J] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasTerminal J] →
[inst_3 : ∀ (i j : J) (f : i ⟶ j), CategoryTheory.IsIso (F.map f)] →
... | For a functor `F : J ⥤ C`, if `J` has a terminal object and all the morphisms in the diagram
are isomorphisms, then the image of the terminal object is isomorphic to the limit of `F`. | true |
TestFunction.postcompCLM._proof_4 | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_3} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {F' : Type u_2} [inst_6 : NormedAddCommGroup F']
[ins... | null | false |
Set.forall_inv_mem._simp_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : InvolutiveInv α] {s : Set α} {p : α → Prop}, (∀ (x : α), x⁻¹ ∈ s → p x) = ∀ x ∈ s, p x⁻¹ | null | false |
Std.Http.instBEqURI.beq | Std.Http.Data.URI.Basic | Std.Http.URI → Std.Http.URI → Bool | null | true |
Submonoid.subtype._proof_2 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (S : Submonoid M), ↑1 = ↑1 | null | false |
_private.Batteries.Data.Fin.Coding.0.Fin.encodeChar.eq_1 | Batteries.Data.Fin.Coding | ∀ (c : Char),
Fin.encodeChar c =
if x : c.toNat < Char.minSurrogate then ⟨c.toNat, ⋯⟩ else ⟨c.toNat - (Char.maxSurrogate + 1 - Char.minSurrogate), ⋯⟩ | null | true |
Std.Sat.CNF.Clause.Internal.size_eq_size_atoms | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {c : Std.Sat.CNF.Clause α}, c.size = c.atoms.size | null | true |
Std.Do.EStateM.instWP | Std.Do.WP.Basic | {ε σ : Type u_1} → Std.Do.WP (EStateM ε σ) (Std.Do.PostShape.except ε (Std.Do.PostShape.arg σ Std.Do.PostShape.pure)) | null | true |
_private.Mathlib.Topology.Order.Priestley.0.exists_isClopen_lower_of_not_le.match_1_1 | Mathlib.Topology.Order.Priestley | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : Preorder α] {x y : α}
(motive : (∃ U, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U) → Prop)
(x_1 : ∃ U, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U),
(∀ (U : Set α) (hU : IsClopen U) (hU' : IsUpperSet U) (hx : x ∈ U) (hy : y ∉ U), motive ⋯) → motive x_1 | null | false |
ENormSMulClass.recOn | Mathlib.Analysis.Normed.MulAction | {α : Type u_3} →
{β : Type u_4} →
[inst : ENorm α] →
[inst_1 : ENorm β] →
[inst_2 : SMul α β] →
{motive : ENormSMulClass α β → Sort u} →
(t : ENormSMulClass α β) → ((enorm_smul : ∀ (r : α) (x : β), ‖r • x‖ₑ = ‖r‖ₑ * ‖x‖ₑ) → motive ⋯) → motive t | null | false |
CategoryTheory.OverClass.rec | Mathlib.CategoryTheory.Comma.Over.OverClass | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X S : C} →
{motive : CategoryTheory.OverClass X S → Sort u_1} →
((hom : X ⟶ S) → motive { hom := hom }) → (t : CategoryTheory.OverClass X S) → motive t | null | false |
linter.tacticAnalysis.dummy | Mathlib.Tactic.TacticAnalysis | Lean.Option Bool | A dummy option for testing the tactic analysis framework | true |
Matroid.Indep.not_dep | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.Indep I → ¬M.Dep I | null | true |
Topology.RelCWComplex.Subcomplex.copy._proof_2 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D]
(E : Topology.RelCWComplex.Subcomplex C) (F : Set X),
F = ↑E →
∀ (J : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)),
J = E.I → D ∪ ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = F | null | false |
SimpleGraph.cycleGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.CycleGraph | ∀ (n : ℕ), NeZero (n + 2) | null | false |
Lean.Elab.Tactic.hasErrorMessages | Lean.Elab.Tactic.Basic | List Lean.Message → Bool | Check if any messages in the list are errors. | true |
CategoryTheory.Idempotents.Karoubi.ext | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q : CategoryTheory.Idempotents.Karoubi C}
(h_X : P.X = Q.X),
CategoryTheory.CategoryStruct.comp P.p (CategoryTheory.eqToHom h_X) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom h_X) Q.p →
P = Q | null | true |
ultrafilter_comap_pure_nhds | Mathlib.Topology.Compactification.StoneCech | ∀ {α : Type u} (b : Ultrafilter α), Filter.comap pure (nhds b) ≤ ↑b | null | true |
CategoryTheory.ShortComplex.Hom.comm₂₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (self : S₁.Hom S₂),
CategoryTheory.CategoryStruct.comp self.τ₂ S₂.g = CategoryTheory.CategoryStruct.comp S₁.g self.τ₃ | the right commutative square of a morphism in `ShortComplex` | true |
MonoidAlgebra.support_coeff_mul_subset | Mathlib.Algebra.MonoidAlgebra.Support | ∀ {k : Type u₁} {G : Type u₂} [inst : Semiring k] [inst_1 : Mul G] [inst_2 : DecidableEq G] (x y : MonoidAlgebra k G),
(x * y).coeff.support ⊆ x.coeff.support * y.coeff.support | null | true |
Inclusion.InclusionConfig.families._default | Mathlib.Tactic.Inclusion.Core.Core | Array Lean.Name | null | false |
Nat.Partition.partitionWithPartEquiv_apply_parts | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ {n a : ℕ} (ha1 : 1 ≤ a) (ha : a ≤ n) (p : { p // a ∈ p.parts }),
((Nat.Partition.partitionWithPartEquiv ha1 ha) p).parts = (↑p).parts.erase a | null | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.uniformity_aux | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : (i : ι) → PseudoEMetricSpace (β i)]
[inst_2 : Fintype ι], uniformity (PiLp p β) = uniformity (WithLp p ((i : ι) → β i)) | null | true |
Std.DTreeMap.Raw.Equiv.diff_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
{t₃ : Std.DTreeMap.Raw α β cmp}, t₁.WF → t₂.WF → t₃.WF → t₁.Equiv t₂ → (t₁ \ t₃).Equiv (t₂ \ t₃) | null | true |
CategoryTheory.IsGrothendieckAbelian.rec | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{motive : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C → Sort u_1} →
((locallySmall : CategoryTheory.LocallySmall.{w, v, u} C) →
(hasFilteredColimitsOfSize : CategoryTheory.Limits.HasFilt... | null | false |
HomotopicalAlgebra.PrepathObject.p₀ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {A : C} → (self : HomotopicalAlgebra.PrepathObject A) → self.P ⟶ A | the first "projection" from the (pre)path object | true |
MvPolynomial.mem_supported | Mathlib.Algebra.MvPolynomial.Supported | ∀ {σ : Type u_1} {R : Type u} [inst : CommSemiring R] {p : MvPolynomial σ R} {s : Set σ},
p ∈ MvPolynomial.supported R s ↔ ↑p.vars ⊆ s | null | true |
CFC.norm_star_mul_mul_self_of_nonneg._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Isometric | Lean.Syntax | null | false |
CompletelyPositiveMapClass | Mathlib.Analysis.CStarAlgebra.CompletelyPositiveMap | (F : Type u_1) →
(A₁ : Type u_2) →
(A₂ : Type u_3) →
[inst : NonUnitalCStarAlgebra A₁] →
[inst_1 : NonUnitalCStarAlgebra A₂] →
[inst_2 : PartialOrder A₁] →
[inst_3 : PartialOrder A₂] → [StarOrderedRing A₁] → [StarOrderedRing A₂] → [FunLike F A₁ A₂] → Prop | A linear map `φ : A₁ →ₗ[ℂ] A₂` is called *completely positive (CP)* if
`CStarMatrix.mapₗ (Fin k) (Fin k) φ` (i.e. applying `φ` to all entries of a k × k matrix) is also
positive for every `k ∈ ℕ`.
Note that `Fin k` here is hardcoded to avoid having to quantify over types and introduce a new
universe parameter. See `C... | true |
isAddUnit_zero | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M], IsAddUnit 0 | null | true |
CategoryTheory.Pi.opLaxMonoidalPi'._proof_6 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : (i : I) → CategoryTheory.Functor D (C i)) [ins... | null | false |
CategoryTheory.MorphismProperty.colimitsOfShape_le_of_final | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) {J : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] {J' : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} J']
(F : CategoryTheory.Functor J J') [F.Final], W.colimitsOfShape J' ≤ W.colimitsOfShape J | null | true |
_private.Mathlib.Algebra.Polynomial.Monic.0.Polynomial.Monic.nextCoeff_multiset_prod._simp_1_5 | Mathlib.Algebra.Polynomial.Monic | ∀ {α : Sort u_1}, (∀ (a : α), True) = True | null | false |
FiniteField.frobeniusAlgEquiv_apply | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) (R : Type u_2) [inst : Field K] [inst_1 : Fintype K] [inst_2 : CommRing R] [inst_3 : Algebra K R]
(p : ℕ) [inst_4 : ExpChar R p] [inst_5 : PerfectRing R p] (a : R),
(FiniteField.frobeniusAlgEquiv K R p) a = a ^ Fintype.card K | null | true |
Std.Iterators.Types.Flatten.rec | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} →
{m : Type w → Type u_1} →
{motive : Std.Iterators.Types.Flatten α α₂ β m → Sort u} →
((it₁ : Std.IterM m (Std.IterM m β)) → (it₂ : Option (Std.IterM m β)) → motive { it₁ := it₁, it₂ := it₂ }) →
(t : Std.Iterators.Types.Flatten α α₂ β m) → motive t | null | false |
Lake.instOrdSemVerCore.ord | Lake.Util.Version | Lake.SemVerCore → Lake.SemVerCore → Ordering | null | true |
NumberField.Units.fun_eq_repr | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {x ζ : (NumberField.RingOfIntegers K)ˣ}
{f : Fin (NumberField.Units.rank K) → ℤ},
ζ ∈ NumberField.Units.torsion K →
x = ζ * ∏ i, NumberField.Units.fundSystem K i ^ f i →
f = ⇑((NumberField.Units.basisModTorsion K).repr (Additive.ofMul ↑x)) | The exponents that appear in the unique decomposition of a unit as the product of
a root of unity and powers of the units of the fundamental system `fundSystem` (see
`exist_unique_eq_mul_prod`) are given by the representation of the unit on `basisModTorsion`. | true |
_private.Mathlib.Data.Finset.Union.0.Finset.mem_biUnion._simp_1_2 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.dedup) = (a ∈ s) | null | false |
CategoryTheory.Equivalence.trans | Mathlib.CategoryTheory.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} → [inst_2 : CategoryTheory.Category.{v₃, u₃} E] → (C ≌ D) → (D ≌ E) → (C ≌ E) | Equivalence of categories is transitive. | true |
HurwitzZeta.completedHurwitzZetaOdd.eq_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (s : ℂ),
HurwitzZeta.completedHurwitzZetaOdd a s = (HurwitzZeta.hurwitzOddFEPair a).Λ ((s + 1) / 2) / 2 | null | true |
isAddUnit_iff_eq_zero._simp_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a : M} [Subsingleton (AddUnits M)], IsAddUnit a = (a = 0) | null | false |
Lean.Parser.Tactic.omega | Init.Tactics | Lean.ParserDescr | The `omega` tactic, for resolving integer and natural linear arithmetic problems.
It is not yet a full decision procedure (no "dark" or "grey" shadows),
but should be effective on many problems.
We handle hypotheses of the form `x = y`, `x < y`, `x ≤ y`, and `k ∣ x` for `x y` in `Nat` or `Int`
(and `k` a literal), al... | true |
Manifold.IsImmersionAt.congr_of_eventuallyEq | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] {H : Type u_7}
[inst_5 : TopologicalSpace H] {G : Type u_9} [inst_6 : TopologicalSpace G] {I : ModelWithCorn... | If `f` is an immersion at `x` and `g = f` on some neighbourhood of `x`,
then `g` is an immersion at `x`. | true |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaEven.0.HurwitzZeta.cosZeta_one_sub._simp_1_2 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
log_riemannZeta_eq_neg_log_sub_add_ofReal | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {s : ℝ}, s > 1 → Real.log (riemannZeta ↑s).re = -Real.log (s - 1) + Real.log (riemannZeta₁ ↑s).re | null | true |
PontryaginDual.instCommGroup | Mathlib.Topology.Algebra.PontryaginDual | {A : Type u_1} → [inst : Monoid A] → [inst_1 : TopologicalSpace A] → CommGroup (PontryaginDual A) | null | true |
CategoryTheory.Functor.shiftMap_comp | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} A] (F : CategoryTheory.Functor C A) {M : Type u_4} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : F.ShiftSequence M] {X Y Z : C} {n : M}
(f : X ⟶ (CategoryTheory.shif... | null | true |
_private.Mathlib.Dynamics.OmegaLimit.0.Flow.omegaLimit_image_subset._simp_1_1 | Mathlib.Dynamics.OmegaLimit | ∀ {τ : Type u_1} {α : Type u_2} [inst : TopologicalSpace τ] [inst_1 : TopologicalSpace α] [inst_2 : AddZero τ]
(ϕ : Flow τ α) (t₁ t₂ : τ) (x : α), ϕ.toFun t₁ (ϕ.toFun t₂ x) = ϕ.toFun (t₁ + t₂) x | null | false |
Ultrafilter.semigroup._proof_1 | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] (U V W : Ultrafilter M), U * V * W = U * (V * W) | null | false |
LocallyFinite.Realizer.mk.inj | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} {β : Type u_2} {inst : TopologicalSpace α} {F : Ctop.Realizer α} {f : β → Set α}
{bas : (a : α) → { s // a ∈ F.F.f s }} {sets : (x : α) → Fintype ↑{i | (f i ∩ F.F.f ↑(bas x)).Nonempty}}
{bas_1 : (a : α) → { s // a ∈ F.F.f s }} {sets_1 : (x : α) → Fintype ↑{i | (f i ∩ F.F.f ↑(bas_1 x)).Nonempty}},
... | null | true |
CategoryTheory.ShortComplex.Hom.noConfusion | Mathlib.Algebra.Homology.ShortComplex.Basic | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{t : S₁.Hom S₂} →
{C' : Type u_1} →
{inst' : CategoryTheory.Category.{v_1, u_1} C'} →
... | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt8.reduceAdd.declare_20._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2231631932._hygCtx._hyg.42 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
_private.Mathlib.Analysis.Complex.BorelCaratheodory.0.Complex.eq_mul_div_one_add_of_eq_div_sub._simp_1_7 | Mathlib.Analysis.Complex.BorelCaratheodory | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
OreLocalization.left_distrib | Mathlib.RingTheory.OreLocalization.Ring | ∀ {R : Type u_1} [inst : Semiring R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(x y z : OreLocalization S R), x * (y + z) = x * y + x * z | null | true |
Nat.multichoose_zero_succ | Mathlib.Data.Nat.Choose.Basic | ∀ (k : ℕ), Nat.multichoose 0 (k + 1) = 0 | null | true |
Finite.of_subsingleton | Mathlib.Data.Fintype.EquivFin | ∀ {α : Sort u_3} [Subsingleton α], Finite α | null | true |
ULift.normedAddCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], AddMonoidHomClass (ULift.{u_2, u_1} E →+ E) (ULift.{u_2, u_1} E) E | null | false |
MeasurableSpace.DynkinSystem.instPartialOrder._proof_4 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} (x x_1 : MeasurableSpace.DynkinSystem α), x ≤ x_1 → x_1 ≤ x → x = x_1 | null | false |
IsLocalization.ringEquivOfRingEquiv._proof_2 | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_4} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_1) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] {P : Type u_3} [inst_3 : CommSemiring P] [inst_4 : IsLocalization M S] {T : Submonoid P}
(Q : Type u_2) [inst_5 : CommSemiring Q] [inst_6 : Algebra P Q] [inst_7 : IsLocalization T Q] (h : R ≃+*... | null | false |
Lean.Elab.Command.ElabHeaderResult | Lean.Elab.MutualInductive | Type | The elaborated header with the `indFVar` registered for this inductive type. | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.reduceStep._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
(Nat.hasNotBit 256 t.ctorIdx → motive t) → motive t | null | false |
singleton_sub_closedBall_zero | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (δ : ℝ) (x : E), {x} - Metric.closedBall 0 δ = Metric.closedBall x δ | null | true |
CochainComplex.ConnectData.restrictionLEIso | Mathlib.Algebra.Homology.Embedding.Connect | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{K : ChainComplex C ℕ} →
{L : CochainComplex C ℕ} →
(h : CochainComplex.ConnectData K L) →
HomologicalComplex.restriction h.cochainComplex (ComplexShape.embeddingUpI... | If `h : ConnectData K L`, then `h.cochainComplex` identifies to `K` in degrees `≤ -1`. | true |
FirstOrder.Language.Functions.apply₂.eq_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u'} (f : L.Functions 2) (t₁ t₂ : L.Term α),
f.apply₂ t₁ t₂ = FirstOrder.Language.func f ![t₁, t₂] | null | true |
CategoryTheory.Center.Hom.rec | Mathlib.CategoryTheory.Monoidal.Center | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : CategoryTheory.Center C} →
{motive : X.Hom Y → Sort u} →
((f : X.fst ⟶ Y.fst) →
(comm :
∀ (U : C),
CategoryTheory.Category... | null | false |
Fin.finsetImage_val_Ioi | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (a : Fin n), Finset.image Fin.val (Finset.Ioi a) = Finset.Ioo (↑a) n | null | true |
Std.ExtHashSet.get!_union_of_not_mem_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : Inhabited α] [inst_1 : EquivBEq α]
[inst_2 : LawfulHashable α] {k : α}, k ∉ m₁ → (m₁ ∪ m₂).get! k = m₂.get! k | null | true |
List.isChain_map_of_isChain | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {β : Type u_2} {R : α → α → Prop} {S : β → β → Prop} (f : α → β),
(∀ (a b : α), R a b → S (f a) (f b)) → ∀ {l : List α}, List.IsChain R l → List.IsChain S (List.map f l) | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.Equiv.0.MvPowerSeries.truncTotal_sub_truncTotal_mem_pow_idealOfVars._proof_1_1 | Mathlib.RingTheory.MvPowerSeries.Equiv | ∀ {σ : Type u_1} {l m : ℕ}, l ≤ m → ∀ (x : σ →₀ ℕ), Finsupp.degree x < l → Finsupp.degree x < m | null | false |
AddMonoidAlgebra.uniqueLinearEquiv._proof_3 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {S : Type u_1} (M : Type u_2) [inst : Semiring S] [inst_1 : Zero M] [inst_2 : Subsingleton M],
Function.LeftInverse (AddMonoidAlgebra.coeffAddEquiv.trans (Finsupp.uniqueAddEquiv 0)).invFun
(AddMonoidAlgebra.coeffAddEquiv.trans (Finsupp.uniqueAddEquiv 0)).toFun | null | false |
Matrix.single_add | Mathlib.Data.Matrix.Basis | ∀ {m : Type u_2} {n : Type u_3} {α : Type u_7} [inst : DecidableEq m] [inst_1 : DecidableEq n] [inst_2 : AddZeroClass α]
(i : m) (j : n) (a b : α), Matrix.single i j (a + b) = Matrix.single i j a + Matrix.single i j b | null | true |
LeanSearchClient.SearchServer.queryNum | LeanSearchClient.Syntax | LeanSearchClient.SearchServer → Lean.CoreM ℕ | null | true |
CategoryTheory.SimplicialObject.Splitting.IndexSet.fac_pull | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {Δ : SimplexCategoryᵒᵖ} (A : CategoryTheory.SimplicialObject.Splitting.IndexSet Δ) {Δ' : SimplexCategoryᵒᵖ}
(θ : Δ ⟶ Δ'),
CategoryTheory.CategoryStruct.comp (A.pull θ).e
(CategoryTheory.Limits.image.ι (CategoryTheory.CategoryStruct.comp θ.unop A.e)) =
CategoryTheory.CategoryStruct.comp θ.unop A.e | null | true |
CategoryTheory.Limits.isColimitOfHasCokernelOfPreservesColimit.congr_simp | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(G : CategoryTheory.Functor C D) [inst_4 : G.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.