name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Abelian.SpectralObject.cokernelSequenceE_exact._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
Mathlib.Tactic.Echelon.EntryCertifier.rec | Mathlib.Tactic.Echelon.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{motive : Mathlib.Tactic.Echelon.EntryCertifier α → Sort u} →
((eq : (a b : Q(«$α»)) → Lean.MetaM Q(«$a» = «$b»)) →
(neZero : (zα : Q(Zero «$α»)) → (a : Q(«$α»)) → Lean.MetaM Q(«$a» ≠ 0)) →
motive { eq := eq, neZero := neZero }) →
(t : Mathl... | null | false |
RCLike.inv_pos | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K] {z : K}, 0 < z⁻¹ ↔ 0 < z | null | true |
List.mapIdxM.go.eq_1 | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : ℕ → α → m β) (a : Array β),
List.mapIdxM.go f [] a = pure a.toList | null | true |
CategoryTheory.Comonad.coalgebraPreadditive._proof_7 | Mathlib.CategoryTheory.Preadditive.EilenbergMoore | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(U : CategoryTheory.Comonad C) [inst_2 : U.Additive] (F G : U.Coalgebra) (x x_1 x_2 : F ⟶ G),
x + x_1 + x_2 = x + (x_1 + x_2) | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.import._regBuiltin.Lean.Parser.Command.import.parenthesizer_11 | Lean.Parser.Command | IO Unit | null | false |
SimpleGraph.nonempty_dart_top | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} [Nontrivial V], Nonempty ⊤.Dart | null | true |
Filter.join._proof_3 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} (f : Filter (Filter α)), Set.univ ∈ {s | {t | s ∈ t} ∈ f} | null | false |
IsCyclotomicExtension.subsingleton_iff._simp_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (S : Set ℕ) (A : Type u) (B : Type v) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Subsingleton B], IsCyclotomicExtension S A B = (S ⊆ {0, 1}) | null | false |
tendsto_comp_coe_Ioo_atTop._simp_1 | Mathlib.Topology.Order.AtTopBotIxx | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X] {a b : X} {α : Type u_2}
{l : Filter α} {f : X → α},
a < b →
autoParam (Order.IsSuccPrelimit b) tendsto_comp_coe_Ioo_atTop._auto_1 →
Filter.Tendsto (fun x => f ↑x) Filter.atTop l = Filter.Tendsto f (nhdsWithin b (Set.I... | null | false |
CategoryTheory.Limits.ι_colimitFiberwiseColimitIso_inv_assoc | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} H]
(G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H)
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColimit ((F... | null | true |
Std.PRange.instToStreamRocIterIteratorOfUpwardEnumerable | Init.Data.Range.Polymorphic.Stream | {α : Type u_1} → [Std.PRange.UpwardEnumerable α] → Std.ToStream (Std.Roc α) (Std.Iter α) | null | true |
_private.Init.Data.SInt.Lemmas.0.ISize.neg_ne_zero._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {a b : ISize}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
SSet.StrictSegalCore.concat.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {X : SSet} {n : ℕ} (self self_1 : X.StrictSegalCore n),
self = self_1 →
∀ (x x_1 : X.obj (Opposite.op { len := 1 })) (e_x : x = x_1) (s s_1 : X.obj (Opposite.op { len := n }))
(e_s : s = s_1)
(h :
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ X 0)) x =
(Ca... | null | true |
extProc._@.Mathlib.Tactic.Attr.Register.612238087._hygCtx._hyg.3 | Mathlib.Tactic.Attr.Register | Lean.Meta.Simp.SimprocExtension | Simplification procedure | false |
HomotopyEquiv.mk._flat_ctor | Mathlib.Algebra.Homology.Homotopy | {ι : Type u_1} →
{V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{c : ComplexShape ι} →
{C D : HomologicalComplex V c} →
(hom : C ⟶ D) →
(inv : D ⟶ C) →
Homotopy (CategoryTheory.CategoryStruct.co... | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.parallelepiped_eq_sum_segment._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : Finset ι) (f : ι → Set α) (a : α),
(a ∈ ∑ i ∈ t, f i) = ∃ g, ∃ (_ : ∀ {i : ι}, i ∈ t → g i ∈ f i), ∑ i ∈ t, g i = a | null | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.Chain._simp_3 | Mathlib.Data.List.Cycle | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
Nat.Internal.Linear.ExprCnstr._sizeOf_inst | Init.Data.Nat.Internal.Linear | SizeOf Nat.Internal.Linear.ExprCnstr | null | false |
Matrix.conjTransposeRingEquiv | Mathlib.LinearAlgebra.Matrix.ConjTranspose | (m : Type u_2) →
(α : Type v) →
[inst : NonUnitalNonAssocSemiring α] →
[inst_1 : StarRing α] → [inst_2 : Fintype m] → Matrix m m α ≃⋆+* (Matrix m m α)ᵐᵒᵖ | `Matrix.conjTranspose` as a `StarRingEquiv` to the opposite ring | true |
String.toInt?_eq_none_iff._simp_1 | Std.Data.String.ToInt | ∀ {s : String}, (s.toInt? = none) = (s.isInt = false) | null | false |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_inf | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
Cardinal.lift.{w, v} (A.relran... | null | true |
QuotientGroup.completeSpace_left | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : Group G] [us : UniformSpace G] [inst_1 : IsLeftUniformGroup G] [FirstCountableTopology G]
(N : Subgroup G) [inst_3 : N.Normal] [hG : CompleteSpace G], CompleteSpace (G ⧸ N) | The quotient `G ⧸ N` of a complete first countable uniform group `G` by a normal subgroup
is itself complete. In contrast to `QuotientGroup.completeSpace_left'`, in this version `G` is
already equipped with a uniform structure.
[N. Bourbaki, *General Topology*, IX.3.1 Proposition 4][bourbaki1966b]
Even though `G` is e... | true |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L),
CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.lift (CochainComplex.mappingCone.inr φ)
(... | null | false |
NonarchAddGroupNorm.mk.inj | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {G : Type u_6} {inst : AddGroup G} {toNonarchAddGroupSeminorm : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero' : ∀ (x : G), toNonarchAddGroupSeminorm.toFun x = 0 → x = 0}
{toNonarchAddGroupSeminorm_1 : NonarchAddGroupSeminorm G}
{eq_zero_of_map_eq_zero'_1 : ∀ (x : G), toNonarchAddGroupSeminorm_1.toFun x = ... | null | true |
PMF.mem_support_iff | Mathlib.Probability.ProbabilityMassFunction.Basic | ∀ {α : Type u_1} (p : PMF α) (a : α), a ∈ p.support ↔ p a ≠ 0 | null | true |
AugmentedSimplexCategory.instMonoidalCategory._proof_4 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ {X₁ X₂ X₃ Y₁ Y₂ Y₃ : AugmentedSimplexCategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂) f₃)
(CategoryTheory.MonoidalCategoryStruct.associator Y₁ Y₂ Y₃).hom =
... | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_10 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (¬x < y) = (y ≤ x) | null | false |
Descriptive.Tree.take_mem | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} {T : ↥(Descriptive.tree A)} {n : ℕ} (x : ↥T), List.take n ↑x ∈ T | null | true |
CategoryTheory.preservesColimits_of_createsColimits_and_hasColimits | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.CreatesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F]
[CategoryTheory.Limits.HasColimitsOfSize.{w, w', v₂, u₂} D],
CategoryTheory.Limits.PreservesColi... | `F` preserves limits if it creates limits and `D` has limits. | true |
_private.Init.Core.0.decide_true.match_1_1 | Init.Core | ∀ (motive : Decidable True → Prop) (h : Decidable True),
(∀ (reflects_decide : True), motive { decide := true, reflects_decide := reflects_decide }) →
(∀ (h : ¬True), motive { decide := false, reflects_decide := h }) → motive h | null | false |
MvPolynomial.IsSymmetric.zero | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R], MvPolynomial.IsSymmetric 0 | null | true |
Multiset.countP_attach | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
Multiset.countP (fun a => p ↑a) s.attach = Multiset.countP p s | null | true |
NSMul | Mathlib.Algebra.Group.Monoid | Type u_2 → Type u_2 | `NSMul` is an implementation detail of `AddMonoid`. It is needed because it is
impossible to extend `SMul ℕ M` and `SMul ℤ M` at the same time. | true |
_private.Mathlib.Analysis.Complex.CauchyIntegral.0.Complex.two_pi_I_inv_smul_circleIntegral_sub_inv_smul_of_differentiable_on_off_countable._simp_1_1 | Mathlib.Analysis.Complex.CauchyIntegral | (Real.pi = 0) = False | null | false |
Std.HashSet.toList | Std.Data.HashSet.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → Std.HashSet α → List α | Transforms the hash set into a list of elements in some order. | true |
Std.ExtHashMap.mem_insert._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β}, (a ∈ m.insert k v) = ((k == a) = true ∨ a ∈ m) | null | false |
CompHausLike.LocallyConstant.counit._proof_4 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ (P : TopCat → Prop) [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u_1 + 1}] [inst_2 : CompHausLike.HasExplicitFiniteCoproducts P]
[inst_3 : CompHausLike.HasExplicitPullbacks P]
(hs :
∀ ⦃X Y : CompHausLike P⦄ (f : X ⟶ Y),
... | null | false |
unexpandMkArray3 | Init.NotationExtra | Lean.PrettyPrinter.Unexpander | null | true |
AlgebraicGeometry.Scheme.jointlySurjectiveTopology | Mathlib.AlgebraicGeometry.Sites.Pretopology | CategoryTheory.GrothendieckTopology AlgebraicGeometry.Scheme | The jointly surjective topology on `Scheme` is defined by the same condition as the jointly
surjective pretopology. | true |
_private.Lean.Language.Basic.0.Lean.Language.SnapshotTask.ReportingRange.ofOptionInheriting.match_1 | Lean.Language.Basic | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) → ((range : Lean.Syntax.Range) → motive (some range)) → (Unit → motive none) → motive x | null | false |
Prod.instReflLex_mathlib_1 | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [Std.Refl s], Std.Refl (Prod.Lex r s) | null | true |
Finsupp.DegLex.monotone_degree | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_1} [inst : LinearOrder α], Monotone fun x => Finsupp.degree (ofDegLex x) | null | true |
Mathlib.Tactic.Monoidal.StructuralOfExpr_monoidalComp | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h i : C} [inst_1 : CategoryTheory.MonoidalCoherence g h]
(η : f ⟶ g) (η' : f ≅ g),
η'.hom = η →
∀ (θ : h ⟶ i) (θ' : h ≅ i),
θ'.hom = θ → (CategoryTheory.monoidalIsoComp η' θ').hom = CategoryTheory.monoidalComp η θ | null | true |
_private.Mathlib.FieldTheory.Galois.Infinite.0.InfiniteGalois.fixingSubgroup_fixedField._simp_1_1 | Mathlib.FieldTheory.Galois.Infinite | ∀ {M : Type u_1} [inst : Mul M] {s : Subsemigroup M} {x : M}, (x ∈ s.carrier) = (x ∈ s) | null | false |
Std.Sat.CNF.Clause.relabel_relabel' | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {α_1 : Type u_2} {r1 : α → α_1} {α_2 : Type u_3} {r2 : α_2 → α},
Std.Sat.CNF.Clause.relabel r1 ∘ Std.Sat.CNF.Clause.relabel r2 = Std.Sat.CNF.Clause.relabel (r1 ∘ r2) | null | true |
Std.Net.instInhabitedSocketAddress.default | Std.Net.Addr | Std.Net.SocketAddress | null | true |
MulMemClass.isRightCancelMul | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} {A : Type u_3} [inst : Mul M] [inst_1 : SetLike A M] [hA : MulMemClass A M] [IsRightCancelMul M]
(S : A), IsRightCancelMul ↥S | A submagma of a right cancellative magma inherits right cancellation. | true |
Lean.Parser.atomicFn | Lean.Parser.Basic | Lean.Parser.ParserFn → Lean.Parser.ParserFn | null | true |
MeasureTheory.StronglyAdapted.isStronglyProgressive_of_discrete | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u : ι → Ω → β} [inst_2 : TopologicalSpace ι] [DiscreteTopology ι]
[SecondCountableTopology ι] [inst_5 : MeasurableSpace ι] [OpensMeasurableSpace ι]
[Topologi... | For filtrations indexed by a discrete order, `StronglyAdapted` and `IsStronglyProgressive` are
equivalent. This lemma provides `StronglyAdapted f u → IsStronglyProgressive f u`.
See `IsStronglyProgressive.stronglyAdapted` for the reverse direction, which is true more generally.
| true |
AlgebraicGeometry.μ_pullback_left_fst._proof_2 | Mathlib.AlgebraicGeometry.Group.Affine | ∀ (R S T : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T] [inst_3 : Algebra R S]
[inst_4 : Algebra R T],
Algebra.TensorProduct.includeRight.comp (algebraMap R T) = (algebraMap S (TensorProduct R S T)).comp (algebraMap R S) | null | false |
NonUnitalStarAlgebra.elemental | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | (R : Type u_1) →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : NonUnitalSemiring A] →
[inst_3 : StarRing A] →
[inst_4 : Module R A] →
[IsScalarTower R A A] →
[SMulCommClass R A A] →
[StarModule R A] ... | The topological closure of the non-unital star subalgebra generated by a single element. | true |
inhomogeneousCochains.d._proof_3 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Monoid G] (A : Rep.{u_2, u_1, u_1} k G) (n : ℕ) (r : k)
(f : (Fin n → G) → ↑A),
(fun g =>
(A.ρ (g 0)) ((r • f) fun i => g i.succ) +
∑ j, (-1) ^ (↑j + 1) • (r • f) (j.contractNth (fun x1 x2 => x1 * x2) g)) =
(RingHom.id k) r • fun g =>
(A.ρ (g ... | null | false |
LinearRecurrence.mkSol._proof_3 | Mathlib.Algebra.LinearRecurrence | ∀ {R : Type u_1} [inst : CommSemiring R] (E : LinearRecurrence R) (a : ℕ) (k : Fin E.order),
a - E.order + ↑k < a → InvImage (fun x1 x2 => x1 < x2) (fun x => x) (a - E.order + ↑k) a | null | false |
Submodule.mul_le | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {M N P : Submodule R A}, M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P | null | true |
Equiv.pSigmaAssoc._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : α → Sort u_2} (γ : (a : α) → β a → Sort u_3),
Function.RightInverse (fun x => ⟨⟨x.fst, x.snd.fst⟩, x.snd.snd⟩) fun x => ⟨x.fst.fst, ⟨x.fst.snd, x.snd⟩⟩ | null | false |
OpenPartialHomeomorph.univUnitBall_apply | Mathlib.Analysis.Normed.Module.Ball.Homeomorph | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] (x : E),
↑OpenPartialHomeomorph.univUnitBall x = (√(1 + ‖x‖ ^ 2))⁻¹ • x | null | true |
Int32.toISize_le | Init.Data.SInt.Lemmas | ∀ {a b : Int32}, a.toISize ≤ b.toISize ↔ a ≤ b | null | true |
ModuleCat.MonoidalCategory.instBraidedSemimoduleCatFunctorEquivalenceSemimoduleCat | Mathlib.Algebra.Category.ModuleCat.Monoidal.Symmetric | {R : Type u} → [inst : CommRing R] → ModuleCat.equivalenceSemimoduleCat.functor.Braided | null | true |
LSeries_one_mul_Lseries_moebius | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {s : ℂ}, 1 < s.re → LSeries 1 s * LSeries (fun n => ↑(ArithmeticFunction.moebius n)) s = 1 | The L-series of the constant sequence `1` and of the Möbius function are inverses. | true |
Std.DTreeMap.Internal.Impl.Const.toListModel_alter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{t : Std.DTreeMap.Internal.Impl α fun x => β} {a : α} {f : Option β → Option β},
t.Balanced →
t.Ordered →
(Std.DTreeMap.Internal.Impl.Const.alter! a f t).toListModel.Perm
(Std.Internal.List.Const.alte... | null | true |
PFun.graph' | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (α →. β) → SetRel α β | Graph of a partial function as a relation. `x` and `y` are related iff `f x` is defined and
"equals" `y`. | true |
AlgebraicGeometry.Scheme.isoOfEq_inv_ι_assoc | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme) {U V : X.Opens} (e : U = V) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.isoOfEq e).inv (CategoryTheory.CategoryStruct.comp U.ι h) =
CategoryTheory.CategoryStruct.comp V.ι h | null | true |
CategoryTheory.GrpObj.lift_inv_left_eq | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.GrpObj B] (f g h : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift (CategoryTheory.CategoryStruct.comp f CategoryTheo... | null | true |
ModuleCat.HasColimit.reflectsColimit | Mathlib.Algebra.Category.ModuleCat.Colimits | ∀ {R : Type w} [inst : Ring R] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[CategoryTheory.Limits.HasColimit (F.comp (CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat))],
CategoryTheory.Limits.ReflectsColimit F (CategoryTheory.forget₂ (ModuleCat R) AddCo... | null | true |
Std.TreeMap.getElem?_eq_some_getElem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a : α} (h : a ∈ t),
t[a]? = some t[a] | null | true |
Nat.compare_eq_ite_lt | Init.Data.Nat.Compare | ∀ (a b : ℕ), compare a b = if a < b then Ordering.lt else if b < a then Ordering.gt else Ordering.eq | null | true |
ImportGraph.Shake.NeedsKind.transitiveClosureSingle | ImportGraph.Shake.Algebra | {H : Type u_1} → [ImportGraph.Shake.Hierarchy H] → ℕ → ImportGraph.Shake.NeedsKind → H → ImportGraph.Shake.Needs | Given an import hierarchy of arrows `j' [_⟩ j` and a preimport `i [imp⟩ ·`, forms the set of
prearrows obtained by transitively closing `i [imp⟩ ·` with respect to the import hierarchy. This
is `i [imp⟩ ·` together with compositions `j [_⟩ i [imp⟩ ·`. `transDeps` is assumed to be
reflexified. | true |
num_smul_one_lt_den_smul_add | Mathlib.Basic.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [IsOrderedAddMonoid M] [inst_3 : One M] {u v : ℚ}
{x y : M}, u.num • 1 < u.den • x → v.num • 1 < v.den • y → (u + v).num • 1 < (u + v).den • (x + y) | For `u v : ℚ` and `x y : M`, one can informally write
`u < x → v < y → u + v < x + y`. We formalize this using smul. | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.lift_f_snd_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ (p q : ℤ), p + 0 = q → q = p | null | false |
Aesop.ForwardRuleMatch.mk.inj | Aesop.Forward.Match.Types | ∀ {rule : Aesop.ForwardRule} {«match» : Aesop.CompleteMatch} {rule_1 : Aesop.ForwardRule}
{match_1 : Aesop.CompleteMatch},
{ rule := rule, «match» := «match» } = { rule := rule_1, «match» := match_1 } → rule = rule_1 ∧ «match» = match_1 | null | true |
CategoryTheory.Limits.ChosenPullback.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ S : C} →
{f₁ : X₁ ⟶ S} →
{f₂ : X₂ ⟶ S} →
(pullback : C) →
(p₁ : pullback ⟶ X₁) →
(p₂ : pullback ⟶ X₂) →
(condition : CategoryTheory.CategoryStruct.comp p₁ f₁ = CategoryTheory.Categor... | null | false |
List.nodup_permutations_iff | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {s : List α}, s.permutations.Nodup ↔ s.Nodup | null | true |
Plausible.TotalFunction.zeroDefault.eq_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type u} {β : Type v} [inst : Zero β] (A : List ((_ : α) × β)) (a : β),
(Plausible.TotalFunction.withDefault A a).zeroDefault = Plausible.TotalFunction.withDefault A 0 | null | true |
Associates.one_or_eq_of_le_of_prime | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [IsCancelMulZero M] {p m : Associates M}, Prime p → m ≤ p → m = 1 ∨ m = p | null | true |
Set.infsep_of_fintype._proof_1 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s], s.Nontrivial → s.offDiag.toFinset.Nonempty | null | false |
partialOrderOfSO.match_5 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) (x : α) (motive : (y : α) → x = y ∨ r x y → y = x ∨ r y x → Prop) (y : α)
(h₁ : x = y ∨ r x y) (h₂ : y = x ∨ r y x),
(∀ (x_1 : x = x ∨ r x x), motive x ⋯ x_1) →
(∀ (x_1 : x = x ∨ r x x), motive x x_1 ⋯) →
(∀ (x_1 : α) (h₁ : r x x_1) (h₂ : r x_1 x), motive x_1 ⋯ ⋯) → mot... | null | false |
le_bihimp_iInf | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] {f : ι → α} [Nonempty ι] {a : α},
⨅ i, bihimp a (f i) ≤ bihimp a (⨅ i, f i) | null | true |
Set.Finite.inter_of_left | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∀ (t : Set α), (s ∩ t).Finite | null | true |
RingOfIntegers.exponent_eq_one_iff | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K}, RingOfIntegers.exponent θ = 1 ↔ ℤ[θ] = ⊤ | null | true |
GradedTensorProduct.instRing._proof_17 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
CategoryTheory.FreeBicategory.normalizeIso_comp | Mathlib.CategoryTheory.Bicategory.Coherence | ∀ {B : Type u} [inst : Quiver B] {a : B} {b c d : CategoryTheory.FreeBicategory B} (p : Quiver.Path a b) (f : b ⟶ c)
(g : c ⟶ d),
CategoryTheory.FreeBicategory.normalizeIso p (CategoryTheory.CategoryStruct.comp f g) =
(CategoryTheory.Bicategory.associator ((CategoryTheory.FreeBicategory.preinclusion B).map { as... | null | true |
Lean.Meta.Grind.Arith.CommRing.MonadRing.recOn | Lean.Meta.Tactic.Grind.Arith.CommRing.MonadRing | {m : Type → Type} →
{motive : Lean.Meta.Grind.Arith.CommRing.MonadRing m → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.MonadRing m) →
((getRing : m Lean.Meta.Grind.Arith.CommRing.Ring) →
(modifyRing : (Lean.Meta.Grind.Arith.CommRing.Ring → Lean.Meta.Grind.Arith.CommRing.Ring) → m Unit) →
... | null | false |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_7 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
CauSeq.IsComplete.isComplete | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} {inst : Field α} {inst_1 : LinearOrder α} {inst_2 : IsStrictOrderedRing α} {β : Type u_2}
{inst_3 : Ring β} {abv : β → α} {inst_4 : IsAbsoluteValue abv} [self : CauSeq.IsComplete β abv] (s : CauSeq β abv),
∃ b, s ≈ CauSeq.const abv b | Every Cauchy sequence has a limit. | true |
SeparationQuotient.exists_out_continuousLinearMap | Mathlib.Topology.Algebra.SeparationQuotient.Section | ∀ (K : Type u_1) (E : Type u_2) [inst : DivisionRing K] [inst_1 : AddCommGroup E] [inst_2 : Module K E]
[inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalAddGroup E] [inst_5 : ContinuousConstSMul K E],
∃ f, SeparationQuotient.mkCLM K E ∘SL f = ContinuousLinearMap.id K (SeparationQuotient E) | There exists a continuous `K`-linear map from `SeparationQuotient E` to `E`
such that `mk (outCLM x) = x` for all `x`.
Note that continuity of this map comes for free, because `mk` is a topology inducing map.
| true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate.0.SSet.ιNormalizedChainComplex._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | IsRightCancelAdd ℕ | null | false |
CategoryTheory.CoreSmallCategoryOfSet.functor | Mathlib.CategoryTheory.SmallRepresentatives | {Ω : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(h : CategoryTheory.CoreSmallCategoryOfSet Ω C) → CategoryTheory.Functor (↑h.smallCategoryOfSet.obj) C | Given `h : CoreSmallCategoryOfSet Ω C`, this is the
obvious functor `h.smallCategoryOfSet.obj ⥤ C`. | true |
BoundedLatticeHom.dual._proof_4 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_1} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : Lattice β]
[inst_3 : BoundedOrder β] (f : BoundedLatticeHom αᵒᵈ βᵒᵈ), f.toFun ⊤ = ⊤ | null | false |
CategoryTheory.Comonad.Coalgebra | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Comonad C → Type (max u₁ v₁) | An Eilenberg-Moore coalgebra for a comonad `T`. | true |
CategoryTheory.PreOneHypercover.IsStronglySheafFor.map_amalgamate | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {E : CategoryTheory.PreOneHypercover X}
{F : CategoryTheory.Functor Cᵒᵖ (Type u_2)} (h : E.IsStronglySheafFor F)
(x : (i : E.I₀) → F.obj (Opposite.op (E.X i)))
(hc :
∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j),
(CategoryTheory.ConcreteCategory.hom... | null | true |
Std.HashMap.erase_emptyWithCapacity | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ},
(Std.HashMap.emptyWithCapacity c).erase a = Std.HashMap.emptyWithCapacity c | null | true |
_private.Mathlib.Dynamics.Ergodic.Extreme.0.Ergodic.of_mem_extremePoints._simp_1_1 | Mathlib.Dynamics.Ergodic.Extreme | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.IsProbabilityMeasure μ = (μ Set.univ = 1) | null | false |
PseudoMetric.IsUltra.sup | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : AddZeroClass R] [inst_1 : SemilatticeSup R] [inst_2 : AddLeftMono R]
[inst_3 : AddRightMono R] {d d' : PseudoMetric X R} [d.IsUltra] [d'.IsUltra], (d ⊔ d').IsUltra | null | true |
instBooleanAlgebraAsBoolAlg._proof_6 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a b : AsBoolAlg α), b ≤ Add.add (a + b) (a * b) | null | false |
CategoryTheory.NatTrans.instCommShiftOppositeShiftHomFunctorNatIsoComp | Mathlib.CategoryTheory.Shift.Opposite | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] (F : CategoryTheory.Functor C D)
{E : Type u_4} [inst_5 : CategoryTheory... | null | true |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.IsCompact.nhdsSet_basis_isCompact._proof_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {K : Set X} ⦃s t : Set X⦄,
s ⊆ t → (∃ r ∈ nhdsSet K, IsCompact r ∧ r ⊆ s) → ∃ r ∈ nhdsSet K, IsCompact r ∧ r ⊆ t | null | false |
Std.MaxEqOr.max_eq_or | Init.Data.Order.Classes | ∀ {α : Type u} {inst : Max α} [self : Std.MaxEqOr α] (a b : α), a ⊔ b = a ∨ a ⊔ b = b | null | true |
IntermediateField.coe_algebraMap_over_bot | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
⇑(algebraMap (↥⊥) F) = ⇑(IntermediateField.botEquiv F E) | null | true |
minimal_ge_iff._simp_2 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {x y : α} [inst : PartialOrder α], Minimal (fun x => y ≤ x) x = (x = y) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.