name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousLinearMap.smulRight.congr_simp | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {M₁ : Type u_4} [inst : TopologicalSpace M₁] [inst_1 : AddCommMonoid M₁] {M₂ : Type u_6}
[inst_2 : TopologicalSpace M₂] [inst_3 : AddCommMonoid M₂] {R : Type u_9} {S : Type u_10} [inst_4 : Semiring R]
[inst_5 : Semiring S] [inst_6 : Module R M₁] [inst_7 : Module R M₂] [inst_8 : Module R S] [inst_9 : Module S M₂]
... | null | true |
Set.finset_prod_mem_finset_prod | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] (t : Finset ι) (f : ι → Set α) (g : ι → α),
(∀ i ∈ t, g i ∈ f i) → ∏ i ∈ t, g i ∈ ∏ i ∈ t, f i | **Alias** of `Set.finsetProd_mem_finsetProd`.
---
An n-ary version of `Set.mul_mem_mul`. | true |
SimpleGraph.Walk.isHamiltonianCycle_iff_isCycle_and_length_eq | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a} [inst_1 : Fintype α],
p.IsHamiltonianCycle ↔ p.IsCycle ∧ p.length = Fintype.card α | null | true |
EMetricSpace.rec | Mathlib.Topology.EMetricSpace.Defs | {α : Type u} →
{motive : EMetricSpace α → Sort u_1} →
([toPseudoEMetricSpace : PseudoEMetricSpace α] →
(eq_of_edist_eq_zero : ∀ {x y : α}, edist x y = 0 → x = y) →
motive { toPseudoEMetricSpace := toPseudoEMetricSpace, eq_of_edist_eq_zero := eq_of_edist_eq_zero }) →
(t : EMetricSpace α) → ... | null | false |
Lean.Meta.ApplyConfig.mk.sizeOf_spec | Init.Meta.Defs | ∀ (newGoals : Lean.Meta.ApplyNewGoals) (synthAssignedInstances allowSynthFailures approx : Bool),
sizeOf
{ newGoals := newGoals, synthAssignedInstances := synthAssignedInstances,
allowSynthFailures := allowSynthFailures, approx := approx } =
1 + sizeOf newGoals + sizeOf synthAssignedInstances + size... | null | true |
FiniteArchimedeanClass.mk.congr_simp | Mathlib.RingTheory.HahnSeries.Lex | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (a a_1 : M)
(e_a : a = a_1) (h : a ≠ 0), FiniteArchimedeanClass.mk a h = FiniteArchimedeanClass.mk a_1 ⋯ | null | true |
Lean.Meta.Grind.Arith.isArithTerm | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Bool | null | true |
_private.Mathlib.Data.Nat.Factors.0.Nat.mem_primeFactorsList_mul._simp_1_1 | Mathlib.Data.Nat.Factors | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
NumberField.IsTotallyComplex.casesOn | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | {K : Type u_1} →
[inst : Field K] →
{motive : NumberField.IsTotallyComplex K → Sort u} →
(t : NumberField.IsTotallyComplex K) →
((isComplex : ∀ (v : NumberField.InfinitePlace K), v.IsComplex) → motive ⋯) → motive t | null | false |
minpoly.mem_range_of_degree_eq_one | Mathlib.FieldTheory.Minpoly.Basic | ∀ (A : Type u_1) {B : Type u_2} [inst : CommRing A] [inst_1 : Ring B] [inst_2 : Algebra A B] (x : B),
(minpoly A x).degree = 1 → x ∈ (algebraMap A B).range | null | true |
CategoryTheory.Pseudofunctor.mapComp_assoc_left_hom_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) {Z : F.obj a ⟶ F.obj d}
(h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (F.map f) (F.map g)... | null | true |
Matroid.IsBase.ncard_eq_ncard_of_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {B₁ B₂ : Set α}, M.IsBase B₁ → M.IsBase B₂ → B₁.ncard = B₂.ncard | null | true |
Sym2.Mem.other' | Mathlib.Data.Sym.Sym2 | {α : Type u_1} → [DecidableEq α] → {a : α} → {z : Sym2 α} → a ∈ z → α | Get the other element of the unordered pair using the decidable equality.
This is the computable version of `Mem.other`. | true |
CategoryTheory.Functor.IsLeftKanExtension.recOn | Mathlib.CategoryTheory.Functor.KanExtension.Basic | {C : Type u_1} →
{H : Type u_3} →
{D : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] →
[inst_2 : CategoryTheory.Category.{v_5, u_5} D] →
{F' : CategoryTheory.Functor D H} →
{L : CategoryTheory.Functor C... | null | false |
CategoryTheory.Functor.category._proof_4 | Mathlib.CategoryTheory.Functor.Category | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {X Y : CategoryTheory.Functor C D} (f : CategoryTheory.NatTrans X Y),
f.vcomp (CategoryTheory.NatTrans.id Y) = f | null | false |
LinearEquiv.extendScalarsOfIsLocalization._proof_1 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_4} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_2) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_3} {N : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[i... | null | false |
TopologicalSpace.Clopens.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isClopen' : IsClopen carrier) (carrier_1 : Set α)
(isClopen'_1 : IsClopen carrier_1),
({ carrier := carrier, isClopen' := isClopen' } = { carrier := carrier_1, isClopen' := isClopen'_1 }) =
(carrier = carrier_1) | null | true |
Std.DTreeMap.Internal.Impl.SizedBalancedTree.mk._flat_ctor | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
{lb ub : ℕ} →
(impl : Std.DTreeMap.Internal.Impl α β) →
impl.Balanced → lb ≤ impl.size → impl.size ≤ ub → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β lb ub | null | false |
MonObj.mopEquiv | Mathlib.CategoryTheory.Monoidal.Opposite.Mon | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon C ≌ CategoryTheory.Mon Cᴹᵒᵖ | The equivalence of categories between monoids internal to `C`
and monoids internal to the monoidal opposite of `C`. | true |
_private.Mathlib.Algebra.Module.TransferInstance.0.Equiv.noZeroSMulDivisors._simp_1_1 | Mathlib.Algebra.Module.TransferInstance | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (y = e.symm x) = (e y = x) | null | false |
CategoryTheory.Subobject.Classifier.mkOfTerminalΩ₀_χ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (Ω₀ : C) (t : CategoryTheory.Limits.IsTerminal Ω₀) (Ω : C)
(truth : Ω₀ ⟶ Ω) (χ : {U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ Ω)
(isPullback :
∀ {U X : C} (m : U ⟶ X) [inst_1 : CategoryTheory.Mono m], CategoryTheory.IsPullback m (t.from U) (χ m... | null | true |
Array.replicate_append_replicate | Init.Data.Array.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {m : ℕ}, Array.replicate n a ++ Array.replicate m a = Array.replicate (n + m) a | null | true |
_private.Mathlib.Analysis.Fourier.FourierTransformDeriv.0.VectorFourier.norm_iteratedFDeriv_fourierPowSMulRight._proof_1_5 | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {k : ℕ} (i : ℕ), k - i ≤ k | null | false |
Polynomial.taylor_mul | Mathlib.Algebra.Polynomial.Taylor | ∀ {R : Type u_1} [inst : CommSemiring R] (r : R) (p q : Polynomial R),
(Polynomial.taylor r) (p * q) = (Polynomial.taylor r) p * (Polynomial.taylor r) q | null | true |
_private.Mathlib.RingTheory.FiniteType.0.Algebra.FiniteType.of_surjective._simp_1_2 | Mathlib.RingTheory.FiniteType | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] (φ : A →ₐ[R] B) {y : B}, (y ∈ φ.range) = ∃ x, φ x = y | null | false |
Lean.Lsp.LeanDidOpenTextDocumentParams.rec | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.LeanDidOpenTextDocumentParams → Sort u} →
((toDidOpenTextDocumentParams : Lean.Lsp.DidOpenTextDocumentParams) →
(dependencyBuildMode? : Option Lean.Lsp.DependencyBuildMode) →
motive
{ toDidOpenTextDocumentParams := toDidOpenTextDocumentParams,
dependencyBuildMode... | null | false |
Lean.IR.IRType.erased.sizeOf_spec | Lean.Compiler.IR.Basic | sizeOf Lean.IR.IRType.erased = 1 | null | true |
MeasureTheory.hausdorffMeasure_orthogonalProjection_le | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {𝕜 : Type u_4} {E : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (K : Submodule 𝕜 E) [inst_5 : K.HasOrthogonalProjection] (d : ℝ)
(s : Set E),
0 ≤ d →
(MeasureTheory.Measure.hausdorffMeasure d) (⇑K.ortho... | **Alias** of `MeasureTheory.hausdorffMeasure_orthogonalProjectionOnto_le`.
---
Let `s` be a subset of `𝕜`-inner product space, and `K` a subspace. Then the `d`-dimensional
Hausdorff measure of the orthogonal projection of `s` onto `K` is less than or equal to the
`d`-dimensional Hausdorff measure of `s`.
| true |
_private.Mathlib.Analysis.Complex.JensenFormula.0.AnalyticOnNhd.sum_divisor_le._simp_1_5 | Mathlib.Analysis.Complex.JensenFormula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
CategoryTheory.NatTrans.mapElements_op_comp_toCostructuredArrow | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor Cᵒᵖ (Type v)} (α : F₁ ⟶ F₂),
(CategoryTheory.NatTrans.mapElements α).op.comp (CategoryTheory.Functor.Elements.toCostructuredArrow F₂) =
(CategoryTheory.Functor.Elements.toCostructuredArrow F₁).comp (CategoryTheory.Costructure... | null | true |
_private.Mathlib.Algebra.Homology.Additive.0.CategoryTheory.NatIso.mapHomologicalComplex._simp_1 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (c : ComplexShape ι) {F G H : CategoryTheory.Functor W₁ W₂}
[in... | null | false |
_private.Mathlib.RingTheory.Polynomial.Cyclotomic.Basic.0.Polynomial.coprime_of_root_cyclotomic._simp_1_2 | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | null | false |
Lean.Elab.Info.ofPartialTermInfo.elim | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
t.ctorIdx = 2 → ((i : Lean.Elab.PartialTermInfo) → motive (Lean.Elab.Info.ofPartialTermInfo i)) → motive t | null | false |
_private.Mathlib.AlgebraicGeometry.Cover.QuasiCompact.0.AlgebraicGeometry.QuasiCompactCover.instPullback₁Scheme._simp_2 | Mathlib.AlgebraicGeometry.Cover.QuasiCompact | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
OrderIso.dualAntisymmetrization._proof_2 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u_1) [inst : Preorder α] (a : α),
Quotient.map' id ⋯ (Quotient.map' id ⋯ (Quotient.mk'' a)) = Quotient.mk'' a | null | false |
_private.Mathlib.Tactic.Algebraize.0.Lean.Attr.algebraizeGetParam.match_1 | Mathlib.Tactic.Algebraize | (motive : Lean.Name → Sort u_1) →
(thm : Lean.Name) → ((t : String) → motive (`RingHom.str t)) → ((x : Lean.Name) → motive x) → motive thm | null | false |
_private.Mathlib.CategoryTheory.CommSq.0.CategoryTheory.CommSq.LiftStruct.ext.match_1 | Mathlib.CategoryTheory.CommSq | ∀ {C : Type u_2} {inst : CategoryTheory.Category.{u_1, u_2} C} {A B X Y : C} {f : A ⟶ X} {i : A ⟶ B} {p : X ⟶ Y}
{g : B ⟶ Y} {sq : CategoryTheory.CommSq f i p g} (motive : sq.LiftStruct → Prop) (h : sq.LiftStruct),
(∀ (l : B ⟶ X) (fac_left : CategoryTheory.CategoryStruct.comp i l = f)
(fac_right : CategoryThe... | null | false |
ProbabilityTheory.iCondIndepSet | Mathlib.Probability.Independence.Conditional | {Ω : Type u_1} →
{ι : Type u_2} →
(m' : MeasurableSpace Ω) →
{mΩ : MeasurableSpace Ω} →
[StandardBorelSpace Ω] →
m' ≤ mΩ →
(ι → Set Ω) →
(μ : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.iCondIndepSet._auto_1) →
[MeasureTheory.IsFiniteMeas... | A family of sets is conditionally independent if the family of measurable space structures they
generate is conditionally independent. For a set `s`, the generated measurable space has measurable
sets `∅, s, sᶜ, univ`.
See `ProbabilityTheory.iCondIndepSet_iff`. | true |
Quot.lift₂._proof_1 | Mathlib.Data.Quot | ∀ {α : Sort u_3} {β : Sort u_1} {γ : Sort u_2} {r : α → α → Prop} {s : β → β → Prop} (f : α → β → γ)
(hr : ∀ (a : α) (b₁ b₂ : β), s b₁ b₂ → f a b₁ = f a b₂),
(∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → f a₁ b = f a₂ b) → ∀ (a₁ a₂ : α), r a₁ a₂ → Quot.lift (f a₁) ⋯ = Quot.lift (f a₂) ⋯ | null | false |
IdemSemiring.ofSemiring | Mathlib.Algebra.Order.Kleene | {α : Type u_1} → [inst : Semiring α] → (∀ (a : α), a + a = a) → IdemSemiring α | Construct an idempotent semiring from an idempotent addition. | true |
Mathlib.Tactic.Says.says.verify | Mathlib.Tactic.Says | Lean.Option Bool | If this option is `true`, verify for `X says Y` that `X says` outputs `Y`. | true |
Mathlib.Tactic.Algebra.add_assoc_rev | Mathlib.Tactic.Algebra.Lemmas | ∀ {R : Type u_1} [sR : CommSemiring R] (a b c : R), a + (b + c) = a + b + c | null | true |
_private.Mathlib.Data.List.Permutation.0.List.count_permutations'Aux_self._simp_1_2 | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | null | false |
CategoryTheory.Adjunction.CoreHomEquivUnitCounit.mk.inj | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{homEquiv : (X : C) → (Y : D) → (F.obj X ⟶ Y) ≃ (X ⟶ G.obj Y)} {unit : CategoryTheory.Functor.id C ⟶ F.comp G}
{counit : G.comp ... | null | true |
_private.Mathlib.Tactic.Linter.DirectoryDependency.0.Mathlib.Linter.DirectoryDependency.forbiddenImportDirsCache | Mathlib.Tactic.Linter.DirectoryDependency | IO.Ref (Option Mathlib.Linter.DirectoryDependency.NamePrefixRel✝) | Cache for `forbiddenImportDirs`: the configuration file is read at most once per process. | true |
List.snd_idxToSigmaCount._proof_2 | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : ReflBEq α] {xs : List α} {i : Fin xs.length},
List.countBefore xs[↑i] xs ↑i < List.count (xs.idxToSigmaCount i).fst xs | null | false |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go._unary._proof_1 | Lean.Data.RArray | ∀ {n : ℕ},
WellFounded
(invImage
(fun x =>
PSigma.casesOn x fun lb ub => PSigma.casesOn ub fun ub h1 => PSigma.casesOn h1 fun h1 h2 => (ub, ub - lb))
Prod.instWellFoundedRelation).1 | null | false |
MonoidHom.mker | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : MulOneClass M] →
[inst_1 : MulOneClass N] →
{F : Type u_4} → [inst_2 : FunLike F M N] → [mc : MonoidHomClass F M N] → F → Submonoid M | The multiplicative kernel of a `MonoidHom` is the `Submonoid` of elements `x : G` such that
`f x = 1`. | true |
Multiset.decidableExistsMultiset._proof_1 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} {p : α → Prop} (l : List α), (∃ a ∈ l, p a) ↔ ∃ x ∈ ⟦l⟧, p x | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.List.filterMap.match_1.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (b : β) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b | null | true |
TwoSidedIdeal.equivMatrix.congr_simp | Mathlib.LinearAlgebra.Matrix.Ideal | ∀ {R : Type u_1} {n : Type u_2} [inst : NonAssocRing R] [inst_1 : Fintype n] [inst_2 : Nonempty n]
[inst_3 : DecidableEq n], TwoSidedIdeal.equivMatrix = TwoSidedIdeal.equivMatrix | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.detectIte_cond_lt | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {root : ℕ} {c t f : Std.Sat.AIG.Fanin} {h : root < aig.decls.size},
Std.Sat.AIG.toCNF.detectIte✝ root h = some (c, t, f) → c.gate < root | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_alterKey._simp_1_4 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValueCast a l h) = Std.Internal.List.getValueCast? a l | null | false |
LinearIndependent.fintypeLinearCombination_injective | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Fintype ι],
LinearIndependent R v → Function.Injective ⇑(Fintype.linearCombination R v) | **Alias** of the forward direction of `linearIndependent_iff_injective_fintypeLinearCombination`. | true |
Lean.SubExpr.Pos.fromString? | Lean.SubExpr | String → Except String Lean.SubExpr.Pos | null | true |
LinearEquiv.piRing.eq_1 | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) (ι : Type x) [inst : Semiring R] (S : Type u_4) [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : Semiring S] [inst_4 : AddCommMonoid M] [inst_5 : Module R M] [inst_6 : Module S M]
[inst_7 : SMulCommClass R S M],
LinearEquiv.piRing R M ι S =
(LinearMap.lsum R (fun x => R) S).... | null | true |
_private.Mathlib.RepresentationTheory.FiniteIndex.0.Rep.coindToInd_of_support_subset_orbit._simp_1_2 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {α : Sort u_1} {r : Setoid α} {x y : α}, (⟦x⟧ = ⟦y⟧) = r x y | null | false |
LieModule.isNilpotent_of_top_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [LieModule R L M],
LieModule.IsNilpotent (↥⊤) M = LieModule.IsNilpotent L M | null | false |
CategoryTheory.Monoidal.CommMonFunctorCategoryEquivalence.unitIso | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.MonoidalCategory D] →
[inst_3 : CategoryTheory.BraidedCategory D] →
CategoryTheory.Functor.id (CategoryTheory.CommMon (Category... | The unit for the equivalence `CommMon (C ⥤ D) ≌ C ⥤ CommMon D`.
| true |
«_aux_Mathlib_Algebra_Lie_Basic___macroRules_term_→ₗ⁅_⁆__1» | Mathlib.Algebra.Lie.Basic | Lean.Macro | null | false |
CategoryTheory.SubobjectRepresentableBy.classifier._proof_4 | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.SubobjectRepresentableBy Ω) [inst_2 : CategoryTheory.Limits.HasTerminal C],
CategoryTheory.CategoryStruct.comp h.Ω₀.arrow (CategoryTheory.Iso.refl Ω).hom =
CategoryTheory.Ca... | null | false |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.tryTheoremCore.match_1 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
(Unit → motive none) → ((r : Lean.Meta.Simp.Result) → motive (some r)) → motive __do_lift | null | false |
SymmetricPower.«_aux_Mathlib_LinearAlgebra_TensorPower_Symmetric___delab_app_SymmetricPower_term⨂ₛ[_]_,__1» | Mathlib.LinearAlgebra.TensorPower.Symmetric | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.multipliableLocallyUniformlyOn_one_sub_pow._simp_1_1 | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] {f : ι → β → α} {g : β → α} {s : Set β}
[inst_1 : UniformSpace α],
HasProdUniformlyOn f g s = TendstoUniformlyOn (fun x1 x2 => ∏ i ∈ x1, f i x2) g Filter.atTop s | null | false |
CategoryTheory.Sieve.giGenerate._proof_1 | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x : CategoryTheory.Sieve X) (x_1 : C)
(x_2 : x_1 ⟶ X), x.arrows x_2 → ∃ Y h g, x.arrows g ∧ CategoryTheory.CategoryStruct.comp h g = x_2 | null | false |
PiTensorProduct.definition._proof_5._@.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.913495409._hygCtx._hyg.2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (G : Type (max u_3 u_1 u_2)) (x : SeminormedAddCommGroup G)
(x_1 : NormedSpace 𝕜 G), ContinuousConstSMul 𝕜 G | null | false |
GromovHausdorff.auxGluing._proof_5 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ (X : ℕ → Type) [inst : (n : ℕ) → MetricSpace (X n)] [inst_1 : ∀ (n : ℕ), CompactSpace (X n)]
[inst_2 : ∀ (n : ℕ), Nonempty (X n)] (n : ℕ) (Y : GromovHausdorff.AuxGluingStruct (X n)),
Isometry (Metric.toGlueR ⋯ ⋯ ∘ GromovHausdorff.optimalGHInjr (X n) (X (n + 1))) | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.maxView._proof_8 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β) (size : ℕ) (k' : α) (v' : β k')
(l' r' : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced →
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').s... | null | false |
Circle.exp_eq_exp | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {x y : ℝ}, Circle.exp x = Circle.exp y ↔ ∃ m, x = y + ↑m * (2 * Real.pi) | null | true |
NumberField.mixedEmbedding.fundamentalCone.idealSetEquiv._proof_4 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(J : ↥(nonZeroDivisors (Ideal (NumberField.RingOfIntegers K))))
(x x_1 : ↑(NumberField.mixedEmbedding.fundamentalCone.idealSet K J)),
(fun a => ⟨NumberField.mixedEmbedding.fundamentalCone.idealSetMap K J a, ⋯⟩) x =
(fun a => ⟨NumberField.mixedEmbedd... | null | false |
CategoryTheory.isProjective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.ObjectProperty C | The `ObjectProperty C` corresponding to the notion of projective objects in `C`. | true |
Lean.Parser.Tactic.ConstructorConfig.mk.noConfusion | Init.Tactics | {P : Sort u} → {first first' : Bool} → { first := first } = { first := first' } → (first = first' → P) → P | null | false |
Valuation.ideal_isPrincipal | Mathlib.RingTheory.Valuation.Discrete.Basic | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {K : Type u_2} [inst_1 : Field K] (v : Valuation K Γ)
[IsCyclic ↥(↑v).valueGroup] [Nontrivial ↥(↑v).valueGroup] (I : Ideal ↥v.valuationSubring), Submodule.IsPrincipal I | null | true |
Prod.instOrderTop | Mathlib.Order.BoundedOrder.Basic | (α : Type u) → (β : Type v) → [inst : LE α] → [inst_1 : LE β] → [OrderTop α] → [OrderTop β] → OrderTop (α × β) | null | true |
_private.Mathlib.Algebra.Category.Grp.EpiMono.0.GrpCat.SurjectiveOfEpiAuxs._aux_Mathlib_Algebra_Category_Grp_EpiMono___macroRules__private_Mathlib_Algebra_Category_Grp_EpiMono_0_GrpCat_SurjectiveOfEpiAuxs_termSX'_1 | Mathlib.Algebra.Category.Grp.EpiMono | Lean.Macro | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Convolution.0.MeasureTheory.hasFDerivAt_convolution_right_with_param._simp_1_9 | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
Equiv.swap_eq_refl_iff | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y : α}, Equiv.swap x y = Equiv.refl α ↔ x = y | null | true |
MulAction.block_stabilizerOrderIso.match_3 | Mathlib.GroupTheory.GroupAction.Blocks | (G : Type u_1) →
[inst : Group G] →
{X : Type u_2} →
[inst_1 : MulAction G X] →
(a : X) →
(motive : ↑(Set.Ici (MulAction.stabilizer G a)) → Sort u_3) →
(x : ↑(Set.Ici (MulAction.stabilizer G a))) →
((H : Subgroup G) → (hH : H ∈ Set.Ici (MulAction.stabilizer G a)) ... | null | false |
CategoryTheory.Functor.PushoutObjObj.ofHasPushout_ι | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {X₁ Y₁ : C₁} (f₁ : X₁ ⟶ Y₁) {X₂ Y₂ : C₂} (f₂ : X₂ ⟶ Y₂)
[inst_3 :... | null | true |
Units.le_of_inv_mul_le_one | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ) {a : M}, ↑u⁻¹ * a ≤ 1 → a ≤ ↑u | **Alias** of the forward direction of `Units.inv_mul_le_one`. | true |
_private.Batteries.Data.MLList.Basic.0.MLList.MLListImpl.nil | Batteries.Data.MLList.Basic | {m : Type u → Type u} → {α : Type u} → MLList.MLListImpl✝ m α | null | true |
Mathlib.Tactic.Order.ToInt.toInt_sup_toInt_eq_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j k : Fin n),
max (Mathlib.Tactic.Order.ToInt.toInt val i) (Mathlib.Tactic.Order.ToInt.toInt val j) =
Mathlib.Tactic.Order.ToInt.toInt val k ↔
max (val i) (val j) = val k | null | true |
Lean.Compiler.LCNF.FindUsed.State.mk.sizeOf_spec | Lean.Compiler.LCNF.ReduceArity | ∀ (used : Lean.FVarIdHashSet), sizeOf { used := used } = 1 + sizeOf used | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.action_exchange | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {w x : D} {y z : C} (f : w ⟶ x) (g : y ⟶ z),
CategoryTheory.CategoryStruct.c... | null | true |
PartOrdEmb.Hom.noConfusion | Mathlib.Order.Category.PartOrdEmb | {P : Sort u_1} →
{X Y : PartOrdEmb} →
{t : X.Hom Y} →
{X' Y' : PartOrdEmb} → {t' : X'.Hom Y'} → X = X' → Y = Y' → t ≍ t' → PartOrdEmb.Hom.noConfusionType P t t' | null | false |
LinearMap.eq_adjoint_iff_basis_left | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedAddCommGroup F] [inst_3 : InnerProductSpace 𝕜 E] [inst_4 : InnerProductSpace 𝕜 F]
[inst_5 : FiniteDimensional 𝕜 E] [inst_6 : FiniteDimensional 𝕜 F] {ι : Type u_5} (b : Module.Basis ι 𝕜 E)
(A : E... | null | true |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compl_image_constructibleTopologySubbasis._proof_1_2 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X], compl '' constructibleTopologySubbasis X = constructibleTopologySubbasis X | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.instIsPreimmersionSubschemeι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData), AlgebraicGeometry.IsPreimmersion I.subschemeι | See `AlgebraicGeometry.Morphisms.ClosedImmersion` for the closed immersion version. | true |
Unitization.instCStarAlgebra | Mathlib.Analysis.CStarAlgebra.Unitization | {A : Type u_3} → [NonUnitalCStarAlgebra A] → CStarAlgebra (Unitization ℂ A) | null | true |
CategoryTheory.Pretriangulated.id_hom₂ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(A : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id A).hom₂ = CategoryTheory.CategoryStruct.id A.obj₂ | null | true |
_private.Init.Data.Range.Polymorphic.UInt.0.USize.instLawfulHasSize._simp_2 | Init.Data.Range.Polymorphic.UInt | ∀ {a b : USize}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
CategoryTheory.IsUniversallyEffectiveEquivalenceRelationCategory.mk | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {R A : C},
(∀ (p₁ p₂ : R ⟶ A) [CategoryTheory.IsEquivalenceRelation p₁ p₂],
CategoryTheory.IsUniversallyEffectiveEquivalenceRelation p₁ p₂) →
CategoryTheory.IsUniversallyEffectiveEquivalenceRelationCategory C | null | true |
AddActionHom.End.instAddMonoidId | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} → {X : Type u_4} → [inst : VAdd M X] → AddMonoid (X →ₑ[id] X) | For an additive monoid `M` acting on a type `X`, the `M`-equivariant functions
from `X` to itself form an additive monoid under composition. | true |
IsAdjoinRootMonic.mkOfAdjoinEqTop'._proof_8 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Module.Finite R S] [inst_4 : Module.Free R S] {α : S} (hα : R[α] = ⊤),
RingHom.ker
(IsAdjoinRoot.ofAdjoinRootEquiv
(AlgEquiv.ofBijective (AdjoinRoot.liftAlgHom (minpoly R α) (Algebra.ofId R S) ... | null | false |
PrimeSpectrum.BasicConstructibleSetData.map.eq_1 | Mathlib.RingTheory.Spectrum.Prime.ConstructibleSet | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] (φ : R →+* S)
(C : PrimeSpectrum.BasicConstructibleSetData R),
PrimeSpectrum.BasicConstructibleSetData.map φ C = { f := φ C.f, n := C.n, g := ⇑φ ∘ C.g } | null | true |
Lean.Meta.Match.Example.var.injEq | Lean.Meta.Match.Basic | ∀ (a a_1 : Lean.FVarId), (Lean.Meta.Match.Example.var a = Lean.Meta.Match.Example.var a_1) = (a = a_1) | null | true |
CategoryTheory.TransfiniteCompositionOfShape.iic._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : OrderBot J] (j : J), ⊥ ≤ j | null | false |
Std.Internal.UV.TCP.Socket.cancelAccept | Std.Internal.UV.TCP | Std.Internal.UV.TCP.Socket → IO Unit | Cancels the accept request of a socket.
| true |
SimpleGraph.not_reachable_of_neighborSet_right_eq_empty | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {u v : V}, u ≠ v → G.neighborSet v = ∅ → ¬G.Reachable u v | null | true |
Matroid.IsRkFinite.indep_of_encard_le_eRk | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {I : Set α}, M.IsRkFinite I → I.encard ≤ M.eRk I → M.Indep I | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.