name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ContinuousLinearMapWOT.instContinuousAdd | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologicalAddGroup F]
[inst_9 : ContinuousConstSMul 𝕜₂ F], ContinuousAdd (E →SWOT[σ] F) | true |
_private.Mathlib.Algebra.Order.Floor.Ring.0.Int.image_fract._simp_1_2 | Mathlib.Algebra.Order.Floor.Ring | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
AddRightCancelMonoid.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {M : Type u} →
(add : M → M → M) →
(∀ (a b c : M), a + b + c = a + (b + c)) →
(zero : M) →
(∀ (a : M), 0 + a = a) →
(∀ (a : M), a + 0 = a) →
(nsmul : ℕ → M → M) →
autoParam (∀ (x : M), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (n : ℕ) (x : M), nsmul (n + 1) x = nsmul n x + x) AddMonoid.nsmul_succ._autoParam →
(∀ (a : M), IsAddRightRegular a) → AddRightCancelMonoid M | false |
ONote.repr_ofNat | Mathlib.SetTheory.Ordinal.Notation | ∀ (n : ℕ), (↑n).repr = ↑n | true |
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 | true |
Subsemiring.sumSq._proof_4 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ (T : Type u_1) [inst : CommSemiring T], 0 ∈ (NonUnitalSubsemiring.sumSq T).carrier | 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) | 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 | 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 (CategoryTheory.Functor.OplaxMonoidal.η F)]
[inst_6 : ∀ (X Y : C), CategoryTheory.IsIso (CategoryTheory.Functor.OplaxMonoidal.δ F X Y)] (X : C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (F.obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.asIso (CategoryTheory.Functor.OplaxMonoidal.η F)).symm.hom (F.obj X))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.asIso
(CategoryTheory.Functor.OplaxMonoidal.δ F (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
X)).symm.hom
(F.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom)) | 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.UnifyEqResult) → motive x) → motive __do_lift | false |
Prod.edist_eq | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (x y : α × β),
edist x y = max (edist x.1 y.1) (edist x.2 y.2) | 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.IsIso (P.lift t)] → CategoryTheory.Limits.IsLimit t | 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 | 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 | 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 | 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.comp (ι (J.snd b)) (I.snd b)) →
∀ ⦃X Y : CategoryTheory.Limits.WalkingMulticospan J⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingMulticospan J)).obj P).map f)
(match Y with
| CategoryTheory.Limits.WalkingMulticospan.left a => ι a
| CategoryTheory.Limits.WalkingMulticospan.right b =>
CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b)) =
CategoryTheory.CategoryStruct.comp
(match X with
| CategoryTheory.Limits.WalkingMulticospan.left a => ι a
| CategoryTheory.Limits.WalkingMulticospan.right b =>
CategoryTheory.CategoryStruct.comp (ι (J.fst b)) (I.fst b))
(I.multicospan.map f) | 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) | 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'_1 : AddMonoid A'] → CategoryTheory.ShiftMkCore C' A' → Sort u_2 | false |
TopologicalSpace.Opens.coe_bot | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α], ↑⊥ = ∅ | 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) | 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 | true |
TensorProduct.prodLeft._proof_7 | Mathlib.LinearAlgebra.TensorProduct.Prod | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | 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 | 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 •
(Fintype.card ι •
(Finset.image (fun ijk => abv ((Algebra.leftMulMatrix bS) (bS ijk.1) ijk.2.1 ijk.2.2)) Finset.univ).max' ⋯) ^
Fintype.card ι | 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₂))) ℰ)
(α : A ⟶ CategoryTheory.uliftYoneda.{max w v₂, v₁, u₁}.comp L) [L.IsLeftKanExtension α],
CategoryTheory.Limits.PreservesColimitsOfSize.{v₃, u₃, max (max (max u₁ v₁) v₂) w, v₂,
max (max (max u₁ (v₁ + 1)) (v₂ + 1)) (w + 1), u₂}
L | 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' | 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 | 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) | 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) | 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✝)
(localRealizationCtxMap : Lean.NameMap Lean.RealizationContext✝¹)
(allRealizations : Task (Lean.NameMap Lean.AsyncConst✝)) (isExporting : Bool),
sizeOf
{ base := base, serverBaseExts := serverBaseExts, checked := checked, asyncConstsMap := asyncConstsMap,
asyncCtx? := asyncCtx?, importRealizationCtx? := importRealizationCtx?,
localRealizationCtxMap := localRealizationCtxMap, allRealizations := allRealizations,
isExporting := isExporting } =
1 + sizeOf base + sizeOf serverBaseExts + sizeOf checked + sizeOf asyncConstsMap + sizeOf asyncCtx? +
sizeOf importRealizationCtx? +
sizeOf localRealizationCtxMap +
sizeOf allRealizations +
sizeOf isExporting | 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 | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_114 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
_private.Lean.Linter.Coe.0.Lean.Linter.Coe.coeLinter._sparseCasesOn_1 | Lean.Linter.Coe | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0._regBuiltin.Int16.reduceNe.declare_151._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.780327193._hygCtx.3.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.780327193._hygCtx._hyg.278 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | 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 (fun h => { lift := fun s => default.hom, fac := ⋯, uniq := ⋯ }) fun h s =>
{ default := h.liftConeMorphism s, uniq := ⋯ }) =
CategoryTheory.CategoryStruct.id ((s : CategoryTheory.Limits.Cone F) → Unique (s ⟶ t)) | 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₁ =
(DerivedCategory.singleFunctor C 0).map f.τ₁ | 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 | false |
Lean.Meta.Sym.instBEqAlphaKey | Lean.Meta.Sym.AlphaShareCommon | BEq Lean.Meta.Sym.AlphaKey | 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 | false |
WithTop.coe_untop₀_of_ne_top | Mathlib.Algebra.Order.WithTop.Untop0 | ∀ {α : Type u_1} [inst : Zero α] {a : WithTop α}, a ≠ ⊤ → ↑a.untop₀ = a | 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 | false |
Lean.instInhabitedTSyntax | Init.Prelude | {ks : Lean.SyntaxNodeKinds} → Inhabited (Lean.TSyntax ks) | true |
Order.coheight_eq | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (a : α), Order.coheight a = ⨆ p, ⨆ (_ : a ≤ RelSeries.head p), ↑p.length | 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‖ | true |
connectedSpace_iff_connectedComponent | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α], ConnectedSpace α ↔ ∃ x, connectedComponent x = Set.univ | true |
Lean.Grind.CommRing.Poly.denoteAsIntModuleExpr._sunfold | Lean.Meta.Tactic.Grind.Arith.Linear.DenoteExpr | Lean.Grind.CommRing.Poly → Lean.Meta.Grind.Arith.Linear.LinearM Lean.Expr | 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 | 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] | true |
List.lookup._sunfold | Init.Data.List.Basic | {α : Type u} → {β : Type v} → [BEq α] → α → List (α × β) → Option β | 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 => h_1 ()
| some (none, s') => h_2 s'
| some (some val, s') => h_3 val s') =
h_2 s' | 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 | true |
Equiv.asEmbedding_range | Mathlib.Logic.Embedding.Set | ∀ {α : Sort u_1} {β : Type u_2} {p : β → Prop} (e : α ≃ Subtype p), Set.range ⇑e.asEmbedding = setOf p | 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 } | 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 | 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 | false |
Lean.Elab.Term.expandSuffices | Lean.Elab.BuiltinNotation | Lean.Macro | true |
Mathlib.Meta.FunProp.LambdaTheoremType.comp | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremType | true |
Set.iUnion_dite | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} (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 | true |
Polynomial.monic_of_degree_le_of_coeff_eq_one | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} (n : ℕ), p.degree ≤ ↑n → p.coeff n = 1 → p.Monic | 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.Snapshot} →
{macroDecl' : Lean.Name} →
{newStx' : Lean.Syntax} →
{newNextMacroScope' : ℕ} →
{hasTraces' : Bool} →
{next' : Array (Lean.Language.SnapshotTask Lean.Language.DynamicSnapshot)} →
{ toSnapshot := toSnapshot, macroDecl := macroDecl, newStx := newStx,
newNextMacroScope := newNextMacroScope, hasTraces := hasTraces, next := next } =
{ toSnapshot := toSnapshot', macroDecl := macroDecl', newStx := newStx',
newNextMacroScope := newNextMacroScope', hasTraces := hasTraces', next := next' } →
(toSnapshot = toSnapshot' →
macroDecl = macroDecl' →
newStx = newStx' →
newNextMacroScope = newNextMacroScope' →
hasTraces = hasTraces' → next = next' → P) →
P | false |
Nat.castAddMonoidHom | Mathlib.Data.Nat.Cast.Basic | (α : Type u_3) → [inst : AddMonoidWithOne α] → ℕ →+ α | 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.Impl.inner sz ky y l r).size - 1 ≤ (Std.DTreeMap.Internal.Impl.balance ky y newL r ⋯ ⋯ ⋯).size | 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 | true |
RegularExpression.matches'_pow | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (P : RegularExpression α) (n : ℕ), (P ^ n).matches' = P.matches' ^ n | 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 | 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_6 : Algebra R A] →
[inst_7 : Algebra R K] →
[IsScalarTower R A K] →
[inst_9 : Algebra R L] → {g : A →ₐ[R] L} → Function.Injective ⇑g → K →ₐ[R] L | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.enumsPass.match_9 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | (motive : MProd Lean.Meta.SimpTheoremsArray Lean.Meta.Simprocs → Sort u_1) →
(r : MProd Lean.Meta.SimpTheoremsArray Lean.Meta.Simprocs) →
((relevantLemmas : Lean.Meta.SimpTheoremsArray) →
(simprocs : Lean.Meta.Simprocs) → motive ⟨relevantLemmas, simprocs⟩) →
motive r | 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 Lean.Meta.RefinedDiscrTree.StackEntry} {mctx_1 : Lean.MetavarContext}
{labelledStars?_1 : Option (Array Lean.MVarId)} {computedKeys_1 : List Lean.Meta.RefinedDiscrTree.Key},
{ previous := previous, stack := stack, mctx := mctx, labelledStars? := labelledStars?,
computedKeys := computedKeys } =
{ previous := previous_1, stack := stack_1, mctx := mctx_1, labelledStars? := labelledStars?_1,
computedKeys := computedKeys_1 } →
previous = previous_1 ∧
stack = stack_1 ∧ mctx = mctx_1 ∧ labelledStars? = labelledStars?_1 ∧ computedKeys = computedKeys_1 | 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 | 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 | 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 | 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 | 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⟩ | false |
Semigrp.str | Mathlib.Algebra.Category.Semigrp.Basic | (self : Semigrp) → Semigroup ↑self | true |
Num.succ'.eq_1 | Mathlib.Data.Num.Lemmas | Num.zero.succ' = 1 | true |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.synthesizePendingAndNormalizeFunType._sparseCasesOn_1 | Lean.Elab.App | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
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) | true |
Mathlib.Tactic.Widget.StringDiagram.AtomNode.atom | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.AtomNode → Mathlib.Tactic.BicategoryLike.Atom | true |
SimpleGraph.map_injective | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (f : V ↪ W), Function.Injective (SimpleGraph.map ⇑f) | 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 | true |
Composition.recOnSingleAppend._unary._proof_3 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (blocks : List ℕ), blocks.sum = blocks.sum | 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 | 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 ((ProbabilityTheory.condExpKernel μ m) ω) | 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 →
CategoryTheory.CategoryStruct.comp (φ.f (e.f i)) ((L.restriction e).d i j) =
CategoryTheory.CategoryStruct.comp ((K.restriction e).d i j) (φ.f (e.f j)) | false |
ArithmeticFunction.pow_one_eq_id | Mathlib.NumberTheory.ArithmeticFunction.Misc | ArithmeticFunction.pow 1 = ArithmeticFunction.id | true |
ENNReal.coe_sub._simp_1 | Mathlib.Data.ENNReal.Operations | ∀ {r p : NNReal}, ↑r - ↑p = ↑(r - p) | false |
MeasureTheory.OuterMeasure.addCommMonoid._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | IsScalarTower ℕ ENNReal ENNReal | 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) | 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 | 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) | 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 | true |
FreeRing.coe_one | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u), ↑1 = 1 | true |
Computation.Results.mem | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {s : Computation α} {a : α} {n : ℕ}, s.Results a n → a ∈ s | 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)] →
[(a : Set X) → SizeOf (p a)] → SizeOf (ShrinkingLemma.PartialRefinement u s p) | false |
not_bddAbove_univ._simp_2 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] [NoTopOrder α], BddAbove Set.univ = False | 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 | true |
FP.FloatCfg.prec | Mathlib.Data.FP.Basic | [self : FP.FloatCfg] → ℕ | 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.Scheme}
(f : Y ⟶ X) {i j : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).I₀}
(x :
↥(CategoryTheory.Limits.pullback ((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).f i)
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).f j))),
∃ k hki hkj y,
(CategoryTheory.Limits.pullback.lift
(CategoryTheory.Limits.pullback.map f (𝒰.f k) f (𝒰.f i) (CategoryTheory.CategoryStruct.id Y) (𝒰.trans hki)
(CategoryTheory.CategoryStruct.id X) ⋯ ⋯)
(CategoryTheory.Limits.pullback.map f (𝒰.f k) f (𝒰.f j) (CategoryTheory.CategoryStruct.id Y) (𝒰.trans hkj)
(CategoryTheory.CategoryStruct.id X) ⋯ ⋯)
⋯)
y =
x | false |
starRingOfComm | Mathlib.Algebra.Star.Basic | {R : Type u_1} → [inst : CommSemiring R] → StarRing R | true |
MulEquiv.hasEnoughRootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ {n : ℕ} [NeZero n] {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] [inst_1 : CommMonoid N]
[hm : HasEnoughRootsOfUnity M n] (e : ↥(rootsOfUnity n M) ≃* ↥(rootsOfUnity n N)), HasEnoughRootsOfUnity N n | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.