name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.Cone.functoriality_obj_pt | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] (F : CategoryTheory.Functor J C)
(G : CategoryTheory.Functor C D) (A : CategoryTheory.Limits.Cone F),
((CategoryTheory.Limits.Cone.fun... | null | true |
Function.Involutive.rightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {f : α → α}, Function.Involutive f → Function.RightInverse f f | null | true |
_private.Mathlib.Logic.Equiv.Defs.0.Equiv.permCongr_trans._proof_1_1 | Mathlib.Logic.Equiv.Defs | ∀ {α' : Type u_2} {β' : Type u_1} (e : α' ≃ β') (p p' : Equiv.Perm α'),
(e.permCongr p).trans (e.permCongr p') = e.permCongr (Equiv.trans p p') | null | false |
Int.gcd_comm | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.gcd b = b.gcd a | null | true |
CliffordAlgebra.evenEquivEvenNeg._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.EvenEquiv | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), -Q = -Q | null | false |
smul_le_smul_iff_of_pos_left._simp_1 | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β} [inst : SMul α β] [inst_1 : Preorder α] [inst_2 : Preorder β]
[inst_3 : Zero α] [PosSMulMono α β] [PosSMulReflectLE α β], 0 < a → (a • b₁ ≤ a • b₂) = (b₁ ≤ b₂) | null | false |
CategoryTheory.GradedObject.single_map_singleObjApplyIsoOfEq_hom | Mathlib.CategoryTheory.GradedObject.Single | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasInitial C] [inst_2 : DecidableEq J] (j : J) {X Y : C} (f : X ⟶ Y) (i : J)
(h : i = j),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.GradedObject.single j).map f i)
(CategoryTheory.GradedOb... | null | true |
Lean.Grind.NatModule.one_nsmul | Init.Grind.Module.Basic | ∀ {M : Type u} [inst : Lean.Grind.NatModule M] (a : M), 1 • a = a | null | true |
Module.Basis.constr_def | Mathlib.LinearAlgebra.Basis.Defs | ∀ {M' : Type u_7} [inst : AddCommMonoid M'] {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst_1 : Semiring R]
[inst_2 : AddCommMonoid M] [inst_3 : Module R M] (b : Module.Basis ι R M) [inst_4 : Module R M'] (S : Type u_13)
[inst_5 : Semiring S] [inst_6 : Module S M'] [inst_7 : SMulCommClass R S M'] (f : ι → M')... | null | true |
ContRepresentation.Equiv | Mathlib.RepresentationTheory.Continuous.Basic | {R : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
[inst_5 : Module R V] →
... | The equivalence between continuous representations. | true |
CategoryTheory.TransfiniteCompositionOfShape.ofComposableArrows_F | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {n : ℕ} (G : CategoryTheory.ComposableArrows C n),
(CategoryTheory.TransfiniteCompositionOfShape.ofComposableArrows G).F = G | null | true |
Algebra.Extension.tensorCotangentSpaceOfFormallyEtale._proof_7 | Mathlib.RingTheory.Etale.Kaehler | ∀ {R : Type u_4} {S : Type u_1} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra S T] {Q : Algebra.Extension R T}, SMulCommClass S Q.Ring T | null | false |
_private.Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane.0.EuclideanGeometry.inversion_mem_perpBisector_inversion_iff._simp_1_7 | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Std.Sat.AIG.Fanin.flip | Std.Sat.AIG.Basic | Std.Sat.AIG.Fanin → Bool → Std.Sat.AIG.Fanin | Flip the inverter bit according to `val`.
| true |
Bornology.ofDist._proof_4 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} (dist : α → α → ℝ) (z : α), ∃ C, ∀ ⦃x : α⦄, x ∈ {z} → ∀ ⦃y : α⦄, y ∈ {z} → dist x y ≤ C | null | false |
_private.Aesop.Forward.State.0.Aesop.ForwardState.enqueuePatSubsts.match_1 | Aesop.Forward.State | (motive : Aesop.ForwardRule × Aesop.Substitution → Sort u_1) →
(x : Aesop.ForwardRule × Aesop.Substitution) →
((r : Aesop.ForwardRule) → (patSubst : Aesop.Substitution) → motive (r, patSubst)) → motive x | null | false |
MeasurableSpace.generateMeasurable_eq_rec | Mathlib.MeasureTheory.MeasurableSpace.Card | ∀ {α : Type u} (s : Set (Set α)),
{t | MeasurableSpace.GenerateMeasurable s t} = MeasurableSpace.generateMeasurableRec s (Ordinal.omega 1) | `generateMeasurableRec s ω₁` generates precisely the smallest sigma-algebra containing `s`. | true |
AddChar.coe_compAddMonoidHom._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {B : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : Monoid M]
(φ : AddChar B M) (f : A →+ B), ⇑φ ∘ ⇑f = ⇑(φ.compAddMonoidHom f) | null | false |
CategoryTheory.MonoidalOpposite.mopMopEquivalenceFunctorMonoidal._proof_12 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᴹᵒᵖᴹᵒᵖ} (f : X ⟶ Y) (X' : Cᴹᵒᵖᴹᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.MonoidalOpposite.mopMopEquivalence C).functor.obj
(Cat... | null | false |
Lean.Meta.Grind.Split.instInhabitedState | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Split.State | null | true |
Std.Roo.forIn'_congr | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerableLT α] [inst_4 : Std.Rxo.IsAlwaysFinite α]
[inst_5 : Std.PRange.LawfulUpwardEnumerable α] {m : Type u → Type w} [inst_6 : Monad m] {γ : Type u} {init init' : γ}
{r r' : Std.Roo ... | null | true |
Aesop.ScriptGenerated.Method.rec | Aesop.Stats.Basic | {motive : Aesop.ScriptGenerated.Method → Sort u} →
motive Aesop.ScriptGenerated.Method.static →
motive Aesop.ScriptGenerated.Method.dynamic → (t : Aesop.ScriptGenerated.Method) → motive t | null | false |
List.infix_append'._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), (l₂ <:+: l₁ ++ (l₂ ++ l₃)) = True | null | false |
controlled_closure_range_of_complete | Mathlib.Analysis.Normed.Group.ControlledClosure | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [CompleteSpace G] {H : Type u_2} [inst_2 : NormedAddCommGroup H]
{f : NormedAddGroupHom G H} {K : Type u_3} [inst_3 : SeminormedAddCommGroup K] {j : NormedAddGroupHom K H},
(∀ (x : K), ‖j x‖ = ‖x‖) →
∀ {C ε : ℝ},
0 < C →
0 < ε → (∀ (k : K), ∃ g, f g =... | Given `f : NormedAddGroupHom G H` for some complete `G`, if every element `x` of the image of
an isometric immersion `j : NormedAddGroupHom K H` has a preimage under `f` whose norm is at most
`C*‖x‖` then the same holds for elements of the (topological) closure of this image with constant
`C+ε` instead of `C`, for any ... | true |
Int.closedBall_eq_Icc | Mathlib.Topology.Instances.Int | ∀ (x : ℤ) (r : ℝ), Metric.closedBall x r = Set.Icc ⌈↑x - r⌉ ⌊↑x + r⌋ | null | true |
BitVec.getLsbD_ofNatLT | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x : ℕ) (lt : x < 2 ^ n) (i : ℕ), (x#'lt).getLsbD i = x.testBit i | null | true |
Fin.get_take_eq_take_get_comp_cast | Mathlib.Data.Fin.Tuple.Take | ∀ {α : Type u_2} {m : ℕ} (l : List α) (h : m ≤ l.length), (List.take m l).get = Fin.take m h l.get ∘ Fin.cast ⋯ | `Fin.take` intertwines with `List.take` via `List.get`. | true |
IsStrictOrderedRing.toContinuousInv₀ | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} [inst : Semifield 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[OrderTopology 𝕜] [ContinuousMul 𝕜], ContinuousInv₀ 𝕜 | null | true |
ProfiniteAddGrp.limitConePtAux._proof_3 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_2 u_1})
{x : (j : J) → ↑(F.obj j).toProfinite.toTop},
x ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F.map π)) (x i) = x j} →
∀ (x_1 x_2 : J) (π : x_1 ⟶ x_2), (ProfiniteAddGrp.Hom.hom (F.ma... | null | false |
CategoryTheory.SimplicialThickening.mk.sizeOf_spec | Mathlib.AlgebraicTopology.SimplicialNerve | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SizeOf J] (as : J), sizeOf { as := as } = 1 + sizeOf as | null | true |
Filter.frequently_true_iff_neBot._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α), (∃ᶠ (x : α) in f, True) = f.NeBot | null | false |
IsClosed.upperSemicontinuousAt_indicator | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {s : Set α} {x : α} {y : β} [inst_1 : Zero β]
[inst_2 : Preorder β], IsClosed s → 0 ≤ y → UpperSemicontinuousAt (s.indicator fun _x => y) x | null | true |
IsOfFinOrder.unit.eq_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {M : Type u_6} [inst : Monoid M] {x : M} (hx : IsOfFinOrder x),
hx.unit = { val := x, inv := x ^ (orderOf x - 1), val_inv := ⋯, inv_val := ⋯ } | null | true |
CategoryTheory.MonoidalCategoryStruct.rightUnitor | Mathlib.CategoryTheory.Monoidal.Category | {C : Type u} →
{𝒞 : CategoryTheory.Category.{v, u} C} →
[self : CategoryTheory.MonoidalCategoryStruct C] →
(X : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ X | The right unitor: `X ⊗ 𝟙_ C ≃ X` | true |
CategoryTheory.Functor.toCostructuredArrow._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {E : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
(G : CategoryTheory.Functor E C) (F : CategoryTheory.Functor C D) (X : D) (f : (Y : E) → F.obj (G.obj Y) ⟶ X)
(h : ∀ {Y Z : E... | null | false |
CategoryTheory.AddMon.forget_δ | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y : CategoryTheory.AddMon C),
CategoryTheory.Functor.OplaxMonoidal.δ (CategoryTheory.AddMon.forget C) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.Mon... | null | true |
_private.Init.Data.Vector.Lemmas.0.Vector.mem_of_getElem?.match_1_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {a : α} (motive : (∃ (h : i < n), xs[i] = a) → Prop)
(x : ∃ (h : i < n), xs[i] = a), (∀ (w : i < n) (e : xs[i] = a), motive ⋯) → motive x | null | false |
Std.ExtHashSet.getD_eq_fallback_of_contains_eq_false | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{a fallback : α}, m.contains a = false → m.getD a fallback = fallback | null | true |
Mathlib.Tactic.BicategoryLike.Mor₂Iso.isStructural._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | Mathlib.Tactic.BicategoryLike.Mor₂Iso → Bool | null | false |
ContinuousMultilinearMap.sum_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [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₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : ContinuousAdd M₂... | null | true |
IO.FS.Metadata.numLinks | Init.System.IO | IO.FS.Metadata → UInt64 | The number of hard links to the file. | true |
FintypeCat.equivEquivIso_symm_apply_apply | Mathlib.CategoryTheory.FintypeCat | ∀ {A B : FintypeCat} (i : A ≅ B) (a : A.obj),
(FintypeCat.equivEquivIso.symm i) a = (CategoryTheory.ConcreteCategory.hom i.hom) a | null | true |
CategoryTheory.Lax.LaxTrans.homCategory.ext_iff | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {Γ Δ : η ⟶ θ}, Γ = Δ ↔ ∀ (a : B), Γ.as.app a = Δ.as.app a | null | true |
Lean.SourceInfo.none.sizeOf_spec | Init.SizeOf | sizeOf Lean.SourceInfo.none = 1 | null | true |
ContinuousMultilinearMap.mk.inj | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} {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₂} {inst_5 : (i : ι) → TopologicalSpace (M₁ i)} {inst_6 : TopologicalSpace M₂}
{toMultilinearMap : Multil... | null | true |
Polynomial.instMulSemiringActionGalSplittingField._proof_4 | Mathlib.FieldTheory.PolynomialGaloisGroup | ∀ {F : Type u_1} [inst : Field F] (p : Polynomial F) (b : p.SplittingField), 1 • b = b | null | false |
CategoryTheory.Limits.cokernel.condition_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
(f : X ⟶ Y) [inst_2 : CategoryTheory.Limits.HasCokernel f] {F : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) → FunLike (F X Y) (carrier X) (carrier Y)} [inst_3 : CategoryTheory.... | null | true |
UniformContinuous.nndist | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : UniformSpace β] {f g : β → α},
UniformContinuous f → UniformContinuous g → UniformContinuous fun b => nndist (f b) (g b) | null | true |
ComplexShape.σ_def | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ (p q : ℤ),
TotalComplexShapeSymmetry.σ (ComplexShape.up ℤ) (ComplexShape.up ℤ) (ComplexShape.up ℤ) p q = (p * q).negOnePow | null | true |
MeasureTheory.Egorov.notConvergentSeq_antitone | Mathlib.MeasureTheory.Function.Egorov | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : PseudoEMetricSpace β] {n : ℕ} {f : ι → α → β} {g : α → β}
[inst_1 : Preorder ι], Antitone (MeasureTheory.Egorov.notConvergentSeq f g n) | null | true |
_private.Init.Data.SInt.Lemmas.0.ISize.toInt_ofNat_of_lt_two_pow_numBits._proof_1_1 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2147483648 → ¬↑n < 2147483648 → False | null | false |
_private.Mathlib.LinearAlgebra.Semisimple.0.LinearEquiv.isSemisimple_iff._simp_1_2 | Mathlib.LinearAlgebra.Semisimple | ∀ (R : Type u_2) [inst : Ring R] (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsSemisimpleModule R M = ComplementedLattice (Submodule R M) | null | false |
WithCStarModule.instNormedAddCommGroupProd._proof_10 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_3} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {E : Type u_2} {F : Type u_1}
[inst_2 : NormedAddCommGroup E] [inst_3 : Module ℂ E] [inst_4 : SMul A E] [inst_5 : NormedAddCommGroup F]
[inst_6 : Module ℂ F] [inst_7 : SMul A F] [inst_8 : CStarModule A E] [inst_9 : CStarModule A F]
[inst_... | null | false |
Fin.lt_sub_iff | Mathlib.Algebra.Group.Fin.Basic | ∀ {n : ℕ} {a b : Fin n}, a < a - b ↔ a < b | null | true |
Function.Injective | Init.Data.Function | {α : Sort u_1} → {β : Sort u_2} → (α → β) → Prop | A function `f : α → β` is called injective if `f x = f y` implies `x = y`. | true |
Set.pairwise_iUnion₂ | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {s : Set (Set α)},
DirectedOn (fun x1 x2 => x1 ⊆ x2) s → ∀ (r : α → α → Prop), (∀ a ∈ s, a.Pairwise r) → (⋃ a ∈ s, a).Pairwise r | null | true |
Submodule.adjoint._proof_3 | Mathlib.Analysis.InnerProductSpace.LinearPMap | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomInvPair (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
Valued.instFaithfulSMulCompletionOfUniformContinuousConstSMul | Mathlib.Topology.Algebra.Valued.ValuedField | ∀ {K : Type u_1} [inst : Field K] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [hv : Valued K Γ₀]
{R : Type u_3} [inst_2 : CommSemiring R] [inst_3 : Algebra R K] [UniformContinuousConstSMul R K] [FaithfulSMul R K],
FaithfulSMul R (UniformSpace.Completion K) | null | true |
CategoryTheory.ObjectProperty.preservesLimit_iff | Mathlib.CategoryTheory.ObjectProperty.FunctorCategory.PreservesLimits | ∀ {J : Type u_1} {C : Type u_3} (K : Type u_5) [inst : CategoryTheory.Category.{v_1, u_5} K]
[inst_1 : CategoryTheory.Category.{v_3, u_1} J] [inst_2 : CategoryTheory.Category.{v_5, u_3} C]
(F : CategoryTheory.Functor K J) (G : CategoryTheory.Functor J C),
CategoryTheory.ObjectProperty.preservesLimit F G ↔ Categor... | null | true |
CategoryTheory.Limits.IsLimit.ofIsZero | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
[CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasZeroObject C] →
{F : CategoryTheory.Functor D C} →
(c : CategoryTheory... | If a functor `F` is zero, then any cone for `F` with a zero point is limit. | true |
Lean.Lsp.CompletionOptions.allCommitCharacters?._default | Lean.Data.Lsp.LanguageFeatures | Option (Array String) | null | false |
_private.Lean.Parser.Term.0.Lean.Parser.initFn._@.Lean.Parser.Term.1815602713._hygCtx._hyg.8 | Lean.Parser.Term | IO Unit | null | false |
_private.Mathlib.Data.Nat.Totient.0.Mathlib.Meta.Positivity.evalNatTotient.match_4 | Mathlib.Data.Nat.Totient | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(z : Q(Zero «$α»)) →
(p : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness z p e) → Sort u_1) →
(u : Lean.L... | null | false |
CircleDeg1Lift.translationNumber_eq_int_iff | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift), Continuous ⇑f → ∀ {m : ℤ}, f.translationNumber = ↑m ↔ ∃ x, f x = x + ↑m | null | true |
String.Slice.Pos.prevAux._proof_6 | Init.Data.String.Basic | ∀ {s : String.Slice} (off : ℕ), off + 1 < s.utf8ByteSize → off < s.utf8ByteSize | null | false |
_private.Mathlib.NumberTheory.Dioph.0.Dioph.diophFn_compn.match_1_1 | Mathlib.NumberTheory.Dioph | ∀ {α : Type} (motive : (x : ℕ) → (x_1 : Set (α ⊕ Fin2 x → ℕ)) → Dioph x_1 → Vector3 ((α → ℕ) → ℕ) x → Prop) (x : ℕ)
(x_1 : Set (α ⊕ Fin2 x → ℕ)) (x_2 : Dioph x_1) (x_3 : Vector3 ((α → ℕ) → ℕ) x),
(∀ (S : Set (α ⊕ Fin2 0 → ℕ)) (d : Dioph S) (f : Vector3 ((α → ℕ) → ℕ) 0), motive 0 S d f) →
(∀ (n : ℕ) (S : Set (α ... | null | false |
Std.DTreeMap.Internal.Impl.toListModel_interSmallerFn | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} [Std.TransOrd α] [inst : BEq α] [Std.LawfulBEqOrd α]
(m sofar : Std.DTreeMap.Internal.Impl α β),
m.WF →
∀ (h₂ : sofar.WF) (l : List ((a : α) × β a)) (k : α),
sofar.toListModel.Perm l →
(↑(m.interSmallerFn ⟨sofar, ⋯⟩ k)).toListModel.Perm (Std.Internal.Lis... | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence.0.CochainComplex.instShiftSequenceHomologicalComplexIntUpHomologyFunctorOfNat._simp_4 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology]
[inst_4 : S₃.HasHomology] (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Sh... | null | false |
Std.DTreeMap.Internal.Impl.isEmpty_inter!_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → m₁.isEmpty = true → (m₁.inter! m₂).isEmpty = true | null | true |
MonoidHom.op._proof_5 | Mathlib.Algebra.Group.Equiv.Opposite | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (f : Mᵐᵒᵖ →* Nᵐᵒᵖ),
MulOpposite.unop ((⇑f ∘ MulOpposite.op) 1) = MulOpposite.unop { unop' := 1 } | null | false |
Setoid.eqvGen_of_setoid | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (r : Setoid α), Relation.EqvGen.setoid ⇑r = r | The equivalence closure of an equivalence relation r is r. | true |
AlgCat.HasLimits.limitConeIsLimit._proof_14 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(s : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget (AlgCat R)).map
... | null | false |
Lean.Macro.resolveGlobalName | Init.Prelude | Lean.Name → Lean.MacroM (List (Lean.Name × List String)) | Resolves the given name to an overload list of global definitions.
The `List String` in each alternative is the deduced list of projections
(which are ambiguous with name components).
Remark: it will not trigger actions associated with reserved names. Recall that Lean
has reserved names. For example, a definition `foo... | true |
Std.DHashMap.Internal.Raw.Const.ofList_eq | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {l : List (α × β)},
Std.DHashMap.Raw.Const.ofList l =
↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany Std.DHashMap.Internal.Raw₀.emptyWithCapacity l) | null | true |
IsBaseChange.endHom._proof_2 | Mathlib.RingTheory.TensorProduct.IsBaseChangeHom | ∀ {S : Type u_1} [inst : CommSemiring S] {P : Type u_2} [inst_1 : AddCommMonoid P] [inst_2 : Module S P],
SMulCommClass S S (P →ₗ[S] P) | null | false |
StrongDual.polar_univ | Mathlib.Analysis.LocallyConvex.Polar | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] {E : Type u_5} [inst_1 : AddCommGroup E]
[inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E], StrongDual.polar 𝕜 Set.univ = {0} | null | true |
CategoryTheory.Limits.Fan.combPairHoms | Mathlib.CategoryTheory.Limits.Shapes.CombinedProducts | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{ι₁ : Type u_1} →
{ι₂ : Type u_2} →
{f₁ : ι₁ → C} →
{f₂ : ι₂ → C} →
(c₁ : CategoryTheory.Limits.Fan f₁) →
(c₂ : CategoryTheory.Limits.Fan f₂) →
(bc : CategoryTheory.Limits.BinaryFan c₁.p... | For fans on maps `f₁ : ι₁ → C`, `f₂ : ι₂ → C` and a binary fan on their
cone points, construct one family of morphisms indexed by `ι₁ ⊕ ι₂` | true |
Ideal.polynomialQuotientEquivQuotientPolynomial._proof_4 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (f g : Polynomial (R ⧸ I)),
(Polynomial.eval₂RingHom (Ideal.Quotient.lift I ((Ideal.Quotient.mk (Ideal.map Polynomial.C I)).comp Polynomial.C) ⋯)
((Ideal.Quotient.mk (Ideal.map Polynomial.C I)) Polynomial.X))
(f * g) =
(Polynomial.eval₂RingHom
... | null | false |
Lean.Omega.Constraint.isImpossible.match_1 | Init.Omega.Constraint | (motive : Lean.Omega.Constraint → Sort u_1) →
(x : Lean.Omega.Constraint) →
((x y : ℤ) → motive { lowerBound := some x, upperBound := some y }) →
((x : Lean.Omega.Constraint) → motive x) → motive x | null | false |
Submodule.isTopCompl_bot_top | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M], Submodule.IsTopCompl ⊥ ⊤ | null | true |
IncidenceAlgebra.instNonAssocSemiring | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | {𝕜 : Type u_2} →
{α : Type u_5} →
[inst : Preorder α] →
[LocallyFiniteOrder α] → [DecidableEq α] → [inst_3 : NonAssocSemiring 𝕜] → NonAssocSemiring (IncidenceAlgebra 𝕜 α) | null | true |
Matrix.of_symm_apply | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (f : Matrix m n α) (i : m) (j : n), Matrix.of.symm f i j = f i j | null | true |
Mathlib.Meta.Positivity.prod_ne_zero | Mathlib.Algebra.Order.BigOperators.Ring.Finset | ∀ {ι : Type u_1} {M₀ : Type u_4} [inst : CommMonoidWithZero M₀] {f : ι → M₀} {s : Finset ι} [Nontrivial M₀]
[NoZeroDivisors M₀], (∀ a ∈ s, f a ≠ 0) → ∏ x ∈ s, f x ≠ 0 | **Alias** of the reverse direction of `Finset.prod_ne_zero_iff`. | true |
LawfulBitraversable.const | Mathlib.Control.Bitraversable.Instances | LawfulBitraversable Functor.Const | null | true |
MonoidAlgebra.addCommGroup._proof_5 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R],
autoParam (∀ (a b : MonoidAlgebra R M), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
NormedRing.algEquivComplexOfComplete._proof_7 | Mathlib.Analysis.Normed.Algebra.GelfandFormula | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] (r : ℂ),
(↑↑(Algebra.ofId ℂ A).toRingHom).toFun ((algebraMap ℂ ℂ) r) = (algebraMap ℂ A) r | null | false |
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.AddMon.EquivLaxMonoidalFunctorPUnit.laxMonoidalToAddMon C =
{ obj := fun F => F.mapAddMon.obj (CategoryTheory.AddMon.trivial (CategoryTheory.Discrete PUnit.{w + 1})),
map := fun {X Y} α =... | null | true |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.deleteEdges_isLoopAt._simp_1_1 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_1} {β : Type u_2} (G : Graph α β) (F : Set β), G.deleteEdges F = G.restrict (G.edgeSet \ F) | null | false |
Aesop.Iteration | Aesop.Tree.Data | Type | null | true |
CategoryTheory.Limits.Trident.IsLimit.mk'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : C} {f : J → (X ⟶ Y)}
(t : CategoryTheory.Limits.Trident f)
(create :
(s : CategoryTheory.Limits.Trident f) →
{ l //
CategoryTheory.CategoryStruct.comp l t.ι = s.ι ∧
∀
{m :
((Cat... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.equiv_iff_toList_perm._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
NFA.eval | Mathlib.Computability.NFA | {α : Type u} → {σ : Type v} → NFA α σ → List α → Set σ | `M.eval x` computes all possible paths though `M` with input `x` starting at an element of
`M.start`. | true |
Units.oneSub.eq_1 | Mathlib.Analysis.Analytic.Constructions | ∀ {R : Type u_4} [inst : NormedRing R] [inst_1 : HasSummableGeomSeries R] (t : R) (h : ‖t‖ < 1),
Units.oneSub t h = { val := 1 - t, inv := ∑' (n : ℕ), t ^ n, val_inv := ⋯, inv_val := ⋯ } | null | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.857132795._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | IO (Lean.Option Bool) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics.0.tendsto_rpow_div_mul_add._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | null | false |
trdeg_eq_zero_iff | Mathlib.RingTheory.AlgebraicIndependent.Transcendental | ∀ {R : Type u_3} {A : Type v} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
Algebra.trdeg R A = 0 ↔ Algebra.IsAlgebraic R A | null | true |
instOneMulHom._proof_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass N] (x x : M), 1 = 1 * 1 | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.evalAdd.match_7 | Mathlib.Tactic.Ring.Common | (motive : Ordering → Sort u_1) → (x : Ordering) → (Unit → motive Ordering.lt) → ((x : Ordering) → motive x) → motive x | null | false |
_private.Mathlib.Probability.Kernel.Representation.0.ProbabilityTheory.Kernel.exists_measurable_map_eq_unitInterval_aux._simp_1_6 | Mathlib.Probability.Kernel.Representation | ∀ {q : ℚ} {K : Type u_5} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K], (0 ≤ ↑q) = (0 ≤ q) | null | false |
Real.floor_pi_eq_three | Mathlib.Analysis.Real.Pi.Bounds | ⌊Real.pi⌋ = 3 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.