name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Coreflective.instIsIsoAppCounitCoreflectorAdjunctionA | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{R : CategoryTheory.Functor D C} [inst_2 : CategoryTheory.Coreflective R]
(X : (CategoryTheory.coreflectorAdjunction R).toComonad.Coalgebra),
CategoryTheory.IsIso ((CategoryTheory.coreflectorAdj... | true |
MulHom.mk.sizeOf_spec | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} {N : Type u_11} [inst : Mul M] [inst_1 : Mul N] [inst_2 : SizeOf M] [inst_3 : SizeOf N]
(toFun : M → N) (map_mul' : ∀ (x y : M), toFun (x * y) = toFun x * toFun y),
sizeOf { toFun := toFun, map_mul' := map_mul' } = 1 | true |
isAddRightRegular_ofDual | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : αᵒᵈ}, IsAddRightRegular (OrderDual.ofDual a) ↔ IsAddRightRegular a | true |
Module.Finite.recOn | Mathlib.RingTheory.Finiteness.Defs | {R : Type u_1} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{motive : Module.Finite R M → Sort u} → (t : Module.Finite R M) → ((fg_top : ⊤.FG) → motive ⋯) → motive t | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.aux_tendsto_tsum_cexp_pnat._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (n • x) | false |
Function.OfArity | Mathlib.Logic.Function.OfArity | Type u → Type u → ℕ → Type u | true |
Lean.Meta.Grind.Arith.Linear.State.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Sort u → Lean.Meta.Grind.Arith.Linear.State → Lean.Meta.Grind.Arith.Linear.State → Sort u | false |
IsLocalization.map_inf | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) (S : Type u_2) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] (I J : Ideal R),
Ideal.map (algebraMap R S) (I ⊓ J) = Ideal.map (algebraMap R S) I ⊓ Ideal.map (algebraMap R S) J | true |
Lean.Elab.Command.CtorView.mk.sizeOf_spec | Lean.Elab.MutualInductive | ∀ (ref : Lean.Syntax) (modifiers : Lean.Elab.Modifiers) (declName : Lean.Name) (declId binders : Lean.Syntax)
(type? : Option Lean.Syntax),
sizeOf
{ ref := ref, modifiers := modifiers, declName := declName, declId := declId, binders := binders,
type? := type? } =
1 + sizeOf ref + sizeOf modifiers ... | true |
Submodule.ext | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p q : Submodule R M},
(∀ (x : M), x ∈ p ↔ x ∈ q) → p = q | true |
FractionalIdeal.absNorm.congr_simp | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Module.Free ℤ R]
[inst_3 : Module.Finite ℤ R] {K : Type u_2} [inst_4 : CommRing K] [inst_5 : Algebra R K]
[inst_6 : IsFractionRing R K], FractionalIdeal.absNorm = FractionalIdeal.absNorm | true |
NormedField.div._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} →
(mul : α → α → α) →
(∀ (a b c : α), a * b * c = a * (b * c)) →
(one : α) →
(∀ (a : α), 1 * a = a) →
(∀ (a : α), a * 1 = a) →
(npow : ℕ → α → α) →
(∀ (x : α), npow 0 x = 1) → (∀ (n : ℕ) (x : α), npow (n + 1) x = npow n x * x) → (α → α) → α → α → α | false |
Lean.Elab.Term.mkConst | Lean.Elab.Term.TermElabM | Lean.Name → optParam (List Lean.Level) [] → Lean.Elab.TermElabM Lean.Expr | true |
lp.inftyNormedCommRing | Mathlib.Analysis.Normed.Lp.lpSpace | {I : Type u_5} →
{B : I → Type u_6} →
[inst : (i : I) → NormedCommRing (B i)] → [∀ (i : I), NormOneClass (B i)] → NormedCommRing ↥(lp B ⊤) | true |
_private.Init.Data.Nat.Fold.0.Nat.foldRev.eq_def | Init.Data.Nat.Fold | ∀ {α : Type u} (x : ℕ) (x_1 : (i : ℕ) → i < x → α → α) (x_2 : α),
x.foldRev x_1 x_2 =
match x, x_1, x_2 with
| 0, f, a => a
| n.succ, f, a => n.foldRev (fun i h => f i ⋯) (f n ⋯ a) | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.Const.alter._proof_41 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} (sz : ℕ) (k' : α) (v' : β) (l' r' : Std.DTreeMap.Internal.Impl α fun x => β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced), (l'.glue r' ⋯ ⋯ ⋯).Balanced | false |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.isIsotypicOfType_submodule_iff.match_1_5 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_3} {M : Type u_2} {S : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup S]
[inst_3 : Module R M] [inst_4 : Module R S] {N : Submodule R M} (m : Submodule R ↥N)
(motive : Nonempty (↥(Submodule.map N.subtype m) ≃ₗ[R] S) → Prop)
(x : Nonempty (↥(Submodule.map N.subtype m) ≃ₗ[R... | false |
Set.Finite.ssubset_toFinset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {t : Set α} {ht : t.Finite} {s : Finset α}, s ⊂ ht.toFinset ↔ ↑s ⊂ t | true |
Lean.Grind.Nat.lo_eq_false_of_le | Init.Grind.Offset | ∀ (u v k : ℕ), Lean.Grind.isLt 0 k = true → u ≤ v → (v + k ≤ u) = False | true |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.union_iUnion_openCell_eq_complex._simp_1_1 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D] (n : ℕ∞),
D ∪ ⋃ m, ⋃ (_ : ↑m < n), ⋃ j, Topology.RelCWComplex.closedCell m j =
D ∪ ⋃ m, ⋃ (_ : ↑m < n), ⋃ j, Topology.RelCWComplex.openCell m j | false |
Ergodic.ae_eq_const_of_ae_eq_comp₀ | Mathlib.Dynamics.Ergodic.Function | ∀ {α : Type u_1} {X : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [Nonempty X]
[inst_2 : MeasurableSpace X] [MeasurableSpace.CountablySeparated X] {f : α → α} {g : α → X},
Ergodic f μ → MeasureTheory.NullMeasurable g μ → g ∘ f =ᵐ[μ] g → ∃ c, g =ᵐ[μ] Function.const α c | true |
Std.Roo.toList_succ_succ_eq_map | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[Std.PRange.LinearlyUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_5 : Std.PRange.InfinitelyUpwardEnumerable α] [inst_6 : Std.Rxo.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {lo h... | true |
CategoryTheory.WellPowered.rec | Mathlib.CategoryTheory.Subobject.WellPowered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] →
[inst_1 : CategoryTheory.LocallySmall.{w, v, u₁} C] →
{motive : CategoryTheory.WellPowered.{w, v, u₁} C → Sort u} →
((subobject_small : ∀ (X : C), Small.{w, max u₁ v} (CategoryTheory.Subobject X)) → motive ⋯) →
(t : CategoryTheor... | false |
finsum_pos | Mathlib.Algebra.BigOperators.Finprod | ∀ {ι : Type u_3} {M : Type u_7} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [IsOrderedCancelAddMonoid M]
{f : ι → M}, (∀ (i : ι), 0 ≤ f i) → (∃ i, 0 < f i) → Function.HasFiniteSupport f → 0 < ∑ᶠ (i : ι), f i | true |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.instCompleteLattice._simp_1 | Mathlib.Probability.Process.Filtration | ∀ {α : Type u} {π : α → Type u_1} [inst : (a : α) → Preorder (π a)] {s : Set ((a : α) → π a)} {f : (a : α) → π a},
IsLUB s f = ∀ (a : α), IsLUB (Function.eval a '' s) (f a) | false |
Std.DTreeMap.maxKey_le_maxKey_insertIfNew | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k} {he : t.isEmpty = false}, (cmp (t.maxKey he) ((t.insertIfNew k v).maxKey ⋯)).isLE = true | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
... | false |
ONote.nf_opowAux._unary | Mathlib.SetTheory.Ordinal.Notation | ∀ (e a0 a : ONote) [e.NF] [a0.NF] [a.NF] (_x : (_ : ℕ) ×' ℕ), (e.opowAux a0 a _x.1 _x.2).NF | false |
ContinuousOrderHom._sizeOf_1 | Mathlib.Topology.Order.Hom.Basic | {α : Type u_6} →
{β : Type u_7} →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : TopologicalSpace α} → {inst_3 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → (α →Co β) → ℕ | false |
CategoryTheory.Abelian.SpectralObject.shortComplexOpcyclesThreeδ₂Toδ₁_exact | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₁₂ : i₀ ⟶ i₂) (f₂₃ : i₁ ⟶ i₃) (h₁₂ : Ca... | true |
Aesop.RuleTacDescr.tacticStx.inj | Aesop.RuleTac.Descr | ∀ {stx stx_1 : Lean.Syntax}, Aesop.RuleTacDescr.tacticStx stx = Aesop.RuleTacDescr.tacticStx stx_1 → stx = stx_1 | true |
Std.DHashMap.Raw._aux_Std_Data_DHashMap_Raw___unexpand_Std_DHashMap_Raw_Equiv_1 | Std.Data.DHashMap.Raw | Lean.PrettyPrinter.Unexpander | false |
UniformConvergenceCLM.isEmbedding_coeFn | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : UniformSpace F] [inst_8 : IsUniformAddGr... | true |
ContMDiffRing.rec | Mathlib.Geometry.Manifold.Algebra.Structures | {𝕜 : 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 ℕ∞} →
... | false |
Ordinal.add_le_iff_of_isSuccLimit | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {a b c : Ordinal.{u_4}}, Order.IsSuccLimit b → (a + b ≤ c ↔ ∀ d < b, a + d ≤ c) | true |
MeasurableEquiv.curry._proof_4 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ (ι : Type u_1) (κ : Type u_2) (X : Type u_3) [inst : MeasurableSpace X], Measurable ⇑(Equiv.curry ι κ X).symm | false |
CategoryTheory.Limits.prod.map_id_id | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct X Y],
CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id Y) =
CategoryTheory.CategoryStruct.id (X ⨯ Y) | true |
List.zipWith5._sunfold | Mathlib.Data.List.Defs | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
{δ : Type u_4} →
{ε : Type u_5} → {ζ : Type u_6} → (α → β → γ → δ → ε → ζ) → List α → List β → List γ → List δ → List ε → List ζ | false |
OpenNormalSubgroup.mk | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} →
[inst : Group G] →
[inst_1 : TopologicalSpace G] →
(toOpenSubgroup : OpenSubgroup G) →
autoParam (↑toOpenSubgroup).Normal OpenNormalSubgroup.isNormal'._autoParam → OpenNormalSubgroup G | true |
LieHom.coe_toLinearMap | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieAlgebra R L₁]
[inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L₁ →ₗ⁅R⁆ L₂), ⇑↑f = ⇑f | true |
ContinuousMap.const | Mathlib.Topology.ContinuousMap.Basic | (α : Type u_1) → {β : Type u_2} → [inst : TopologicalSpace α] → [inst_1 : TopologicalSpace β] → β → C(α, β) | true |
HomotopicalAlgebra.FibrantObject.HoCat.ιCompResolutionNatTrans._proof_1 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.FibrantObject C) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp f
{ hom := HomotopicalAlgebra.FibrantObject.HoCat.iResolutionObj (HomotopicalAlgebra.FibrantObject.ι.obj x... | false |
MulDistribMulActionHom.map_inv | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} (A' : Type u_8) [inst_2 : Group A']
[inst_3 : MulDistribMulAction M A'] (B' : Type u_9) [inst_4 : Group B'] [inst_5 : MulDistribMulAction N B']
(f : A' →ₑ*[φ] B') (x : A'), f x⁻¹ = (f x)⁻¹ | true |
_private.Mathlib.Geometry.Euclidean.Inversion.Basic.0.EuclideanGeometry.dist_inversion_mul_dist_center_eq._simp_1_1 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
CategoryTheory.GrothendieckTopology.OneHypercover.toPreOneHypercover | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} → {S : C} → J.OneHypercover S → CategoryTheory.PreOneHypercover S | true |
finsum_mem_insert_of_eq_zero_if_notMem | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] {f : α → M} {a : α} {s : Set α},
(a ∉ s → f a = 0) → ∑ᶠ (i : α) (_ : i ∈ insert a s), f i = ∑ᶠ (i : α) (_ : i ∈ s), f i | true |
CategoryTheory.Adjunction.mapProjectivePresentation._proof_1 | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) [G.PreservesEpimorphisms] (X : C) (Y : CategoryTheory.ProjectivePresentation X),
CategoryTheory.Projective (... | false |
ProbabilityTheory.Kernel.withDensity._proof_1 | Mathlib.Probability.Kernel.WithDensity | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β)
[ProbabilityTheory.IsSFiniteKernel κ] (f : α → β → ENNReal),
Measurable (Function.uncurry f) → Measurable fun a => (κ a).withDensity (f a) | false |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.lintegral_abs_det_fderiv_le_addHaar_image_aux1._simp_1_3 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : LE α] [CanonicallyOrderedAdd α] (a : α), (0 ≤ a) = True | false |
Set.toFinset_eq_empty._simp_1 | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} {s : Set α} [inst : Fintype ↑s], (s.toFinset = ∅) = (s = ∅) | false |
Lean.Lsp.CompletionItemKind.class.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemKind.class = 1 | true |
ArchimedeanOrder.instLT.eq_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddGroup M] [inst_1 : Lattice M],
ArchimedeanOrder.instLT = { lt := fun a b => ∀ (n : ℕ), n • |ArchimedeanOrder.val b| < |ArchimedeanOrder.val a| } | true |
MeasureTheory.Measure.jordanDecompositionOfToSignedMeasureSub | Mathlib.MeasureTheory.VectorMeasure.Decomposition.JordanSub | {X : Type u_1} →
{mX : MeasurableSpace X} →
(μ ν : MeasureTheory.Measure X) →
[MeasureTheory.IsFiniteMeasure μ] → [MeasureTheory.IsFiniteMeasure ν] → MeasureTheory.JordanDecomposition X | true |
WithLp.zero_snd | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {p : ENNReal} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : AddCommGroup β], WithLp.snd 0 = 0 | true |
Set.UniformEquicontinuousOn.mono | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {α : Type u_6} {β : Type u_8} [uα : UniformSpace α] [uβ : UniformSpace β] {H H' : Set (β → α)} {S : Set β},
H.UniformEquicontinuousOn S → H' ⊆ H → H'.UniformEquicontinuousOn S | true |
AddGroup.ofRightAxioms._proof_4 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Add G] [inst_1 : Neg G] [inst_2 : Zero G],
(∀ (a b c : G), a + b + c = a + (b + c)) →
(∀ (a : G), a + 0 = a) → (∀ (a : G), a + -a = 0) → (∀ (a : G), -a + a = 0) → ∀ (a : G), 0 + a = a | false |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem?_toList_ric_eq_some._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | false |
_private.Mathlib.GroupTheory.GroupAction.FixingSubgroup.0.mem_fixingSubmonoid_iff.match_1_1 | Mathlib.GroupTheory.GroupAction.FixingSubgroup | ∀ {α : Type u_1} {s : Set α} (motive : ↑s → Prop) (x : ↑s), (∀ (y : α) (hy : y ∈ s), motive ⟨y, hy⟩) → motive x | false |
_private.Mathlib.GroupTheory.QuotientGroup.Defs.0.QuotientGroup.leftRel_eq_top._simp_1_3 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (b * a = c) = (a = b⁻¹ * c) | false |
Lean.Parser.Level.hole | Lean.Parser.Level | Lean.Parser.Parser | true |
SimpleGraph.IsSRGWith.compl_is_regular | Mathlib.Combinatorics.SimpleGraph.StronglyRegular | ∀ {V : Type u} [inst : Fintype V] {G : SimpleGraph V} [inst_1 : DecidableRel G.Adj] {n k ℓ μ : ℕ}
[inst_2 : DecidableEq V], G.IsSRGWith n k ℓ μ → Gᶜ.IsRegularOfDegree (n - k - 1) | true |
_private.Mathlib.Analysis.Normed.Group.Continuity.0.NormedGroup.toENormedMonoid._simp_2 | Mathlib.Analysis.Normed.Group.Continuity | ∀ (x y : NNReal), ↑x + ↑y = ↑(x + y) | false |
SimpleGraph.Embedding.complEquiv._proof_5 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W},
Function.RightInverse (fun f => { toEmbedding := f.toEmbedding, map_rel_iff' := ⋯ }) fun f =>
{ toEmbedding := f.toEmbedding, map_rel_iff' := ⋯ } | false |
MeasureTheory.measureDense_measurableSet | Mathlib.MeasureTheory.Measure.SeparableMeasure | ∀ {X : Type u_1} [m : MeasurableSpace X] {μ : MeasureTheory.Measure X}, μ.MeasureDense {s | MeasurableSet s} | true |
Polynomial.irreducible_of_dvd_cyclotomic_of_natDegree | Mathlib.RingTheory.Polynomial.Cyclotomic.Factorization | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Fintype K] {p f n : ℕ} {P : Polynomial K},
Fintype.card K = p ^ f →
∀ (hn : p.Coprime n) [hp : Fact (Nat.Prime p)],
P ∣ Polynomial.cyclotomic n K → P.natDegree = orderOf (ZMod.unitOfCoprime (p ^ f) ⋯) → Irreducible P | true |
AlgebraicGeometry.SpecMapRestrictBasicOpenIso._proof_2 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {R S : CommRingCat} (f : R ⟶ S) (r : ↑R),
(TopologicalSpace.Opens.comap { toFun := PrimeSpectrum.comap (CommRingCat.Hom.hom f), continuous_toFun := ⋯ })
(PrimeSpectrum.basicOpen r) =
PrimeSpectrum.basicOpen ((CommRingCat.Hom.hom f) r) | false |
Finset.card_eraseNone_le | Mathlib.Data.Finset.Option | ∀ {α : Type u_1} (s : Finset (Option α)), (Finset.eraseNone s).card ≤ s.card | true |
IsAddUnit.exists_neg | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a : M}, IsAddUnit a → ∃ b, a + b = 0 | true |
_private.Batteries.Tactic.Lint.Frontend.0.Batteries.Tactic.Lint.lintCore.match_3 | Batteries.Tactic.Lint.Frontend | (motive : Option Lean.MessageData → Sort u_1) →
(msg? : Option Lean.MessageData) →
((msg : Lean.MessageData) → motive (some msg)) → ((x : Option Lean.MessageData) → motive x) → motive msg? | false |
Finset.prod_of_isEmpty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} {f : ι → M} [inst : CommMonoid M] [IsEmpty ι] (s : Finset ι), ∏ i ∈ s, f i = 1 | true |
Mathlib.Tactic.ToAdditive.to_additive_dont_translate | Mathlib.Tactic.Translate.ToAdditive | Lean.ParserDescr | true |
NonUnitalStarSubalgebra.mem_map | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {F : Type v'} {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Star A] [inst_4 : NonUnitalNonAssocSemiring B] [inst_5 : Module R B] [inst_6 : Star B]
[inst_7 : FunLike F A B] [inst_8 : NonUnitalAlgHomClass F R A B] [inst_9 : Star... | true |
IsometryEquiv.constVAdd_symm | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : AddGroup G] [inst_2 : AddAction G X]
[inst_3 : IsIsometricVAdd G X] (c : G), (IsometryEquiv.constVAdd c).symm = IsometryEquiv.constVAdd (-c) | true |
String.Pos.le_endPos | Init.Data.String.Basic | ∀ {s : String} (p : s.Pos), p ≤ s.endPos | true |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.Subalgebra.frontier_spectrum._simp_1_1 | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
(r ∉ spectrum R a) = IsUnit ((algebraMap R A) r - a) | false |
SkewMonoidAlgebra.DistribMulActionHom.single._proof_3 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {M : Type u_2} [inst : AddCommMonoid M] {α : Type u_1} (a : α) (x y : M),
(↑(SkewMonoidAlgebra.singleAddHom a)).toFun (x + y) =
(↑(SkewMonoidAlgebra.singleAddHom a)).toFun x + (↑(SkewMonoidAlgebra.singleAddHom a)).toFun y | false |
Std.DTreeMap.Internal.Impl.Equiv.constGetEntryGE_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
(h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂) {k : α} {he : ∃ a ∈ t₁, (compare a k).isGE = true},
Std.DTreeMap.Internal.Impl.Const.getEntryGE k t₁ ⋯ he = Std.DTreeMap.Internal.Impl.Const.getEntryGE ... | true |
FirstOrder.Language.DefinableSet.instInhabited | Mathlib.ModelTheory.Definability | {L : FirstOrder.Language} →
{M : Type w} → [inst : L.Structure M] → {A : Set M} → {α : Type u₁} → Inhabited (L.DefinableSet A α) | true |
_private.Mathlib.LinearAlgebra.RootSystem.Basic.0.RootPairing.coroot_eq_coreflection_of_root_eq' | Mathlib.LinearAlgebra.RootSystem.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] [Finite ι] [CharZero R] [IsDomain R]
[Module.IsTorsionFree R M] (p : M →ₗ[R] N →ₗ[R] R) [p.IsPerfPair] (root : ι ↪ M) (coroot : ι ↪ N),
... | true |
_private.Std.Data.Iterators.Lemmas.Combinators.DropWhile.0.Std.IterM.step_intermediateDropWhile.match_1.splitter | Std.Data.Iterators.Lemmas.Combinators.DropWhile | (motive : Bool → Sort u_1) → (x : Bool) → (x = true → motive true) → (x = false → motive false) → motive x | true |
Submonoid.center | Mathlib.GroupTheory.Submonoid.Center | (M : Type u_1) → [inst : MulOneClass M] → Submonoid M | true |
CategoryTheory.Lax.StrongTrans.mk._flat_ctor | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
(app : (a : B) → F.obj a ⟶ G.obj a) →
(naturality :
{a b : B} →
(f : a ⟶ b) →
... | false |
Lean.Lsp.SignatureHelpParams.recOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SignatureHelpParams → Sort u} →
(t : Lean.Lsp.SignatureHelpParams) →
((toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams) →
(toWorkDoneProgressParams : Lean.Lsp.WorkDoneProgressParams) →
(context? : Option Lean.Lsp.SignatureHelpContext) →
motive
... | false |
MulEquiv.piUnits._proof_9 | Mathlib.Algebra.Group.Pi.Units | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (x x_1 : ((i : ι) → M i)ˣ),
(fun i => { val := ↑(x * x_1) i, inv := (x * x_1).inv i, val_inv := ⋯, inv_val := ⋯ }) = fun i =>
{ val := ↑(x * x_1) i, inv := (x * x_1).inv i, val_inv := ⋯, inv_val := ⋯ } | false |
UInt16.ofNatLT_shiftLeft | Init.Data.UInt.Bitwise | ∀ {a b : ℕ} (ha : a <<< b < UInt16.size) (hb : b < 16),
UInt16.ofNatLT (a <<< b) ha = UInt16.ofNatLT a ⋯ <<< UInt16.ofNatLT b ⋯ | true |
Matrix.compLinearEquiv | Mathlib.Data.Matrix.Composition | (I : Type u_1) →
(J : Type u_2) →
(K : Type u_3) →
(L : Type u_4) →
(R : Type u_5) →
(R₀ : Type u_7) →
[inst : Semiring R₀] →
[inst_1 : AddCommMonoid R] →
[inst_2 : Module R₀ R] → Matrix I J (Matrix K L R) ≃ₗ[R₀] Matrix (I × K) (J × L) R | true |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.inverse_obj_left_right_as | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor T D) (Y : D) (X : T)
(Y_1 : CategoryTheory.CostructuredArrow ((CategoryTheory.Over.forget X).comp F) Y),
((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEqu... | true |
_private.Batteries.Tactic.Trans.0.Batteries.Tactic.getRel.match_3 | Batteries.Tactic.Trans | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Lean.Expr)) →
((rel x : Lean.Expr) → motive (some (rel, x))) → (Unit → motive none) → motive __do_lift | false |
Set.exists_mem_of_nonempty | Mathlib.Data.Set.Basic | ∀ (α : Type u_1) [Nonempty α], ∃ x, x ∈ Set.univ | true |
Std.Sat.AIG.RelabelNat.State.Inv1.below.rec | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α]
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv1 a a_1 → Prop}
{motive_1 :
{a : ℕ} →
{a_1 : Std.HashMap α ℕ} →
(t : Std.Sat.AIG.RelabelNat.State.Inv1 a a_1) → Std.Sat.AIG.RelabelNat.State.Inv1.below t → Prop},... | false |
Lean.Meta.instToExprCoeFnInfo | Lean.Meta.CoeAttr | Lean.ToExpr Lean.Meta.CoeFnInfo | true |
CategoryTheory.CartesianClosed.uncurry_eq | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X Y : C}
[inst_2 : CategoryTheory.Closed A] (g : Y ⟶ A ⟹ X),
CategoryTheory.MonoidalClosed.uncurry g =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft A g)
((Categ... | true |
AddUnits.orderEmbeddingVal_apply | Mathlib.Algebra.Order.Monoid.Units | ∀ {α : Type u_1} [inst : AddMonoid α] [inst_1 : LinearOrder α], ⇑AddUnits.orderEmbeddingVal = AddUnits.val | true |
CategoryTheory.MorphismProperty.Comma.isoFromComma._proof_2 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | false |
Lean.Elab.Term.MVarErrorInfo._sizeOf_1 | Lean.Elab.Term.TermElabM | Lean.Elab.Term.MVarErrorInfo → ℕ | false |
CategoryTheory.Functor.toOver | Mathlib.CategoryTheory.Comma.Over.Basic | {T : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} T] →
{S : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} S] →
(F : CategoryTheory.Functor S T) →
(X : T) →
(f : (Y : S) → F.obj Y ⟶ X) →
(∀ {Y Z : S} (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (F... | true |
Aesop.UnorderedArraySet.noConfusionType | Aesop.Util.UnorderedArraySet | Sort u →
{α : Type u_1} →
[inst : BEq α] →
Aesop.UnorderedArraySet α → {α' : Type u_1} → [inst' : BEq α'] → Aesop.UnorderedArraySet α' → Sort u | false |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.mem_degreeLT._simp_1_2 | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | false |
Lean.Meta.Simp.State.usedTheorems._default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.UsedSimps | false |
CategoryTheory.Limits.WalkingMulticospan.instFintype | Mathlib.CategoryTheory.Limits.Shapes.FiniteMultiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
[Fintype J.L] → [Fintype J.R] → Fintype (CategoryTheory.Limits.WalkingMulticospan J) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.