name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearMap.const_apply | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M₂ : Type w} {ι : Type x} [inst : Semiring R] [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂]
(x : M₂), LinearMap.const x = Function.const ι x | null | true |
Lean.Meta.RefinedDiscrTree.ExprInfo.mk.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {P : Sort u} →
{expr : Lean.Expr} →
{bvars : List Lean.FVarId} →
{lctx : Lean.LocalContext} →
{localInsts : Lean.LocalInstances} →
{cfg : Lean.Meta.Config} →
{expr' : Lean.Expr} →
{bvars' : List Lean.FVarId} →
{lctx' : Lean.LocalContext} →
... | null | false |
TopCat.toSSetObjEdgeEquiv._proof_2 | Mathlib.Topology.Homotopy.TopCat.ZerothHomotopy | ∀ {X : TopCat} {x y : ↑X} (e : SSet.Edge (TopCat.toSSetObj₀Equiv.symm x) (TopCat.toSSetObj₀Equiv.symm y)),
(CategoryTheory.ConcreteCategory.hom (TopCat.toSSetObj₁Equiv e.edge)) 0 = x | null | false |
List.forA | Init.Data.List.Control | {m : Type u → Type v} → [Applicative m] → {α : Type w} → List α → (α → m PUnit.{u + 1}) → m PUnit.{u + 1} | Applies the applicative action `f` to every element in the list, in order.
If `m` is also a `Monad`, then using `List.forM` can be more efficient.
`List.mapA` is a variant that collects results.
| true |
CategoryTheory.FreeBicategory.inclusion | Mathlib.CategoryTheory.Bicategory.Coherence | (B : Type u) →
[inst : Quiver B] →
CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete (CategoryTheory.Paths B))
(CategoryTheory.FreeBicategory B) | The inclusion pseudofunctor from the locally discrete bicategory on the path category into the
free bicategory.
| true |
Matrix.coe_units_inv | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : (Matrix n n α)ˣ),
↑A⁻¹ = (↑A)⁻¹ | Coercing the result of `Units.instInv` is the same as coercing first and applying the
nonsingular inverse. | true |
_private.Mathlib.Data.Int.Interval.0.Finset.Icc_succ_succ._simp_1_1 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
Lean.Meta.Grind.Arith.CommRing.CommRing.subFn?._inherited_default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Option Lean.Expr | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiffAt_one_iff._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {n : ℕ},
ContDiffAt 𝕜 (↑n + 1) f x = ∃ f', (∃ u ∈ nhds x, ∀ x ∈ u, HasFDerivAt f (f' x) x) ∧ ... | null | false |
AdicCompletion.piEquivOfFintype | Mathlib.RingTheory.AdicCompletion.Functoriality | {R : Type u_1} →
[inst : CommRing R] →
(I : Ideal R) →
{ι : Type u_6} →
(M : ι → Type u_7) →
[inst_1 : (i : ι) → AddCommGroup (M i)] →
[inst_2 : (i : ι) → Module R (M i)] →
[DecidableEq ι] →
[Fintype ι] → AdicCompletion I ((j : ι) → M j) ≃ₗ[AdicCom... | If `ι` is finite, `pi` is a linear equiv. | true |
_private.Std.Http.Internal.ChunkedBuffer.0.Std.Http.Internal.ChunkedBuffer.toByteArray._proof_1 | Std.Http.Internal.ChunkedBuffer | ∀ (cb : Std.Http.Internal.ChunkedBuffer), 1 = cb.data.size → 1 ≤ cb.data.size | null | false |
Padic.instNontriviallyNormedField | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [hp : Fact (Nat.Prime p)] → NontriviallyNormedField ℚ_[p] | null | true |
ModuleCon.instAddZeroClassQuotient._proof_2 | Mathlib.Algebra.Module.Congruence.Defs | ∀ {S : Type u_1} (M : Type u_2) [inst : SMul S M] [inst_1 : AddZeroClass M] (c : ModuleCon S M)
(a : ModuleCon.Quotient M c), a + 0 = a | null | false |
instBooleanAlgebraSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_12 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (x : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }), (↑x).1 * 1 = (↑x).1 | null | false |
Mathlib.Tactic.Sat.Clause.mk.noConfusion | Mathlib.Tactic.Sat.FromLRAT | {P : Sort u} →
{lits : Array ℤ} →
{expr proof : Lean.Expr} →
{lits' : Array ℤ} →
{expr' proof' : Lean.Expr} →
{ lits := lits, expr := expr, proof := proof } = { lits := lits', expr := expr', proof := proof' } →
(lits = lits' → expr = expr' → proof = proof' → P) → P | null | false |
instDifferentialAlgebra | Mathlib.RingTheory.Derivation.DifferentialRing | ∀ (A : Type u_1) [inst : CommRing A] [inst_1 : Differential A], DifferentialAlgebra A A | null | true |
Matrix.conjTranspose_circulant | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} {n : Type u_3} [inst : Star α] [inst_1 : SubtractionMonoid n] (v : n → α),
(Matrix.circulant v).conjTranspose = Matrix.circulant (star fun i => v (-i)) | null | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.isUniformInducing_pi_restrict._simp_1_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
IsUniformInducing f = (UniformSpace.comap f inst_1 = inst) | null | false |
BoxIntegral.Prepartition.eq_of_boxes_subset_iUnion_superset | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I},
π₁.boxes ⊆ π₂.boxes → π₂.iUnion ⊆ π₁.iUnion → π₁ = π₂ | null | true |
AlgebraicGeometry.Scheme.Cover.trans_map | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst : CategoryTheory.Category.{v_1, u_1} 𝒰.I₀] [inst_1 : 𝒰.LocallyDirected] {i j : 𝒰.I₀} (hij : i ⟶ j),
CategoryTheory.CategoryStruc... | null | true |
_private.Mathlib.RingTheory.Localization.Ideal.0.IsLocalization.map_eq_top_of_not_subset._simp_1_1 | Mathlib.RingTheory.Localization.Ideal | ∀ {α : Type u_1} {s t : Set α}, (¬s ⊆ t) = ∃ x ∈ s, x ∉ t | null | false |
DFinsupp.extendWith_single_zero | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {α : Option ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : Option ι) → Zero (α i)] (i : ι)
(x : α (some i)), (DFinsupp.extendWith 0 fun₀ | i => x) = fun₀ | some i => x | null | true |
Int.sub_mul | Init.Data.Int.Lemmas | ∀ (a b c : ℤ), (a - b) * c = a * c - b * c | null | true |
Ideal.IsAugmentation | Mathlib.RingTheory.Ideal.IsAugmentation | (R : Type u_1) → [inst : CommSemiring R] → {A : Type u_2} → [inst_1 : Semiring A] → [Algebra R A] → Ideal A → Prop | An ideal `I` of an `R`-algebra `A` is an augmentation ideal
if its underlying module is a complement to `1 : Submodule R A`. | true |
Lean.Meta.Grind.AttrKind.infer.sizeOf_spec | Lean.Meta.Tactic.Grind.Attr | sizeOf Lean.Meta.Grind.AttrKind.infer = 1 | null | true |
Std.DTreeMap.Internal.RooSliceData.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {P : Sort u_1} →
{α : Type u} →
{β : α → Type v} →
{inst : Ord α} →
{t : Std.DTreeMap.Internal.RooSliceData α β} →
{α' : Type u} →
{β' : α' → Type v} →
{inst' : Ord α'} →
{t' : Std.DTreeMap.Internal.RooSliceData α' β'} →
α = α' → ... | null | false |
Nat.IsCarmichael.odd | Mathlib.NumberTheory.CarmichaelNumber | ∀ {n : ℕ}, n.IsCarmichael → Odd n | A Carmichael number is odd. | true |
_private.Mathlib.MeasureTheory.Function.JacobianOneDim.0.MeasureTheory.exists_decomposition_of_monotoneOn_hasDerivWithinAt._simp_1_4 | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
_private.Mathlib.CategoryTheory.RepresentedBy.0.CategoryTheory.Functor.IsRepresentedBy.iff_of_isoObj._simp_1_3 | Mathlib.CategoryTheory.RepresentedBy | ∀ {C : Type u₁} [inst : CategoryTheory.CategoryStruct.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp g.op f.op = (CategoryTheory.CategoryStruct.comp f g).op | null | false |
Finset.union_subset_right | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t u : Finset α}, s ∪ t ⊆ u → t ⊆ u | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory.0.MeasureTheory.SimpleFunc.exists_le_lowerSemicontinuous_lintegral_ge._simp_1_5 | Mathlib.MeasureTheory.Integral.Bochner.VitaliCaratheodory | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderTop α] {a : α}, (a < ⊤) = (a ≠ ⊤) | null | false |
_private.Mathlib.Analysis.Normed.Operator.BanachSteinhaus.0.banach_steinhaus_iSup_nnnorm._simp_1_2 | Mathlib.Analysis.Normed.Operator.BanachSteinhaus | ∀ {s : Set NNReal}, BddAbove s = BddAbove (NNReal.toReal '' s) | null | false |
Algebra.FormallySmooth.iff_injective_cotangentComplexBaseChange | Mathlib.RingTheory.Smooth.Local | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsLocalRing S]
[inst_3 : Algebra R S] (P : Type u_3) (K : Type u_4) [inst_4 : Field K] [inst_5 : CommRing P] [inst_6 : Algebra R P]
[inst_7 : Algebra P S] [IsScalarTower R P S] [inst_9 : Algebra S K] [inst_10 : Algebra P K]
[inst_... | The **Jacobian criterion** for smoothness of local algebras.
Suppose `S` is a local `R`-algebra, and `0 → I → P → S → 0` is a presentation such that
`P` is formally-smooth over `R`, `Ω[P⁄R]` is finite free over `P`,
(typically satisfied when `P` is the localization of a polynomial ring of finite type)
and `I` is finite... | true |
WithAbs.instIsSeparable_1 | Mathlib.Analysis.Normed.Field.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Field R] {T : Type u_3}
[inst_3 : Field T] (v : AbsoluteValue R S) [inst_4 : Algebra T R] [Algebra.IsSeparable T R],
Algebra.IsSeparable T (WithAbs v) | null | true |
Valuation.map_sub_lt | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R} {g : Γ₀}, v x < g → v y < g → v (x - y) < g | null | true |
PosNum.minFac.eq_3 | Mathlib.Data.Num.Prime | ∀ (n : PosNum), n.bit1.minFac = n.bit1.minFacAux (↑n) 1 | null | true |
Matrix.submatrix_id_id | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} (A : Matrix m n α), A.submatrix id id = A | null | true |
Turing.ToPartrec.instDecidableEqCode.decEq | Mathlib.Computability.TuringMachine.Config | (x x_1 : Turing.ToPartrec.Code) → Decidable (x = x_1) | null | true |
Mathlib.Tactic.Abel.NormalExpr.zero.sizeOf_spec | Mathlib.Tactic.Abel | ∀ (e : Lean.Expr), sizeOf (Mathlib.Tactic.Abel.NormalExpr.zero e) = 1 + sizeOf e | null | true |
CategoryTheory.PreGaloisCategory.endMulEquivAutGalois_pi | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) [inst_2 : CategoryTheory.PreGaloisCategory.FiberFunctor F]
(f : CategoryTheory.End F) (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(CategoryTheory.Concr... | null | true |
IsDedekindDomain.HeightOneSpectrum.noConfusionType | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | Sort u →
{R : Type u_1} →
[inst : CommRing R] →
IsDedekindDomain.HeightOneSpectrum R →
{R' : Type u_1} → [inst' : CommRing R'] → IsDedekindDomain.HeightOneSpectrum R' → Sort u | null | false |
CategoryTheory.Adjunction.lim_preservesLimits | Mathlib.CategoryTheory.Adjunction.Limits | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u} [inst_1 : CategoryTheory.Category.{v, u} J]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C], CategoryTheory.Limits.PreservesLimits CategoryTheory.Limits.lim | null | true |
SheafOfModules.freeFunctor | Mathlib.Algebra.Category.ModuleCat.Sheaf.Free | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[J.WEqualsLocallyBijective AddCommGrpCat] → CategoryTheory.Functor (Type u) (SheafOfModules ... | The functor `Type u ⥤ SheafOfModules.{u} R` which sends a type `I` to
`free I` which is a coproduct indexed by `I` of copies of `R` (thought of as a
presheaf of modules over itself). | true |
Std.LawfulBEqCmp.compare_beq_eq_beq | Init.Data.Order.Ord | ∀ {α : Type u} [inst : BEq α] {cmp : α → α → Ordering} [Std.LawfulBEqCmp cmp] {a b : α},
(cmp a b == Ordering.eq) = (a == b) | null | true |
IsDedekindDomain.HeightOneSpectrum.adicCompletion.instField._proof_3 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
(a : IsDedekindDomain.HeightOneSpectrum.adicCompletion K v), a + 0 = a | null | false |
Int.pos_of_neg_neg | Init.Data.Int.Order | ∀ {a : ℤ}, -a < 0 → 0 < a | null | true |
OrderEmbedding.ltEmbedding_apply | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α ↪o β) (x : α), f.ltEmbedding x = f x | null | true |
Std.DHashMap.Internal.Raw₀.Const.get_filterMap | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w}
(m : Std.DHashMap.Internal.Raw₀ α fun x => β) [inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Option γ}
{k : α} (h : (↑m).WF) {h' : (Std.DHashMap.Internal.Raw₀.filterMap f m).contains k = true},
Std.DHashMap.Internal.Raw₀... | null | true |
_private.Mathlib.Topology.Inseparable.0.inseparable_iff_forall_isClosed._simp_1_3 | Mathlib.Topology.Inseparable | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x | null | false |
Complex.tendsto_exp_nhds_zero_iff | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {l : Filter α} {f : α → ℂ},
Filter.Tendsto (fun x => Complex.exp (f x)) l (nhds 0) ↔ Filter.Tendsto (fun x => (f x).re) l Filter.atBot | null | true |
CommGrpCat | Mathlib.Algebra.Category.Grp.Basic | Type (u + 1) | The category of groups and group morphisms. | true |
Lean.Language.SnapshotTask.ReportingRange.some.injEq | Lean.Language.Basic | ∀ (range range_1 : Lean.Syntax.Range),
(Lean.Language.SnapshotTask.ReportingRange.some range = Lean.Language.SnapshotTask.ReportingRange.some range_1) =
(range = range_1) | null | true |
_private.Mathlib.RingTheory.Algebraic.Integral.0.IsAlgebraic.of_mul.match_1_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {y : S}
(motive : (∃ t ∈ R[y], ∃ r, r ≠ 0 ∧ y * t = (algebraMap R S) r) → Prop)
(x : ∃ t ∈ R[y], ∃ r, r ≠ 0 ∧ y * t = (algebraMap R S) r),
(∀ (t : S) (ht : t ∈ R[y]) (r : R) (hr : r ≠ 0) (eq : y * t = (algebraMap R S)... | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.lcm_one | Init.Data.Int.Linear | ∀ (a : ℤ), a.lcm 1 = a.natAbs | null | true |
_private.Mathlib.Combinatorics.Enumerative.Bell.0.Nat.sigmaPartitionWithPartEquiv._proof_7 | Mathlib.Combinatorics.Enumerative.Bell | ∀ (n : ℕ) (x : (i : Fin n.succ) × { p // ↑i + 1 ∈ p.parts }),
↑⟨↑⟨↑x.snd, ⟨↑x.fst + 1, ⋯⟩⟩.snd - 1, ⋯⟩ + 1 ∈ ⟨↑x.snd, ⟨↑x.fst + 1, ⋯⟩⟩.fst.parts | null | false |
_private.Mathlib.Data.List.Lattice.0.List.bagInter_sublist_left._proof_1_5 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (l₁ l₂ : List α),
(l₁.bagInter l₂).Sublist l₁ → (l₁.bagInter l₂).Sublist (a :: l₁) | null | false |
Polynomial.not_dvd_of_degree_lt | Mathlib.Algebra.Polynomial.Degree.Domain | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R}, q ≠ 0 → q.degree < p.degree → ¬p ∣ q | null | true |
CategoryTheory.MonoOver.isColimitCoconeOfHasStrongEpiMonoFactorisation | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{Y : C} →
[inst_1 : CategoryTheory.Limits.HasCoproducts C] →
[inst_2 : CategoryTheory.Limits.HasStrongEpiMonoFactorisations C] →
{J : Type u₂} →
[inst_3 : CategoryTheory.Category.{v₂, u₂} J] →
(F : Cate... | The cocone `coconeOfHasStrongEpiMonoFactorisation F` is a colimit | true |
ProofWidgets.RefreshToken.update | ProofWidgets.Component.RefreshComponent | ProofWidgets.RefreshToken → ProofWidgets.Html → BaseIO Unit | Update the current HTML tree to be `html`. See also `updateLazy`. | true |
Lean.Elab.Tactic.Grind.LiftActionCoreResult.closed | Lean.Elab.Tactic.Grind.Basic | Lean.Elab.Tactic.Grind.LiftActionCoreResult | null | true |
PrespectralSpace.exists_isCompact_and_isOpen_between | Mathlib.Topology.Spectral.Prespectral | ∀ {X : Type u_1} [inst : TopologicalSpace X] [PrespectralSpace X] {K U : Set X},
IsCompact K → IsOpen U → K ⊆ U → ∃ W, IsCompact W ∧ IsOpen W ∧ K ⊆ W ∧ W ⊆ U | null | true |
AddEquiv.map_add' | Mathlib.Algebra.Group.Equiv.Defs | ∀ {A : Type u_9} {B : Type u_10} [inst : Add A] [inst_1 : Add B] (self : A ≃+ B) (x y : A),
self.toFun (x + y) = self.toFun x + self.toFun y | The proposition that the function preserves addition | true |
ConcaveOn.le_slope_of_hasDerivAt | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x y f' : ℝ}, ConcaveOn ℝ S f → x ∈ S → y ∈ S → x < y → HasDerivAt f f' y → f' ≤ slope f x y | null | true |
AddGroupTopology.instBoundedOrder | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} → [inst : AddGroup α] → BoundedOrder (AddGroupTopology α) | null | true |
isRegular_op | Mathlib.Algebra.Regular.Opposite | ∀ {R : Type u_1} [inst : Mul R] {a : R}, IsRegular (MulOpposite.op a) ↔ IsRegular a | null | true |
_private.Mathlib.Topology.MetricSpace.HausdorffDimension.0.intrinsicInterior.eq_1 | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ (𝕜 : Type u_1) {V : Type u_2} {P : Type u_5} [inst : Ring 𝕜] [inst_1 : AddCommGroup V] [inst_2 : Module 𝕜 V]
[inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] (s : Set P),
intrinsicInterior 𝕜 s = Subtype.val '' interior (Subtype.val ⁻¹' s) | null | true |
Std.IO.Process.ResourceUsageStats.unsharedDataSizeKb | Std.Async.Process | Std.IO.Process.ResourceUsageStats → UInt64 | Size of unshared data segment (kilobytes)
| true |
CategoryTheory.AddMon.mkIso.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.AddMon C} (e : M.X ≅ N.X)
(one_f : CategoryTheory.CategoryStruct.comp CategoryTheory.AddMonObj.zero e.hom = CategoryTheory.AddMonObj.zero)
(mul_f :
CategoryTheory.CategoryStruct.comp ... | null | true |
CompactlySupportedContinuousMap.comp | Mathlib.Topology.ContinuousMap.CompactlySupported | {β : Type u_3} →
{γ : Type u_4} →
{δ : Type u_5} →
[inst : TopologicalSpace β] →
[inst_1 : TopologicalSpace γ] →
[inst_2 : TopologicalSpace δ] →
[inst_3 : Zero δ] →
CompactlySupportedContinuousMap γ δ → CocompactMap β γ → CompactlySupportedContinuousMap β δ | Composition of a continuous function with compact support with a cocompact map
yields another continuous function with compact support. | true |
Aesop.ForwardInstantiationStats.rec | Aesop.Stats.Basic | {motive : Aesop.ForwardInstantiationStats → Sort u} →
((«matches» hyps : ℕ) → motive { «matches» := «matches», hyps := hyps }) →
(t : Aesop.ForwardInstantiationStats) → motive t | null | false |
mabs_eq_inv_self | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a : G}, |a|ₘ = a⁻¹ ↔ a ≤ 1 | null | true |
HomologicalComplex₂.instHasTotalIntObjUpCompShiftFunctor₁ShiftFunctor₂ | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (x y : ℤ) [K.HasTotal (ComplexShape.up ℤ)],
(((HomologicalComplex₂.shiftFunctor₁ C x).comp (HomologicalComplex₂.shiftFunctor₂ C y)).obj K).HasTot... | null | true |
CategoryTheory.Functor.IsDenseSubsite.sheafifyOfIsEquivalenceCompIso | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
(J : CategoryTheory.GrothendieckTopology C) →
(K : CategoryTheory.GrothendieckTopology D) →
(G : CategoryTheory.Functor C D) →
(A : ... | Assuming that `(C, J)` is a dense subsite of `(D, K)` (via a functor `G : C ⥤ D`)
and `sheafPushforwardContinuous G A J₀ J` is an equivalence of categories, this is
the isomorphism between `sheafifyOfIsEquivalence J K G A ⋙ G.sheafPushforwardContinuous A J K`
and the functor which sends a presheaf to the sheafification... | true |
CategoryTheory.Enriched.FunctorCategory.functorEnrichedOrdinaryCategory._proof_2 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V]
(C : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} C] (J : Type u_3)
[inst_3 : CategoryTheory.Category.{u_1, u_3} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
[inst_5 :
∀ (F₁ F₂ : ... | null | false |
Lean.Grind.ConfigInteractive.instances._inherited_default | Init.Grind.Config | ℕ | null | false |
CategoryTheory.«_aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___macroRules_CategoryTheory_termᘁ__1» | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.Macro | null | false |
AddSubgroup.quotientEquivProdOfLE'_symm_apply | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s t : AddSubgroup α} (h_le : s ≤ t) (f : α ⧸ t → α)
(hf : Function.RightInverse f QuotientAddGroup.mk) (a : (α ⧸ t) × ↥t ⧸ s.addSubgroupOf t),
(AddSubgroup.quotientEquivProdOfLE' h_le f hf).symm a = Quotient.map' (fun b => f a.1 + ↑b) ⋯ a.2 | null | true |
Sym.append_inj_left | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n n' : ℕ} {s s' : Sym α n} (t : Sym α n'), s.append t = s'.append t ↔ s = s' | null | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.send | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Unbounded✝ α → α → BaseIO (Task (Except Std.CloseableChannel.Error Unit)) | null | true |
Std.Time.instTransOrdPlainDate | Std.Time.Date.PlainDate | Std.TransOrd Std.Time.PlainDate | null | true |
Std.DTreeMap.Raw.mem_of_get_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.LawfulEqCmp cmp]
{k : α} {v : β k} {w : k ∈ t}, t.get k w = v → k ∈ t | null | true |
AlgEquiv.restrictNormal_apply | Mathlib.FieldTheory.Normal.Defs | ∀ {F : Type u_1} [inst : Field F] {K₁ : Type u_3} [inst_1 : Field K₁] [inst_2 : Algebra F K₁]
(L : IntermediateField F K₁) [inst_3 : Normal F ↥L] (σ : Gal(K₁/F)) (x : ↥L), ↑((σ.restrictNormal ↥L) x) = σ ↑x | null | true |
Function.not_lt_argminOn | Mathlib.Order.WellFounded | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) [inst : LT β] [inst_1 : WellFoundedLT β] (s : Set α) {a : α} (ha : a ∈ s),
¬f a < f (Function.argminOn f s ⋯) | null | true |
MulAction.equivSubgroupOrbitsSetoidComap._proof_3 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ {G : Type u_2} {X : Type u_1} [inst : Group G] [inst_1 : MulAction G X] (ω : Quotient (MulAction.orbitRel G X))
(x : ↑(MulAction.orbitRel.Quotient.orbit ω)), ↑x ∈ Quotient.mk (MulAction.orbitRel G X) ⁻¹' {ω} | null | false |
CategoryTheory.Pseudofunctor.StrongTrans.associator_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Pseudo | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.Pseudofunctor B C} (I : CategoryTheory.Pseudofunctor B C) (η : F ⟶ G) (θ : G ⟶ H) (ι : H ⟶ I)
(a : B),
(CategoryTheory.Bicategory.associator η θ ι).inv.as.app a =
(CategoryTheory.B... | null | true |
Rep.barComplex.d_single | Mathlib.RepresentationTheory.Homological.Resolution | ∀ {k G : Type u} [inst : CommRing k] (n : ℕ) [inst_1 : Group G] (x : Fin (n + 1) → G),
((Rep.Hom.hom (Rep.barComplex.d k G n)) fun₀ | x => MonoidAlgebra.single 1 1) =
(fun₀ | fun i => x i.succ => MonoidAlgebra.single (x 0) 1) +
∑ j, fun₀ | j.contractNth (fun x1 x2 => x1 * x2) x => MonoidAlgebra.single 1 ((-... | null | true |
CategoryTheory.MonoidalCoherence.tensor_right_iso | Mathlib.Tactic.CategoryTheory.MonoidalComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
[inst_2 : CategoryTheory.MonoidalCoherence (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) Y],
CategoryTheory.MonoidalCoherence.iso =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).symm ≪≫... | null | true |
mabs.eq_1 | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] (a : α), |a|ₘ = a ⊔ a⁻¹ | null | true |
Lean.Lsp.OpenNamespace.rec | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.OpenNamespace → Sort u} →
((«namespace» : Lean.Name) →
(exceptions : Array Lean.Name) → motive (Lean.Lsp.OpenNamespace.allExcept «namespace» exceptions)) →
((«from» «to» : Lean.Name) → motive (Lean.Lsp.OpenNamespace.renamed «from» «to»)) →
(t : Lean.Lsp.OpenNamespace) → motive t | null | false |
tendstoLocallyUniformlyOn_iff_forall_tendsto | Mathlib.Topology.UniformSpace.LocallyUniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : TopologicalSpace α] [inst_1 : UniformSpace β] {F : ι → α → β}
{f : α → β} {s : Set α} {p : Filter ι},
TendstoLocallyUniformlyOn F f p s ↔
∀ x ∈ s, Filter.Tendsto (fun y => (f y.2, F y.1 y.2)) (p ×ˢ nhdsWithin x s) (uniformity β) | null | true |
AddCircle.windingNumber | Mathlib.Topology.Covering.FundamentalGroupCircle | {p : ℝ} → [hp : Fact (0 < p)] → {x : AddCircle p} → FundamentalGroup (AddCircle p) x → ℤ | The winding number of a loop in `AddCircle p`, defined as its image under `windingNumberIso`. | true |
_private.Init.Data.UInt.Bitwise.0.UInt16.shiftLeft_add_of_toNat_lt._proof_1_3 | Init.Data.UInt.Bitwise | ∀ {b c : UInt16}, b.toNat + c.toNat < 16 → ¬c.toNat < 16 → False | null | false |
CompletePartialOrder | Mathlib.Order.CompletePartialOrder | Type u_4 → Type u_4 | Complete partial orders are partial orders where every directed set has a least upper bound.
| true |
InfClosed.image | Mathlib.Order.SupClosed | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {s : Set α}
[inst_2 : FunLike F α β] [InfHomClass F α β], InfClosed s → ∀ (f : F), InfClosed (⇑f '' s) | null | true |
InnerProductSpace.rankOne_one_right_eq_toSpanSingleton | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_4} {F : Type u_6} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
(x : F), ((InnerProductSpace.rankOne 𝕜) x) 1 = ContinuousLinearMap.toSpanSingleton 𝕜 x | null | true |
CategoryTheory.CanonicallyOverClass.casesOn | Mathlib.CategoryTheory.Comma.Over.OverClass | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X S : C} →
{motive : CategoryTheory.CanonicallyOverClass X S → Sort u_1} →
(t : CategoryTheory.CanonicallyOverClass X S) →
([toOverClass : CategoryTheory.OverClass X S] → motive { toOverClass := toOverClass }) → motive t | null | false |
Filter.diff_mem_inf_principal_compl | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {s : Set α}, s ∈ f → ∀ (t : Set α), s \ t ∈ f ⊓ Filter.principal tᶜ | **Alias** of `Filter.sdiff_mem_inf_principal_compl`. | true |
_private.Lean.Elab.Tactic.Rewrite.0.Lean.Elab.Tactic.foldRWRulesSeq.match_1 | Lean.Elab.Tactic.Rewrite | (motive : Option (Array Lean.Name) → Sort u_1) →
(__x : Option (Array Lean.Name)) →
((eqThms : Array Lean.Name) → motive (some eqThms)) → ((x : Option (Array Lean.Name)) → motive x) → motive __x | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_112 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
ENNReal.log_le_log_iff._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLog | ∀ {x y : ENNReal}, (x.log ≤ y.log) = (x ≤ y) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.