name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
orthonormal_vecCons_iff | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{n : ℕ} {v : E} {vs : Fin n → E},
Orthonormal 𝕜 (Matrix.vecCons v vs) ↔ ‖v‖ = 1 ∧ (∀ (i : Fin n), inner 𝕜 v (vs i) = 0) ∧ Orthonormal 𝕜 vs | null | true |
Subsemiring.sumSq._proof_4 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ (T : Type u_1) [inst : CommSemiring T], 0 ∈ (NonUnitalSubsemiring.sumSq T).carrier | null | false |
Prod.isRegular_mk._simp_2 | Mathlib.Algebra.Regular.Prod | ∀ {R : Type u_2} {S : Type u_3} [inst : Mul R] [inst_1 : Mul S] {a : R} {b : S},
IsRegular (a, b) = (IsRegular a ∧ IsRegular b) | null | false |
SimpleGraph.Walk.IsHamiltonianCycle.mk | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.IsCycle → p.tail.IsHamiltonian → p.IsHamiltonianCycle | null | true |
CategoryTheory.Functor.CoreMonoidal.ofOplaxMonoidal._proof_6 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal]
[inst_5 : CategoryTheory.IsIso (Catego... | null | false |
_private.Lean.Meta.Tactic.Cases.0.Lean.Meta.Cases.unifyEqs?.match_1 | Lean.Meta.Tactic.Cases | (motive : Option Lean.Meta.UnifyEqResult → Sort u_1) →
(__do_lift : Option Lean.Meta.UnifyEqResult) →
((mvarId : Lean.MVarId) →
(subst : Lean.Meta.FVarSubst) →
(numNewEqs : ℕ) → motive (some { mvarId := mvarId, subst := subst, numNewEqs := numNewEqs })) →
((x : Option Lean.Meta.UnifyEqResu... | null | false |
Prod.edist_eq | Mathlib.Topology.EMetricSpace.Defs | ∀ {β : Type v} {α : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (x y : α × β),
edist x y = max (edist x.1 y.1) (edist x.2 y.2) | null | true |
CategoryTheory.Limits.IsLimit.ofPointIso | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{r t : CategoryTheory.Limits.Cone F} →
(P : CategoryTheory.Limits.IsLimit r) →
[i : CategoryTheory.IsIs... | If the canonical morphism from a cone point to a limiting cone point is an iso, then the
first cone was limiting also.
| true |
instDistribOfSemiring | Mathlib.Algebra.Ring.Defs | {α : Type u} → [Semiring α] → Distrib α | null | true |
MultilinearMap.ext_iff | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {ι : Type uι} {M₁ : ι → Type v₁} {M₂ : Type v₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] {f f' : MultilinearMap R M₁ M₂}, f = f' ↔ ∀ (x : (i : ι) → M₁ i), f x = f' x | null | true |
ProofWidgets.instRpcEncodableGetExprPresentationParams.dec._@.ProofWidgets.Presentation.Expr.4203983209._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) ProofWidgets.GetExprPresentationParams | null | false |
CategoryTheory.Precoverage.ZeroHypercover.mem₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Precoverage C} {S : C}
(self : J.ZeroHypercover S), self.presieve₀ ∈ J.coverings S | null | true |
CategoryTheory.Limits.Multifork.ofι._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) (P : C) (ι : (a : J.L) → P ⟶ I.left a),
(∀ (b : J.R),
CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b) =
CategoryTheory.CategoryStruct.... | null | false |
TopologicalSpace.IsCompletelyMetrizableSpace.sigma | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {ι : Type u_3} {X : ι → Type u_4} [inst : (n : ι) → TopologicalSpace (X n)]
[∀ (n : ι), TopologicalSpace.IsCompletelyMetrizableSpace (X n)],
TopologicalSpace.IsCompletelyMetrizableSpace ((n : ι) × X n) | A disjoint union of completely metrizable spaces is completely metrizable. | true |
CategoryTheory.ShiftMkCore.noConfusionType | Mathlib.CategoryTheory.Shift.Basic | Sort u_2 →
{C : Type u} →
{A : Type u_1} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
CategoryTheory.ShiftMkCore C A →
{C' : Type u} →
{A' : Type u_1} →
[inst' : CategoryTheory.Category.{v, u} C'] →
[inst... | null | false |
TopologicalSpace.Opens.coe_bot | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α], ↑⊥ = ∅ | null | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.linearIndependent_iffₒₛ._simp_1_7 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Path.0.SSet.spine_δ₀._simp_1_5 | Mathlib.AlgebraicTopology.SimplicialSet.Path | { len := 0 }.const { len := 0 + 1 } 1 = SimplexCategory.δ 0 | null | false |
AddSubgroup.dense_of_no_min | Mathlib.Topology.Algebra.Order.Archimedean | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] [inst_3 : TopologicalSpace G]
[OrderTopology G] [Archimedean G] (S : AddSubgroup G), S ≠ ⊥ → (¬∃ a, IsLeast {g | g ∈ S ∧ 0 < g} a) → Dense ↑S | Let `S` be a nontrivial additive subgroup in an archimedean linear ordered
additive commutative group `G` with order topology. If the set of positive elements of `S` does not
have a minimal element, then `S` is dense `G`. | true |
TensorProduct.prodLeft._proof_7 | Mathlib.LinearAlgebra.TensorProduct.Prod | ∀ (R : Type u_1) (M₃ : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M₃] [inst_2 : Module R M₃],
IsScalarTower R R M₃ | null | false |
instAddCommMonoidSymmetricPower._proof_12 | Mathlib.LinearAlgebra.TensorPower.Symmetric | ∀ (R ι : Type u_1) [inst : CommSemiring R] (M : Type u_2) [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a b : SymmetricPower R ι M), a + b = b + a | null | false |
Lean.Grind.CommRing.norm_int_cert.eq_1 | Init.Grind.Ring.CommSolver | ∀ (e : Lean.Grind.CommRing.Expr) (p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.norm_int_cert e p = e.toPoly_k.beq' p | null | true |
ClassGroup.normBound.eq_1 | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {R : Type u_1} {S : Type u_2} [inst : EuclideanDomain R] [inst_1 : CommRing S] [inst_2 : IsDomain S]
[inst_3 : Algebra R S] (abv : AbsoluteValue R ℤ) {ι : Type u_5} [inst_4 : DecidableEq ι] [inst_5 : Fintype ι]
(bS : Module.Basis ι R S),
ClassGroup.normBound abv bS =
(Fintype.card ι).factorial •
(Fint... | null | true |
CategoryTheory.Presheaf.preservesColimitsOfSize_of_isLeftKanExtension | Mathlib.CategoryTheory.Limits.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {ℰ : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} ℰ]
{A : CategoryTheory.Functor C ℰ} [CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁}.HasPointwiseLeftKanExtension A]
(L : CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂))) ℰ)
(... | Any left Kan extension along the Yoneda embedding preserves colimits. | true |
Lean.Meta.Sym.MatchUnifyResult.noConfusion | Lean.Meta.Sym.Pattern | {P : Sort u} → {t t' : Lean.Meta.Sym.MatchUnifyResult} → t = t' → Lean.Meta.Sym.MatchUnifyResult.noConfusionType P t t' | null | false |
Right.one_lt_inv_iff | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : Group α] [inst_1 : LT α] [MulRightStrictMono α] {a : α}, 1 < a⁻¹ ↔ a < 1 | Uses `right` co(ntra)variant. | true |
InnerProductGeometry.norm_sub_eq_add_norm_iff_angle_eq_pi | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y : V},
x ≠ 0 → y ≠ 0 → (‖x - y‖ = ‖x‖ + ‖y‖ ↔ InnerProductGeometry.angle x y = Real.pi) | The norm of the difference of two non-zero vectors equals the sum of their norms
if and only the angle between the two vectors is π. | true |
Module.isTorsionBySet_iff_is_torsion_by_span | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Module.IsTorsionBySet R M s ↔ Module.IsTorsionBySet R M ↑(Ideal.span s) | null | true |
_private.Lean.Environment.0.Lean.Environment.mk.sizeOf_spec | Lean.Environment | ∀ (base : Lean.VisibilityMap✝ Lean.Kernel.Environment) (serverBaseExts : Array Lean.EnvExtensionState)
(checked : Task Lean.Kernel.Environment) (asyncConstsMap : Lean.VisibilityMap✝ Lean.AsyncConsts✝)
(asyncCtx? : Option Lean.AsyncContext✝) (importRealizationCtx? : Option Lean.RealizationContext✝)
(localRealizati... | null | true |
SummationFilter.instLeAtTopSymmetricIoc | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G]
[inst_3 : LocallyFiniteOrder G] [NoBotOrder G], (SummationFilter.symmetricIoc G).LeAtTop | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_114 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
CategoryTheory.Limits.IsLimit.isoUniqueConeMorphism._proof_4 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_3, u_2} C] {F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F},
CategoryTheory.CategoryStruct.comp (TypeCat.ofHom fun h => { lift := fun s => default.hom, fac := ⋯, uniq := ⋯ })
(... | null | false |
CategoryTheory.ShortComplex.ShortExact.singleTriangle.map_hom₁ | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] {S₁ S₂ : CategoryTheory.ShortComplex C} (h₁ : S₁.ShortExact) (h₂ : S₂.ShortExact)
(f : S₁ ⟶ S₂),
(CategoryTheory.ShortComplex.ShortExact.singleTriangle.map h₁ h₂ f).hom₁ =
(DerivedCateg... | null | true |
Commute.sub_right._simp_1 | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R] {a b c : R}, Commute a b → Commute a c → Commute a (b - c) = True | null | false |
Lean.Meta.Sym.instBEqAlphaKey | Lean.Meta.Sym.AlphaShareCommon | BEq Lean.Meta.Sym.AlphaKey | null | true |
galGroupBasis._proof_3 | Mathlib.FieldTheory.KrullTopology | ∀ (K : Type u_2) (L : Type u_1) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {U : Set Gal(L/K)},
U ∈ (galBasis K L).sets → U * U ⊆ U | null | false |
WithTop.coe_untop₀_of_ne_top | Mathlib.Algebra.Order.WithTop.Untop0 | ∀ {α : Type u_1} [inst : Zero α] {a : WithTop α}, a ≠ ⊤ → ↑a.untop₀ = a | null | true |
NumberField.InfinitePlace.instMulActionAlgEquiv._proof_3 | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_2} [inst : Field k] {K : Type u_1} [inst_1 : Field K] [inst_2 : Algebra k K]
(x : NumberField.InfinitePlace K), 1 • x = 1 • x | null | false |
Lean.instInhabitedTSyntax | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → Inhabited (Lean.TSyntax ks) | null | true |
Order.coheight_eq | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (a : α), Order.coheight a = ⨆ p, ⨆ (_ : a ≤ RelSeries.head p), ↑p.length | The **coheight** of an element `a` in a preorder `α` is the supremum of the rightmost index of all
relation series of `α` ordered by `<` and beginning with `a`.
This is not the definition of `coheight`. The definition of `coheight` is via the `height` in the
dual order, in order to easily transfer theorems between `he... | true |
NormedAddGroupHom.opNorm_nonneg | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂), 0 ≤ ‖f‖ | null | true |
connectedSpace_iff_connectedComponent | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α], ConnectedSpace α ↔ ∃ x, connectedComponent x = Set.univ | null | true |
AlgebraicGeometry.GeometricallyConnected.recOn | Mathlib.AlgebraicGeometry.Geometrically.Connected | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.GeometricallyConnected f → Sort u} →
(t : AlgebraicGeometry.GeometricallyConnected f) →
((geometrically_connectedSpace : AlgebraicGeometry.geometrically (fun x => ConnectedSpace ↥x) f) → motive ⋯) →
motive t | null | false |
InnerProductSpace.Core.ne_zero_of_inner_self_ne_zero | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] {x : F}, inner 𝕜 x x ≠ 0 → x ≠ 0 | null | true |
Stream'.get_append_left | Mathlib.Data.Stream.Init | ∀ {α : Type u} (n : ℕ) (x : List α) (a : Stream' α) (h : n < x.length), (x ++ₛ a).get n = x[n] | null | true |
Std.Internal.instLawfulMemForInIdList | Std.Internal.ForIn.Lemmas | ∀ {α : Type u₁}, Std.Internal.LawfulMemForInId (List α) α | null | true |
List.lookup._sunfold | Init.Data.List.Basic | {α : Type u} → {β : Type v} → [BEq α] → α → List (α × β) → Option β | null | false |
_private.Mathlib.Data.WSeq.Defs.0.Stream'.WSeq.length.match_1.eq_2 | Mathlib.Data.WSeq.Defs | ∀ {α : Type u_1} (motive : Option (Stream'.Seq1 (Option α)) → Sort u_2) (s' : Stream'.Seq (Option α))
(h_1 : Unit → motive none) (h_2 : (s' : Stream'.Seq (Option α)) → motive (some (none, s')))
(h_3 : (val : α) → (s' : Stream'.Seq (Option α)) → motive (some (some val, s'))),
(match some (none, s') with
| none... | null | true |
finprod_le_finprod' | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f g : α → M} [inst_1 : PartialOrder M] [MulLeftMono M],
Function.HasFiniteMulSupport f → Function.HasFiniteMulSupport g → f ≤ g → ∏ᶠ (a : α), f a ≤ ∏ᶠ (a : α), g a | **Alias** of `finprod_le_finprod`.
---
Monotonicity of `finprod`. See `finprod_le_finprod₀` for a variant where
`M` is a `CommMonoidWithZero`. | true |
Equiv.asEmbedding_range | Mathlib.Logic.Embedding.Set | ∀ {α : Sort u_1} {β : Type u_2} {p : β → Prop} (e : α ≃ Subtype p), Set.range ⇑e.asEmbedding = Set.ofPred p | null | true |
SMul.comp.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {N : Type u_2} (α : Type u_5) [inst : SMul M α] (g : N → M),
SMul.comp α g = { smul := SMul.comp.smul g } | null | true |
_private.Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite.0.CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.exists_epi | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type v} [inst_1 : CategoryTheory.SmallCategory D]
(F : CategoryTheory.Functor D Cᵒᵖ) [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] (X : D), ∃ f, CategoryTheory.Epi f | null | true |
BinaryTree.left.eq_1 | Mathlib.Data.Tree.Basic | ∀ {α : Type u}, BinaryTree.nil.left = BinaryTree.nil | null | true |
_private.Lean.Elab.PreDefinition.WF.Eqns.0.Lean.Elab.WF.copyPrivateUnfoldTheorem._sparseCasesOn_1 | Lean.Elab.PreDefinition.WF.Eqns | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lean.Elab.Term.expandSuffices | Lean.Elab.BuiltinNotation | Lean.Macro | null | true |
Mathlib.Meta.FunProp.LambdaTheoremType.comp | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremType | Composition theorem e.g. `Continuous f → Continuous g → Continuous fun x ↦ f (g x)` | true |
Set.iUnion_dite | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} (p : ι → Prop) [inst : DecidablePred p] (f : (i : ι) → p i → Set α)
(g : (i : ι) → ¬p i → Set α),
(⋃ i, if h : p i then f i h else g i h) = (⋃ i, ⋃ (h : p i), f i h) ∪ ⋃ i, ⋃ (h : ¬p i), g i h | null | true |
ofDual_sdiff | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a b : αᵒᵈ),
OrderDual.ofDual (a \ b) = OrderDual.ofDual b ⇨ OrderDual.ofDual a | null | true |
Lean.Elab.Command.MacroExpandedSnapshot.mk.noConfusion | Lean.Elab.Command | {P : Sort u} →
{toSnapshot : Lean.Language.Snapshot} →
{macroDecl : Lean.Name} →
{newStx : Lean.Syntax} →
{newNextMacroScope : ℕ} →
{hasTraces : Bool} →
{next : Array (Lean.Language.SnapshotTask Lean.Language.DynamicSnapshot)} →
{toSnapshot' : Lean.Language.Snapsh... | null | false |
Nat.castAddMonoidHom | Mathlib.Data.Nat.Cast.Basic | (α : Type u_3) → [inst : AddMonoidWithOne α] → ℕ →+ α | `Nat.cast : ℕ → α` as an `AddMonoidHom`. | true |
Std.DTreeMap.Internal.Impl.updateCell._proof_37 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (ky : α) (y : β ky) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz ky y l r).Balanced) (newL : Std.DTreeMap.Internal.Impl α β)
(h₁ : newL.Balanced) (h₂ : l.size - 1 ≤ newL.size) (h₃ : newL.size ≤ l.size + 1),
(Std.DTreeMap.Internal.Im... | null | false |
Polynomial.isPrimitiveRoot_of_mahlerMeasure_eq_one | Mathlib.NumberTheory.MahlerMeasure | ∀ {p : Polynomial ℤ},
(Polynomial.map (Int.castRingHom ℂ) p).mahlerMeasure = 1 →
∀ {z : ℂ}, z ≠ 0 → z ∈ p.aroots ℂ → ∃ n, 0 < n ∧ IsPrimitiveRoot z n | If an integer polynomial has Mahler measure equal to 1, then all its complex nonzero roots are
roots of unity. | true |
RegularExpression.matches'_pow | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (P : RegularExpression α) (n : ℕ), (P ^ n).matches' = P.matches' ^ n | null | true |
hasSum_fintype_support | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Fintype β] (f : β → α)
(L : SummationFilter β) [L.HasSupport] [inst_4 : DecidablePred fun x => x ∈ L.support],
HasSum f (∑ b ∈ L.support.toFinset, f b) L | null | true |
IsFractionRing.liftAlgHom | Mathlib.RingTheory.Localization.FractionRing | {R : Type u_1} →
[inst : CommRing R] →
{A : Type u_4} →
[inst_1 : CommRing A] →
{K : Type u_5} →
[inst_2 : Field K] →
{L : Type u_7} →
[inst_3 : Field L] →
[inst_4 : Algebra A K] →
[IsFractionRing A K] →
[inst_... | `AlgHom` version of `IsFractionRing.lift`. | true |
_private.Mathlib.Algebra.Homology.Opposite.0.HomologicalComplex.instHasHomologyUnopOfOpposite._proof_1 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (K : HomologicalComplex Vᵒᵖ c) (i : ι) [K.HasHomology i],
K.unop.HasHomology i | null | false |
Lean.Meta.RefinedDiscrTree.LazyEntry.mk.inj | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ∀ {previous : Option Lean.Meta.RefinedDiscrTree.ExprInfo} {stack : List Lean.Meta.RefinedDiscrTree.StackEntry}
{mctx : Lean.MetavarContext} {labelledStars? : Option (Array Lean.MVarId)}
{computedKeys : List Lean.Meta.RefinedDiscrTree.Key} {previous_1 : Option Lean.Meta.RefinedDiscrTree.ExprInfo}
{stack_1 : List L... | null | true |
Differentiable.fun_add_iff_left._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F},
Differentiable 𝕜 g → (Differentiable 𝕜 fun i => f i + g i) = Differentiable 𝕜 f | null | false |
_private.Mathlib.Order.Atoms.0.le_iff_atom_le_imp.match_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α} (x : α)
(motive : x ∈ {a_1 | IsAtom a_1 ∧ a_1 ≤ a} → Prop) (x_1 : x ∈ {a_1 | IsAtom a_1 ∧ a_1 ≤ a}),
(∀ (h₁ : IsAtom x) (h₂ : x ≤ a), motive ⋯) → motive x_1 | null | false |
Submodule.coe_toNonUnitalSubalgebra | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
(p : Submodule R A) (h_mul : ∀ (x y : A), x ∈ p → y ∈ p → x * y ∈ p), ↑(p.toNonUnitalSubalgebra h_mul) = ↑p | null | true |
CategoryTheory.conjugateEquiv_leftUnitor_hom | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{L : CategoryTheory.Functor A B} {R : CategoryTheory.Functor B A} (adj : L ⊣ R),
(CategoryTheory.conjugateEquiv adj (CategoryTheory.Adjunction.id.comp adj)) L.leftUnitor.hom = R.rightUnitor.inv | null | true |
_private.Mathlib.Order.Interval.Set.OrdConnectedComponent.0.Set.dual_ordConnectedSection._simp_1_5 | Mathlib.Order.Interval.Set.OrdConnectedComponent | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Semigrp.str | Mathlib.Algebra.Category.Semigrp.Basic | (self : Semigrp) → Semigroup ↑self | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Variation.Basic.0.MeasureTheory.VectorMeasure.exists_variation_le_add'._simp_1_3 | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b | null | false |
Num.succ'.eq_1 | Mathlib.Data.Num.Lemmas | Num.zero.succ' = 1 | null | true |
DirectSum.equivCongrLeft | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
{κ : Type u_1} → (h : ι ≃ κ) → (DirectSum ι fun i => β i) ≃+ DirectSum κ fun k => β (h.symm k) | Reindexing terms of a direct sum: change indexing type from `ι` to `κ` along an equivalence
`h : ι ≃ κ`. | true |
Mathlib.Tactic.Widget.StringDiagram.AtomNode.atom | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.AtomNode → Mathlib.Tactic.BicategoryLike.Atom | The underlying expression of the node. | true |
SimpleGraph.map_injective | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W), Function.Injective (SimpleGraph.map ⇑f) | null | true |
ODE.FunSpace.compProj | Mathlib.Analysis.ODE.PicardLindelof | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{tmin tmax : ℝ} → {t₀ : ↑(Set.Icc tmin tmax)} → {x₀ : E} → {r L : NNReal} → ODE.FunSpace t₀ x₀ r L → ℝ → E | Extend the domain of `α` from `Icc tmin tmax` to `ℝ` such that `α t = α tmin` for all `t ≤ tmin`
and `α t = α tmax` for all `t ≥ tmax`. | true |
Composition.recOnSingleAppend._unary._proof_3 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (blocks : List ℕ), blocks.sum = blocks.sum | null | false |
WithBot.add_right_cancel | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Add α] {x y z : WithBot α} [IsRightCancelAdd α], z ≠ ⊥ → x + z = y + z → x = y | null | true |
List.IsPrefix.interleave | Batteries.Data.List.Interleave | ∀ {α : Type u_1} {l₁ l₃ l₂ l₄ : List α},
l₁.length = l₂.length ∨ l₁.length = l₂.length + 1 → l₁ <+: l₃ → l₂ <+: l₄ → l₁.interleave l₂ <+: l₃.interleave l₄ | null | true |
MeasureTheory.Integrable.condExpKernel_ae | Mathlib.Probability.Kernel.Condexp | ∀ {Ω : Type u_1} {F : Type u_2} {m : MeasurableSpace Ω} [mΩ : MeasurableSpace Ω] [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] [inst_2 : NormedAddCommGroup F] {f : Ω → F},
MeasureTheory.Integrable f μ → ∀ᵐ (ω : Ω) ∂μ, MeasureTheory.Integrable f ((ProbabilityT... | null | true |
HomologicalComplex.restrictionMap._proof_2 | Mathlib.Algebra.Homology.Embedding.Restriction | ∀ {ι : Type u_1} {ι' : Type u_4} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K L : HomologicalComplex C c'} (φ : K ⟶ L) (e : c.Embedding c') [inst_2 : e.IsRelIff] (i j : ι),
c.Rel i j →
CategoryTh... | null | false |
ArithmeticFunction.pow_one_eq_id | Mathlib.NumberTheory.ArithmeticFunction.Misc | ArithmeticFunction.pow 1 = ArithmeticFunction.id | null | true |
_private.Std.WP.Monad.Sound.0.Std.WP.EStateM.wpInst.match_1.splitter | Std.WP.Monad.Sound | {ε σ α : Type} →
(motive : EStateM.Result ε σ α → Sort u_1) →
(x : EStateM.Result ε σ α) →
((a : α) → (s' : σ) → motive (EStateM.Result.ok a s')) →
((el : ε) → (s' : σ) → motive (EStateM.Result.error el s')) → motive x | null | true |
ENNReal.coe_sub._simp_1 | Mathlib.Basic.ENNReal.Operations | ∀ {r p : NNReal}, ↑r - ↑p = ↑(r - p) | null | false |
MeasureTheory.OuterMeasure.addCommMonoid._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} (a b c : MeasureTheory.OuterMeasure α), a + b + c = a + (b + c) | null | false |
Function.Surjective.sumMap | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {α' : Type w} {β : Type v} {β' : Type x} {f : α → β} {g : α' → β'},
Function.Surjective f → Function.Surjective g → Function.Surjective (Sum.map f g) | null | true |
Std.DTreeMap.Const.ofList_singleton | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {k : α} {v : β},
Std.DTreeMap.Const.ofList [(k, v)] cmp = ∅.insert k v | null | true |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.symmetricCategory_braiding_inv_left | Mathlib.CategoryTheory.Monoidal.Arrow | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.Limits.HasInitial C] [inst_3 : CategoryTheory.CartesianMonoidalCategory C]
[inst_4 : CategoryTheory.MonoidalClosed C] [inst_5 : CategoryTheory.BraidedCategory C]
(X₁ X₂ : CategoryTheory... | null | true |
dist_single_single | Mathlib.Topology.MetricSpace.Pseudo.Pi | ∀ {β : Type u_2} [inst : Fintype β] {Y : Type u_4} [inst_1 : PseudoMetricSpace Y] [inst_2 : Zero Y]
[inst_3 : DecidableEq β] (i j : β) (a b : Y), i ≠ j → dist (Pi.single i a) (Pi.single j b) = max (dist a 0) (dist b 0) | The (sup metric) distance between `Pi.single i a` and `Pi.single j b` for
`i ≠ j` is `max (dist a 0) (dist b 0)`. | true |
Std.Internal.List.containsKey_filter_not_contains_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α}
{hl₁ : Std.Internal.List.DistinctKeys l₁} {k : α},
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.containsKey k (List.filter (fun p => !l₂.contains p.fst) l₁) = false | null | true |
FreeRing.coe_one | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u), ↑1 = 1 | null | true |
Computation.Results.mem | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ}, s.Results a n → a ∈ s | null | true |
ShrinkingLemma.PartialRefinement._sizeOf_inst | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
{inst : TopologicalSpace X} →
(u : ι → Set X) →
(s : Set X) →
(p : Set X → Prop) →
[SizeOf ι] →
[SizeOf X] →
[(a : ι) → (a_1 : X) → SizeOf (u a a_1)] →
[(a : X) → SizeOf (s a)] →
... | null | false |
not_bddAbove_univ._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] [NoTopOrder α], BddAbove Set.univ = False | null | false |
Finset.addEnergy_univ_right | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddCommGroup α] [inst_2 : Fintype α] (s : Finset α),
s.addEnergy Finset.univ = Fintype.card α * s.card ^ 2 | null | true |
FP.FloatCfg.prec | Mathlib.Data.FP.Basic | [self : FP.FloatCfg] → ℕ | null | true |
AlgebraicGeometry.Scheme.Cover.locallyDirectedPullbackCover._proof_10 | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
[inst : P.IsStableUnderBaseChange] (𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst_1 : CategoryTheory.Category.{u_3, u_1} 𝒰.I₀] [inst_2 : 𝒰.LocallyDirected] {Y : AlgebraicGeometry... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.