name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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 |
TensorProduct.AlgebraTensorModule.rightComm._proof_31 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (S : Type u_1) (B : Type u_2) (M : Type u_4) (P : Type u_3) [inst : Semiring B] [inst_1 : AddCommMonoid M]
[inst_2 : Module B M] [inst_3 : AddCommMonoid P] [inst_4 : CommSemiring S] [inst_5 : Module S M] [inst_6 : Module S P]
[inst_7 : Algebra S B] [inst_8 : IsScalarTower S B M], SMulCommClass S B (TensorProduct ... | null | false |
Tactic.MfldSetTac._aux_Mathlib_Logic_Equiv_PartialEquiv___elabRules_Tactic_MfldSetTac_mfldSetTac_1 | Mathlib.Logic.Equiv.PartialEquiv | Lean.Elab.Tactic.Tactic | A very basic tactic to show that sets showing up in manifolds coincide or are included
in one another. | false |
Subgroup.instInhabitedLeftTransversal.eq_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G},
Subgroup.instInhabitedLeftTransversal = { default := ⟨Set.range Quotient.out, ⋯⟩ } | null | true |
_private.Mathlib.RingTheory.Polynomial.HilbertPoly.0.Polynomial.natDegree_hilbertPoly_of_ne_zero_of_rootMultiplicity_lt._simp_1_9 | Mathlib.RingTheory.Polynomial.HilbertPoly | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] {n : ℕ}, (↑n = 0) = (n = 0) | null | false |
CovBy.unique_right | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, c ⋖ a → c ⋖ b → a = b | null | true |
Lean.Parser.checkNoImmediateColon | Lean.Parser.Basic | Lean.Parser.Parser | Fail if previous token is immediately followed by ':'. | true |
LinearMap.codRestrictOfInjective | Mathlib.Algebra.Module.Submodule.Equiv | {R : Type u_1} →
{M₁ : Type u_6} →
{M₂ : Type u_7} →
{M₃ : Type u_8} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : Module R M₁] →
[inst_5 : Module R... | The restriction of a linear map on the target to a submodule of the target given by
an inclusion. | 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 |
Function.Semiconj.mapsTo_range | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {fa : α → α} {fb : β → β} {f : α → β},
Function.Semiconj f fa fb → Set.MapsTo fb (Set.range f) (Set.range f) | 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 |
CategoryTheory.Presheaf.imageSieve_whisker_forget | Mathlib.CategoryTheory.Sites.LocallySurjective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A]
{FA : A → A → Type u_1} {CA : A → Type w'} [inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)]
[inst_3 : CategoryTheory.ConcreteCategory A FA] {F G : CategoryTheory.Functor Cᵒᵖ A} (f : F ⟶ G) {U : ... | null | true |
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 |
List.iterateTR_loop_eq | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (f : α → α) (a : α) (n : ℕ) (l : List α), List.iterateTR.loop f a n l = l.reverse ++ List.iterate f a n | 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 |
TwoSidedIdeal.instPartialOrder | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → PartialOrder (TwoSidedIdeal R) | null | true |
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) [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | 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 |
instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : AddZeroClass α]
[inst_3 : AddZeroClass β] [inst_4 : FunLike F α β] [inst_5 : OrderHomClass F α β] [inst_6 : AddMonoidHomClass F α β],
instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass = { coe := OrderMonoid... | null | true |
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 |
List.SortedGT.sortedGE | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, l.SortedGT → l.SortedGE | 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 |
isClopen_discrete._simp_1 | Mathlib.Topology.Clopen | ∀ {X : Type u} [inst : TopologicalSpace X] [DiscreteTopology X] (s : Set X), IsClopen s = True | null | false |
GoToModuleLinkProps._sizeOf_1 | ImportGraph.Tools.FindHome | GoToModuleLinkProps → ℕ | null | false |
FintypeCat.toProfinite._proof_4 | Mathlib.Topology.Category.Profinite.Basic | ∀ (A : FintypeCat), CompactSpace A.obj | 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 |
FirstOrder.Language.Formula.realize_iff._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {φ ψ : L.Formula α} {v : α → M},
(φ.iff ψ).Realize v = (φ.Realize v ↔ ψ.Realize v) | null | false |
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 |
ONote.brecOn.go | Mathlib.SetTheory.Ordinal.Notation | {motive : ONote → Sort u} → (t : ONote) → ((t : ONote) → ONote.below t → motive t) → motive t ×' ONote.below t | 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 |
Mathlib.Meta.NormNum.isNNRat_lt_false | Mathlib.Tactic.NormNum.Ineq | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a b : α} {na nb da db : ℕ},
Mathlib.Meta.NormNum.IsNNRat a na da →
Mathlib.Meta.NormNum.IsNNRat b nb db → decide (nb * da ≤ na * db) = true → ¬a < b | null | true |
Lean.Elab.Level.Context.mk.noConfusion | Lean.Elab.Level | {P : Sort u} →
{options : Lean.Options} →
{ref : Lean.Syntax} →
{autoBoundImplicit : Bool} →
{options' : Lean.Options} →
{ref' : Lean.Syntax} →
{autoBoundImplicit' : Bool} →
{ options := options, ref := ref, autoBoundImplicit := autoBoundImplicit } =
... | null | false |
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 |
_private.Init.Data.Array.QSort.Basic.0.Array.qpartition.loop._unsafe_rec | Init.Data.Array.QSort.Basic | {α : Type u_1} →
{n : ℕ} →
(α → α → Bool) →
(lo hi : ℕ) →
hi < n →
α →
Vector α n →
(i k : ℕ) →
autoParam (lo ≤ i) Array.qpartition._auto_2✝ →
autoParam (i ≤ k) Array.qpartition._auto_4✝ →
autoParam (k ≤ hi) Ar... | null | false |
basisOfLinearIndependentOfCardEqFinrank.congr_simp | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Type u_1}
[inst_3 : Fintype ι] [inst_4 : Nonempty ι] {b b_1 : ι → V} (e_b : b = b_1) (lin_ind : LinearIndependent K b)
(card_eq : Fintype.card ι = Module.finrank K V),
basisOfLinearIndependentOfCardEqFinrank l... | null | true |
_private.Mathlib.Algebra.Polynomial.Eval.Defs.0.Polynomial.eval₂_mul_C'._simp_1_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {G₀ : Type u_2} [inst : MulZeroClass G₀] (a : G₀), Commute 0 a = True | null | false |
CategoryTheory.MorphismProperty.respectsIso_of_isStableUnderComposition | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderComposition], CategoryTheory.MorphismProperty.isomorphisms C ≤ P → P.RespectsIso | null | true |
_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 | null | false |
LightCondensed.lanPresheafExt_inv | Mathlib.Condensed.Discrete.Colimit | ∀ {F G : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)} (S : LightProfiniteᵒᵖ)
(i : FintypeCat.toLightProfinite.op.comp F ≅ FintypeCat.toLightProfinite.op.comp G),
(LightCondensed.lanPresheafExt i).inv.app S =
CategoryTheory.Limits.colimMap
((CategoryTheory.CostructuredArrow.proj FintypeCat.toLightProf... | null | true |
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 |
Ideal.Quotient.field._proof_13 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) [I.IsMaximal] (a : R ⧸ I), ¬a = 0 → ∃ b, a * b = 1 | null | false |
String.Slice.Pattern.ToBackwardSearcher.noConfusion | Init.Data.String.Pattern.Basic | {P : Sort u} →
{ρ : Type} →
{pat : ρ} →
{σ : String.Slice → Type} →
{t : String.Slice.Pattern.ToBackwardSearcher pat σ} →
{ρ' : Type} →
{pat' : ρ'} →
{σ' : String.Slice → Type} →
{t' : String.Slice.Pattern.ToBackwardSearcher pat' σ'} →
... | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.sizeof_of_step._proof_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (L2 : List (α × Bool)) (x : α) (b : Bool),
List.rec 1 (fun head tail tail_ih => 1 + head._sizeOf_1 + tail_ih) L2 <
1 + (x, b)._sizeOf_1 +
(1 + (x, !b)._sizeOf_1 + List.rec 1 (fun head tail tail_ih => 1 + head._sizeOf_1 + tail_ih) L2) | 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 |
CategoryTheory.Limits.HasWidePullback | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (B : C) → (objs : J → C) → ((j : J) → objs j ⟶ B) → Prop | `HasWidePullback B objs arrows` means that `wideCospan B objs arrows` has a limit. | true |
CompletableTopField | Mathlib.Topology.Algebra.UniformField | (K : Type u_1) → [Field K] → [UniformSpace K] → Prop | A topological field is completable if it is separated and the image under
the mapping x ↦ x⁻¹ of every Cauchy filter (with respect to the additive uniform structure)
which does not have a cluster point at 0 is a Cauchy filter
(with respect to the additive uniform structure). This ensures the completion is
a field.
| true |
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 |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Increment.0.SzemerediRegularity.distinctPairs | Mathlib.Combinatorics.SimpleGraph.Regularity.Increment | {α : Type u_1} →
[inst : Fintype α] →
[inst_1 : DecidableEq α] →
{P : Finpartition Finset.univ} →
P.IsEquipartition →
(G : SimpleGraph α) → [DecidableRel G.Adj] → ℝ → ↥P.parts.offDiag → Finset (Finset α × Finset α) | The contribution to `Finpartition.energy` of a pair of distinct parts of a `Finpartition`. | true |
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 |
Lean.Grind.CommRing.Poly.combine.go.match_1.congr_eq_2 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) (p₁ p₂ : Lean.Grind.CommRing.Poly)
(h_1 : (k₁ k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.num k₂))
(h_2 :
(k₁ k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) →
... | 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 |
AlgebraicGeometry.Scheme.Hom.appLE_map'_assoc | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U : Y.Opens} {V V' : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (i : V = V') {Z : CommRingCat}
(h : X.presheaf.obj (Opposite.op V) ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.appLE f U V' ⋯)
(CategoryTheory.Category... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderOut.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (lhs rhs cin : aig.Ref),
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderOut aig { lhs := lhs, rhs := rhs, cin := cin } =
(aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.mkXorCached
{ lhs := (aig.mkXorCached { lhs := lhs, rhs :=... | null | true |
abs.unexpander | Mathlib.Algebra.Order.Group.Unbundled.Abs | Lean.PrettyPrinter.Unexpander | Unexpander for the notation `|a|` for `abs a`.
Tries to add discretionary parentheses in unparsable cases. | true |
CentroidHom.comp_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (g f : CentroidHom α) (a : α), (g.comp f) a = g (f a) | null | 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 |
ProofWidgets.instRpcEncodablePanelWidgetProps.dec._@.ProofWidgets.Component.Panel.Basic.2840189264._hygCtx._hyg.1 | ProofWidgets.Component.Panel.Basic | Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) ProofWidgets.PanelWidgetProps | null | false |
CategoryTheory.Functor.RepresentableBy.casesOn | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type v)} →
{Y : C} →
{motive : F.RepresentableBy Y → Sort u} →
(t : F.RepresentableBy Y) →
((homEquiv : {X : C} → (X ⟶ Y) ≃ F.obj (Opposite.op X)) →
(homEquiv_comp :
... | null | false |
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 |
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 | 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 |
_private.ProofWidgets.Cancellable.0.ProofWidgets.initFn._@.ProofWidgets.Cancellable.2133826679._hygCtx._hyg.2 | ProofWidgets.Cancellable | IO (IO.Ref (ProofWidgets.RequestId × Std.HashMap ProofWidgets.RequestId ProofWidgets.CancellableTask)) | null | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.stalk_iso | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
(x : ↑X.toTopCat), CategoryTheory.IsIso (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x) | 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 |
CategoryTheory.Limits.biprod.opIso_hom_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P Q : C) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct P Q] {Z : Cᵒᵖ} (h : Opposite.op P ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.opIso P Q).hom
(CategoryTheory.... | null | true |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.measureEntries._unsafe_rec | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → ℕ → ℕ | null | false |
SzemerediRegularity.mul_sq_le_sum_sq | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | ∀ {ι : Type u_2} {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s t : Finset ι}
{x : 𝕜},
s ⊆ t → ∀ (f : ι → 𝕜), x ^ 2 ≤ ((∑ i ∈ s, f i) / ↑s.card) ^ 2 → ↑s.card ≠ 0 → ↑s.card * x ^ 2 ≤ ∑ i ∈ t, f i ^ 2 | null | true |
instMonoidUniformOnFun._proof_3 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : Monoid β] (a : UniformOnFun α β 𝔖), a * 1 = a | null | false |
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 | Monotonicity of `finprod`. See `finprod_le_finprod` for a variant where
`M` is a `CommMonoidWithZero`. | true |
Equiv.Perm.disjoint_noncommProd_right | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {g : Equiv.Perm α} {ι : Type u_2} {k : ι → Equiv.Perm α} {s : Finset ι}
(hs : (↑s).Pairwise fun i j => Commute (k i) (k j)), (∀ i ∈ s, g.Disjoint (k i)) → g.Disjoint (s.noncommProd k hs) | null | 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 | null | true |
Filter.HasBasis.recOn | Mathlib.Order.Filter.Bases.Basic | {α : Type u_1} →
{ι : Sort u_4} →
{l : Filter α} →
{p : ι → Prop} →
{s : ι → Set α} →
{motive : l.HasBasis p s → Sort u} →
(t : l.HasBasis p s) → ((mem_iff' : ∀ (t : Set α), t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t) → motive ⋯) → motive t | null | false |
Lean.Elab.Tactic.Do.Internal.VCGen.State.simpState | Lean.Elab.Tactic.Do.Internal.VCGen.Context | Lean.Elab.Tactic.Do.Internal.VCGen.State → Lean.Meta.Sym.Simp.State | Persistent cache for the `Sym.Simp` simplifier used to pre-simplify hypotheses
before grind internalization. Threading this cache across VCGen iterations avoids
re-simplifying shared subexpressions (e.g., `s + 1 + 1 + ...` chains).
| 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.Mathlib.Probability.Kernel.RadonNikodym.0.ProbabilityTheory.Kernel.rnDeriv_eq_top_iff._simp_1_5 | Mathlib.Probability.Kernel.RadonNikodym | ∀ {r : ℝ}, (ENNReal.ofReal r = ⊤) = False | null | false |
_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 |
Acc.ndrecOnC.eq_1 | Init.WFComputable | ∀ {α : Sort u_1} {r : α → α → Prop} {C : α → Sort v} {a : α} (n : Acc r a)
(m : (x : α) → (∀ (y : α), r y x → Acc r y) → ((y : α) → r y x → C y) → C x), n.ndrecOnC m = Acc.recC m n | null | true |
Lean.Elab.Term.expandSuffices | Lean.Elab.BuiltinNotation | Lean.Macro | null | true |
Std.TreeMap.inter | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → Std.TreeMap α β cmp → Std.TreeMap α β cmp | Computes the intersection of the given tree maps. The result will only contain entries from the first map.
This function always merges the smaller map into the larger map.
| true |
ProbabilityTheory.Kernel.IsFiniteKernel.comapRight | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {f : γ → β} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsFiniteKernel κ]
(hf : MeasurableEmbedding f), ProbabilityTheory.IsFiniteKernel (κ.comapRight hf) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.