name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SymbolicDynamics.FullShift.Pattern.condition | Mathlib.Dynamics.SymbolicDynamics.Basic | ∀ {A : Type u_1} {G : Type u_2} [inst : Inhabited A] (self : SymbolicDynamics.FullShift.Pattern A G),
∀ g ∉ self.support, self.config g = default | Outside the support, `config` takes the default value of `A`. | true |
NormedSpace.ofReal_exp_ℝ_ℝ._simp_1 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ (r : ℝ), NormedSpace.exp ↑r = ↑(NormedSpace.exp r) | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn?_cons._simp_1_2 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {le : LE α} {a b : α}, (a ≤ b) = (b ≤ a) | null | false |
_private.Batteries.Data.Fin.Coding.0.Fin.encodePi.match_1.splitter | Batteries.Data.Fin.Coding | (n : ℕ) → (motive : Fin n → Sort u_1) → (x : Fin n) → ((i : ℕ) → (hi : i < n) → motive ⟨i, hi⟩) → motive x | null | true |
NonemptyInterval.toProd_nsmul | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddMonoid α] [inst_1 : Preorder α] [inst_2 : AddLeftMono α] [inst_3 : AddRightMono α]
(s : NonemptyInterval α) (n : ℕ), (n • s).toProd = n • s.toProd | null | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.subgroup_strong_bound_right | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G},
↑(A * A).card < 3 / 2 * ↑A.card → ∀ a ∈ A, a • MulOpposite.op a • (A⁻¹ * A) ⊆ A * A | null | true |
GroupExtension.IsConj.symm | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
(S : GroupExtension N E G) {s₁ s₂ : S.Splitting}, S.IsConj s₁ s₂ → S.IsConj s₂ s₁ | `N`-conjugacy is symmetric. | true |
csSup_empty | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α], sSup ∅ = ⊥ | null | true |
CategoryTheory.EnrichedCategory.comp_id | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} {inst : CategoryTheory.Category.{w, v} V} {inst_1 : CategoryTheory.MonoidalCategory V} {C : Type u₁}
[self : CategoryTheory.EnrichedCategory V C] (X Y : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.rightUnitor (X ⟶[V] Y)).inv
(CategoryTheory.CategoryStruct.comp
... | null | true |
Polynomial.coeff_monomial | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a : R} {m n : ℕ} [inst : Semiring R], ((Polynomial.monomial n) a).coeff m = if n = m then a else 0 | null | true |
Equiv.piCongrLeft_preimage_univ_pi | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} (f : ι' ≃ ι) (t : (i : ι) → Set (α i)),
⇑(Equiv.piCongrLeft α f) ⁻¹' Set.univ.pi t = Set.univ.pi fun i => t (f i) | null | true |
Zsqrtd.lift._proof_7 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {R : Type u_1} [inst : CommRing R] {d : ℤ} (f : ℤ√d →+* R),
(fun r => { toFun := fun a => ↑a.re + ↑a.im * ↑r, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ })
((fun f => ⟨f Zsqrtd.sqrtd, ⋯⟩) f) =
f | null | false |
SSet.prodStdSimplex.pairingCore.IsType₂.type₁_x | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
(hx : SSet.prodStdSimplex.pairingCore.IsType₂ x) {d : ℕ} (hd : x.dim = d),
(hx.type₁ hd).x = SSet.Subcomplex.N.mk (hx.simplex hd) ⋯ ⋯ | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.emod_sub_cancel_left._simp_1_4 | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, (a ∣ -b) = (a ∣ b) | null | false |
Tactic.ComputeAsymptotics.Monomial.inv_length | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ (t : Tactic.ComputeAsymptotics.Monomial), List.length t.inv.unit = List.length t.unit | null | true |
String.Slice.Pos.sliceTo_eq_endPos | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p : s.Pos}, p.sliceTo p ⋯ = (s.sliceTo p).endPos | null | true |
Std.Do.SPred.entails_nil_pure_intro | Std.Do.SPred.SPred | ∀ {φ : Prop} {Q : Std.Do.SPred []}, (φ → Q.down) → ⌜φ⌝ ⊢ₛ Q | null | true |
Lean.Widget.InteractiveGoal.mk.injEq | Lean.Widget.InteractiveGoal | ∀ (toInteractiveGoalCore : Lean.Widget.InteractiveGoalCore) (userName? : Option String) (goalPrefix : String)
(mvarId : Lean.MVarId) (isInserted? isRemoved? : Option Bool)
(toInteractiveGoalCore_1 : Lean.Widget.InteractiveGoalCore) (userName?_1 : Option String) (goalPrefix_1 : String)
(mvarId_1 : Lean.MVarId) (is... | null | true |
Real.volume_pi_Ioo_toReal | Mathlib.MeasureTheory.Measure.Lebesgue.Basic | ∀ {ι : Type u_1} [inst : Fintype ι] {a b : ι → ℝ},
a ≤ b → (MeasureTheory.volume (Set.univ.pi fun i => Set.Ioo (a i) (b i))).toReal = ∏ i, (b i - a i) | null | true |
CategoryTheory.Adjunction.leftAdjointUniq_hom_counit_assoc | Mathlib.CategoryTheory.Adjunction.Unique | ∀ {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] {F F' : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj1 : F ⊣ G) (adj2 : F' ⊣ G) {Z : CategoryTheory.Functor D D} (h : CategoryTheory.Functor.id D ⟶ Z),
CategoryTheory.C... | null | true |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.cotangentEquivProd._proof_1 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
{P : Algebra.Generators R S ι} {σ : Type u_4} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
SMulCommClass (Algebra.Generators.Presentation... | null | false |
LinearMap.dualMap | Mathlib.LinearAlgebra.Dual.Defs | {R : Type u_1} →
{M₁ : Type u_2} →
{M₂ : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : Module R M₁] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M₂] → (M₁ →ₗ[R] M₂) → Module.Dual R M₂ →ₗ[R] Module.Dual R M₁ | Given a linear map `f : M₁ →ₗ[R] M₂`, `f.dualMap` is the linear map between the dual of
`M₂` and `M₁` such that it maps the functional `φ` to `φ ∘ f`. | true |
Lean.Grind.Order.le_lt_trans | Init.Grind.Order | ∀ {α : Type u_1} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] [Std.IsPreorder α] {a b c : α},
a ≤ b → b < c → a < c | null | true |
HomologicalComplex.unop._proof_1 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {c : ComplexShape ι}
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (X : HomologicalComplex Vᵒᵖ c) (i j : ι),
¬c.symm.Rel i j → (X.d j i).unop = 0 | null | false |
CategoryTheory.Limits.WidePullbackShape.struct | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} → CategoryTheory.CategoryStruct.{w, w} (CategoryTheory.Limits.WidePullbackShape J) | null | true |
FirstOrder.Language.ElementarySubstructure.mk | Mathlib.ModelTheory.ElementarySubstructures | {L : FirstOrder.Language} →
{M : Type u_1} →
[inst : L.Structure M] →
(toSubstructure : L.Substructure M) → toSubstructure.IsElementary → L.ElementarySubstructure M | null | true |
Algebra.PreSubmersivePresentation.baseChange_ring | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.PreSubmersivePresentation R S ι σ), (Algebra.PreSubmersivePresentation.baseChange R P).Ring = P.Ring | null | true |
ContIntertwiningMap.comp | Mathlib.RepresentationTheory.Continuous.Basic | {R : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
{U : Type u_5} →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
... | The composition of two continuous intertwining maps is a continuous intertwining map. | true |
CategoryTheory.NatIso.pi._proof_4 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_3} {C : I → Type u_1} [inst : (i : I) → CategoryTheory.Category.{u_5, u_1} (C i)] {D : I → Type u_4}
[inst_1 : (i : I) → CategoryTheory.Category.{u_2, u_4} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)}
(e : (i : I) → F i ≅ G i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTra... | null | false |
String.Slice.RevByteIterator.instFiniteUInt8 | Init.Data.String.Iterate | ∀ {m : Type → Type u_1} [inst : Pure m], Std.Iterators.Finite String.Slice.RevByteIterator m | null | true |
Lean.Lsp.RpcConnected._sizeOf_inst | Lean.Data.Lsp.Extra | SizeOf Lean.Lsp.RpcConnected | null | false |
SimpleGraph.Walk.IsSubwalk.map | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G G' : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'},
p₂.IsSubwalk p₁ → ∀ (f : G →g G'), (SimpleGraph.Walk.map f p₂).IsSubwalk (SimpleGraph.Walk.map f p₁) | null | true |
_private.Mathlib.Analysis.Complex.Poisson.0.circleAverage_re_smul_on_ball_zero_aux._proof_1_2 | Mathlib.Analysis.Complex.Poisson | ∀ {R φ θ r : ℝ},
(R * (Real.cos θ + (Real.sin θ * 0 - 0 * 1)) - 0 * (0 + (Real.sin θ * 1 + 0 * 0))) *
(R * (Real.cos θ + (Real.sin θ * 0 - 0 * 1)) - 0 * (0 + (Real.sin θ * 1 + 0 * 0)) -
(r * (Real.cos φ + (Real.sin φ * 0 - 0 * 1)) - 0 * (0 + (Real.sin φ * 1 + 0 * 0)))) /
((R ... | null | false |
_private.Lean.Elab.Term.0.Lean.Elab.initFn._regBuiltin._private.Lean.Elab.Term.0.Lean.Elab.initFn.docString_1._@.Lean.Elab.Term.2114473129._hygCtx._hyg.2 | Lean.Elab.Term | IO Unit | null | false |
AddLECancellable.le_add_iff_nonneg_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {a b : α} [inst : LE α] [inst_1 : AddZeroClass α] [AddLeftMono α],
AddLECancellable a → (a ≤ a + b ↔ 0 ≤ b) | null | true |
Complex.arg_neg_eq_arg_add_pi_of_im_neg | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {x : ℂ}, x.im < 0 → (-x).arg = x.arg + Real.pi | null | true |
CategoryTheory.ProjectiveResolution.extLinearEquivCohomologyClass_symm_apply | Mathlib.CategoryTheory.Abelian.Projective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.ProjectiveResolution X) {n : ℕ} {R₀ : Type u_1}
[inst_3 : Ring R₀] [inst_4 : CategoryTheory.Linear R₀ C]
(a : CochainComplex.HomComplex.CohomologyClass R.co... | null | true |
_private.Init.Data.Order.LemmasExtra.0.Std.instOrientedOrdOfLawfulOrderOrd._simp_5 | Init.Data.Order.LemmasExtra | ∀ {o : Ordering}, (o.swap = Ordering.gt) = (o = Ordering.lt) | null | false |
Set.Ioc_union_Ici_eq_Ioi | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a < b → Set.Ioc a b ∪ Set.Ici b = Set.Ioi a | null | true |
Algebra.mem_adjoin_iff | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] {s : Set A} {x : A},
x ∈ Algebra.adjoin R s ↔ x ∈ Subring.closure (Set.range ⇑(algebraMap R A) ∪ s) | null | true |
Con.instInfSet | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} → [inst : Mul M] → InfSet (Con M) | The infimum of a set of congruence relations on a given type with a multiplication. | true |
CategoryTheory.Span.mkIso | Mathlib.CategoryTheory.Bicategory.Span.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{Wₗ Wᵣ : CategoryTheory.MorphismProperty C} →
{c c' : C} →
{S S' : CategoryTheory.Span Wₗ Wᵣ c c'} →
(e : S.apex ≅ S'.apex) →
autoParam (CategoryTheory.CategoryStruct.comp e.hom S'.l = S.l) CategoryTheory.Span.mkI... | Construct an isomorphism of spans from an isomorphism between the
apices that is compatible with the projections. | true |
Option.guard_comp | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {p : α → Bool} {f : β → α}, Option.guard p ∘ f = Option.map f ∘ Option.guard (p ∘ f) | null | true |
QuasispectrumRestricts.nonUnitalStarAlgHom._proof_11 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ {R : Type u_1} {S : Type u_2} [inst : Semifield R] [inst_1 : Field S] [inst_2 : TopologicalSpace S]
[IsTopologicalRing S] [inst_4 : Algebra R S], ContinuousConstSMul R S | null | false |
_private.Mathlib.CategoryTheory.Adjunction.Comma.0.eq_iff_true_of_subsingleton._simp_2 | Mathlib.CategoryTheory.Adjunction.Comma | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
CategoryTheory.Grp.forget₂Mon_obj_one | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(A : CategoryTheory.Grp C), CategoryTheory.MonObj.one = CategoryTheory.MonObj.one | null | true |
orderTopology_of_nhds_abs | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_3} [inst : TopologicalSpace α] [inst_1 : AddCommGroup α] [inst_2 : LinearOrder α] [IsOrderedAddMonoid α],
(∀ (a : α), nhds a = ⨅ r, ⨅ (_ : r > 0), Filter.principal {b | |a - b| < r}) → OrderTopology α | null | true |
CompactCoherentification.continuous_mk_symm | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous ⇑(CompactCoherentification.mk X).symm | null | true |
Asymptotics.IsLittleO.neg_left | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {F : Type u_3} {E' : Type u_4} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{f' : α → E'} {l : Filter α}, f' =o[l] g → (fun x => -f' x) =o[l] g | **Alias** of the reverse direction of `Asymptotics.isLittleO_neg_left`. | true |
LieModule.weight_vector_multiplication | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u_2} {L : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (M₁ : Type u_5)
(M₂ : Type u_6) (M₃ : Type u_7) [inst_3 : AddCommGroup M₁] [inst_4 : Module R M₁] [inst_5 : LieRingModule L M₁]
[inst_6 : LieModule R L M₁] [inst_7 : AddCommGroup M₂] [inst_8 : Module R M₂] [inst_9 : L... | See also `bourbaki1975b` Chapter VII §1.1, Proposition 2 (ii). | true |
Std.Do.Spec.throw_ReaderT | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {sh : Std.Do.PostShape} {ε : Type u_1} {ρ α : Type u} {e : ε}
{Q : Std.Do.PostCond α (Std.Do.PostShape.arg ρ sh)} [inst : Std.Do.WP m sh] [inst_1 : MonadExceptOf ε m],
⦃(Std.Do.wp (MonadLift.monadLift (MonadExceptOf.throw e))).apply Q⦄ MonadExceptOf.throw e ⦃Q⦄ | null | true |
ContMDiffConstVAdd.rec | Mathlib.Geometry.Manifold.Algebra.SMul | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{H : Type u_2} →
[inst_1 : TopologicalSpace H] →
{E : Type u_3} →
[inst_2 : NormedAddCommGroup E] →
[inst_3 : NormedSpace 𝕜 E] →
{I : ModelWithCorners 𝕜 E H} →
{n : WithTop ℕ∞} →
... | null | false |
Function.Semiconj.surjOn_image | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {fa : α → α} {fb : β → β} {f : α → β} {s t : Set α},
Function.Semiconj f fa fb → Set.SurjOn fa s t → Set.SurjOn fb (f '' s) (f '' t) | null | true |
ContinuousOn.div' | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u_1} {X : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace G] [inst_2 : Div G]
[ContinuousDiv G] {f g : X → G} {s : Set X}, ContinuousOn f s → ContinuousOn g s → ContinuousOn (f / g) s | null | true |
TestFunction._sizeOf_1 | Mathlib.Analysis.Distribution.TestFunction | {E : Type u_3} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{Ω : TopologicalSpace.Opens E} →
{F : Type u_4} →
{inst_2 : NormedAddCommGroup F} →
{inst_3 : NormedSpace ℝ F} → {n : ℕ∞} → [SizeOf E] → [SizeOf F] → TestFunction Ω F n → ℕ | null | false |
CategoryTheory.Pi.sumElimCategory._proof_17 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_1} (C : I → Type u_2) {J : Type u_1} {D : J → Type u_2}
[inst : (j : J) → CategoryTheory.Category.{u_3, u_2} (D j)] (j : J),
autoParam
(∀ {X Y : Sum.elim C D (Sum.inr j)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.c... | null | false |
Bundle.Pretrivialization.continuousLinearMap_symm_apply' | Mathlib.Topology.VectorBundle.Hom | ∀ {𝕜₁ : Type u_1} [inst : NontriviallyNormedField 𝕜₁] {𝕜₂ : Type u_2} [inst_1 : NontriviallyNormedField 𝕜₂]
(σ : 𝕜₁ →+* 𝕜₂) {B : Type u_3} {F₁ : Type u_4} [inst_2 : NormedAddCommGroup F₁] [inst_3 : NormedSpace 𝕜₁ F₁]
{E₁ : B → Type u_5} [inst_4 : (x : B) → AddCommGroup (E₁ x)] [inst_5 : (x : B) → Module 𝕜₁ ... | null | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.intMinSealed.eq_1 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ), BitVec.Signed.intMinSealed✝ n = ↑(2 ^ (n - 1)) | null | true |
Summable.of_add_one_of_neg_add_one | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] [ContinuousAdd M] {f : ℤ → M},
(Summable fun n => f (↑n + 1)) → (Summable fun n => f (-(↑n + 1))) → Summable f | null | true |
_private.Mathlib.CategoryTheory.Presentable.Type.0.CategoryTheory.Types.instIsCardinalLocallyPresentableType._simp_1 | Mathlib.CategoryTheory.Presentable.Type | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] {X : C} {P : CategoryTheory.ObjectProperty C},
(CategoryTheory.ObjectProperty.singleton X ≤ P) = P X | null | false |
_private.Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional.0.PositiveContinuousLinearMap.tendsto_nhds_opNorm._proof_1_2 | Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional | (1 + 1).AtLeastTwo | null | false |
CochainComplex.mappingCone.liftCochain | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{F G : CochainComplex C ℤ} →
(φ : F ⟶ G) →
[inst_2 : HomologicalComplex.HasHomotopyCofiber φ] →
{K : CochainComplex C ℤ} →
{n m : ℤ} →
CochainC... | Given `φ : F ⟶ G`, this is the cochain in `Cochain (mappingCone φ) K n` that is
constructed from two cochains `α : Cochain F K m` (with `m + 1 = n`) and `β : Cochain F K n`. | true |
TopCat.Presheaf.IsFlasque.pushforward_isFlasque | Mathlib.Topology.Sheaves.Flasque | ∀ {X : TopCat} {C : Type v} [inst : CategoryTheory.Category.{w, v} C] (F : TopCat.Presheaf C X) {Y : TopCat}
[F.IsFlasque] (f : X ⟶ Y), ((TopCat.Presheaf.pushforward C f).obj F).IsFlasque | null | true |
CategoryTheory.GradedObject.singleObjApplyIso | 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 : C) → (CategoryTheory.GradedObject.single j).obj X j ≅ X | The canonical isomorphism `(single j).obj X j ≅ X`. | true |
connectedComponentIn_eq | Mathlib.Topology.Connected.Basic | ∀ {α : Type u} [inst : TopologicalSpace α] {x y : α} {F : Set α},
y ∈ connectedComponentIn F x → connectedComponentIn F x = connectedComponentIn F y | null | true |
Mathlib.Tactic.ITauto._aux_Mathlib_Tactic_ITauto___elabRules_Mathlib_Tactic_ITauto_itauto_1 | Mathlib.Tactic.ITauto | Lean.Elab.Tactic.Tactic | null | false |
ZeroAtInftyContinuousMap.coe_mk | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : Zero β] {f : α → β}
(hf : Continuous f) (hf' : Filter.Tendsto f (Filter.cocompact α) (nhds 0)),
⇑{ toFun := f, continuous_toFun := hf, zero_at_infty' := hf' } = f | null | true |
Inclusion.IntervalBool.and.eq_4 | Mathlib.Tactic.Inclusion.Core.ToSet | ∀ (x x_1 : Inclusion.IntervalBool),
(x = Inclusion.IntervalBool.false → False) →
(x_1 = Inclusion.IntervalBool.false → False) →
(x = Inclusion.IntervalBool.true → x_1 = Inclusion.IntervalBool.true → False) →
x.and x_1 = Inclusion.IntervalBool.undetermined | null | true |
hasMFDerivWithinAt_congr_set | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
Lean.Widget.GetWidgetsResponse.mk.sizeOf_spec | Lean.Widget.UserWidget | ∀ (widgets : Array Lean.Widget.PanelWidgetInstance), sizeOf { widgets := widgets } = 1 + sizeOf widgets | null | true |
Maximal.and_right | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P Q : α → Prop} {x : α} [inst : LE α], Maximal P x → Q x → Maximal (fun x => P x ∧ Q x) x | null | true |
CategoryTheory.Center.isIso_of_f_isIso | Mathlib.CategoryTheory.Monoidal.Center | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : CategoryTheory.Center C} (f : X ⟶ Y) [CategoryTheory.IsIso f.f], CategoryTheory.IsIso f | null | true |
Filter.sets_ssubset_sets | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f g : Filter α}, f.sets ⊂ g.sets ↔ g < f | null | true |
Dyadic.neg_mul | Init.Data.Dyadic.Basic | ∀ (x y : Dyadic), -x * y = -(x * y) | null | true |
Ordnode.ctorElimType | Mathlib.Data.Ordmap.Ordnode | {α : Type u} → {motive : Ordnode α → Sort u_1} → ℕ → Sort (max 1 u_1 (imax (u + 1) (u + 1) (u + 1) u_1)) | null | false |
CategoryTheory.ReflQuiver.noConfusion | Mathlib.Combinatorics.Quiver.ReflQuiver | {P : Sort u_1} →
{obj : Type u} →
{t : CategoryTheory.ReflQuiver obj} →
{obj' : Type u} →
{t' : CategoryTheory.ReflQuiver obj'} → obj = obj' → t ≍ t' → CategoryTheory.ReflQuiver.noConfusionType P t t' | null | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.skippingBinders.loop._unsafe_rec | Lean.PrettyPrinter.Delaborator.Builtins | {α : Type} →
ℕ →
Array Lean.Name →
(Array Lean.Name → Lean.PrettyPrinter.Delaborator.DelabM α) →
ℕ → Array Lean.Name → Lean.PrettyPrinter.Delaborator.DelabM α | null | false |
LieSubmodule.map_incl_le._simp_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {N : LieSubmodule R L M} {N' : LieSubmodule R L ↥N},
(LieSubmodule.map N.incl N' ≤ N) = True | null | false |
MulRingNorm.noConfusionType | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | Sort u →
{R : Type u_2} →
[inst : NonAssocRing R] → MulRingNorm R → {R' : Type u_2} → [inst' : NonAssocRing R'] → MulRingNorm R' → Sort u | null | false |
ExteriorAlgebra.«_aux_Mathlib_LinearAlgebra_ExteriorAlgebra_Basic___macroRules_ExteriorAlgebra_term⋀[_]^__1» | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | Lean.Macro | null | false |
CategoryTheory.MorphismProperty.comul_hom | Mathlib.CategoryTheory.CopyDiscardCategory.Widesubcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : P.IsMonoidalStable] (c : CategoryTheory.WideSubcategory P)
[inst_3 : CategoryTheory.ComonObj c.obj] [inst_4 : P.IsStableUnderComonoid c.obj],
CategoryTheory... | null | true |
tsum_eq_tsum_primes_of_support_subset_prime_powers | Mathlib.NumberTheory.EulerProduct.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : UniformSpace α] [IsUniformAddGroup α] [CompleteSpace α] [T0Space α]
{f : ℕ → α},
Summable f → Function.support f ⊆ {n | IsPrimePow n} → ∑' (n : ℕ), f n = ∑' (p : Nat.Primes) (k : ℕ), f (↑p ^ (k + 1)) | null | true |
Lean.PrettyPrinter.Delaborator.addDelabTermInfo | Lean.PrettyPrinter.Delaborator.Basic | Lean.SubExpr.Pos →
Lean.Syntax →
Lean.Expr →
optParam Bool false →
optParam (Option Lean.DeclarationLocation) none →
optParam (Option String) none →
optParam (Option (Lean.PPContext → IO String)) none →
optParam Bool true → Lean.PrettyPrinter.Delaborator.DelabM Un... | Adds `DelabTermInfo` at the given position.
Either `docString?` or `mkDocString?` can be provided. The `docString?` field is a convenient
interface for `mkDocString?`.
| true |
_private.Mathlib.Analysis.Calculus.TangentCone.Basic.0.tangentConeAt_subset_zero._simp_1_2 | Mathlib.Analysis.Calculus.TangentCone.Basic | ∀ {α : Type u} {p : α → Prop} {f : Filter α}, (¬∃ᶠ (x : α) in f, p x) = ∀ᶠ (x : α) in f, ¬p x | null | false |
AlgebraicGeometry.IsDominant.respectsIso | Mathlib.AlgebraicGeometry.Morphisms.UnderlyingMap | CategoryTheory.MorphismProperty.RespectsIso @AlgebraicGeometry.IsDominant | null | true |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.Cover.ι_glueMorphisms._simp_1_2 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (x : ↥X), 𝒰.f (𝒰.idx x) = 𝒰.ulift.f x | null | false |
_private.Mathlib.Combinatorics.SetFamily.Compression.UV.0.UV.aux._proof_1_2 | Mathlib.Combinatorics.SetFamily.Compression.UV | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {u v : Finset α},
(∀ x ∈ u, ∃ y ∈ v, UV.IsCompressed (u.erase x) (v.erase y) 𝒜) → v = ∅ → u = ∅ | null | false |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Elab.Tactic.Grind.shouldKeep._sparseCasesOn_1 | Lean.Elab.Tactic.Grind.Param | {motive : Lean.Meta.Grind.Origin → Sort u} →
(t : Lean.Meta.Grind.Origin) →
((declName : Lean.Name) → motive (Lean.Meta.Grind.Origin.decl declName)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Real.toNNReal.eq_1 | Mathlib.Basic.NNReal.Defs | ∀ (r : ℝ), r.toNNReal = NNReal.mk (max r 0) ⋯ | null | true |
ENNReal.neTopHomeomorphNNReal._proof_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | Continuous ({a | a ≠ ⊤}.domRestrict ENNReal.toNNReal) | null | false |
Lean.Meta.Grind.Params.extra | Lean.Meta.Tactic.Grind.Main | Lean.Meta.Grind.Params → Lean.PArray Lean.Meta.Grind.EMatchTheorem | null | true |
not_supIrred_bot._simp_2 | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] [inst_1 : OrderBot α], SupIrred ⊥ = False | null | false |
FredholmDecomposition._sizeOf_1 | Mathlib.Analysis.Normed.Operator.Fredholm.Basic | {𝕜 : Type u_1} →
{E : Type u_2} →
{inst : NontriviallyNormedField 𝕜} →
{inst_1 : AddCommGroup E} →
{inst_2 : Module 𝕜 E} → {inst_3 : TopologicalSpace E} → [SizeOf 𝕜] → [SizeOf E] → FredholmDecomposition 𝕜 E → ℕ | null | false |
_private.Lean.Elab.Tactic.LibrarySearch.0.Lean.Elab.LibrarySearch.elabLibrarySearchConfig.evalConfigItem | Lean.Elab.Tactic.LibrarySearch | Lean.Elab.ConfigEval.EvalConfigItem Lean.Parser.Tactic.LibrarySearchConfig | null | true |
List.rightInverse_idxToSigmaCount_sigmaCountToIdx | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs : List α},
Function.RightInverse xs.idxToSigmaCount xs.sigmaCountToIdx | null | true |
Function.Coequalizer.Rel | Mathlib.Logic.Function.Coequalizer | {α : Type u_1} → {β : Type u_2} → (α → β) → (α → β) → β → β → Prop | The relation generating the equivalence relation used for defining `Function.coequalizer`. | true |
CentroidHom.ext | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] {f g : CentroidHom α}, (∀ (a : α), f a = g a) → f = g | null | true |
CategoryTheory.CostructuredArrow.epi_of_epi_left | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {S : CategoryTheory.Functor C D} {A B : CategoryTheory.CostructuredArrow S T} (f : A ⟶ B)
[h : CategoryTheory.Epi (CategoryTheory.CostructuredArrow.Hom.left f)], CategoryTheory.Epi f | The converse of this is true with additional assumptions, see `epi_iff_epi_left`. | true |
BitVec.getElem_not | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {i : ℕ} (h : i < w), (~~~x)[i] = !x[i] | null | true |
gc_Ici_sInf | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} [inst : CompleteSemilatticeInf α],
GaloisConnection (⇑OrderDual.toDual ∘ Set.Ici) (sInf ∘ ⇑OrderDual.ofDual) | `toDual ∘ Ici` and `sInf ∘ ofDual` form a Galois connection. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.