name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Functor.leftKanExtensionUnit_leftKanExtension_map_leftKanExtensionObjIsoColimit_hom | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : Ca... | true |
Std.DTreeMap.Internal.Impl.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.LawfulEqOrd α] →
(k : α) →
(Option (β k) → Option (β k)) →
(t : Std.DTreeMap.Internal.Impl α β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (t.size - 1) (t.size + 1) | false |
Lean.Meta.Simp.initFn._@.Lean.Meta.Tactic.Simp.Main.3634004939._hygCtx._hyg.4 | Lean.Meta.Tactic.Simp.Main | IO (Lean.Option Bool) | false |
CategoryTheory.rightDistrib | Mathlib.CategoryTheory.Distributive.Monoidal | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] →
[CategoryTheory.IsMonoidalRightDistrib C] →
(X Y Z : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj Y X ⨿... | true |
Set.list_sum_subset_list_sum | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : List ι) (f₁ f₂ : ι → Set α),
(∀ i ∈ t, f₁ i ⊆ f₂ i) → (List.map f₁ t).sum ⊆ (List.map f₂ t).sum | true |
UInt64.add_comm | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a + b = b + a | true |
Rep.hom_ext | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{w, u, v} k G} {f g : A ⟶ B},
Rep.Hom.hom f = Rep.Hom.hom g → f = g | true |
Ordinal.veblen_gamma_zero | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Ordinal.veblen o.gamma 0 = o.gamma | true |
_private.Mathlib.Order.Concept.0.mem_lowerPolar_singleton._simp_1_2 | Mathlib.Order.Concept | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
CategoryTheory.Subgroupoid.hom | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} →
[inst : CategoryTheory.Groupoid C] → (S : CategoryTheory.Subgroupoid C) → CategoryTheory.Functor (↑S.objs) C | true |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_3 | Init.Data.String.FindPos | ∀ (s : String.Slice) (offset : String.Pos.Raw) (h : offset ≤ s.rawEndPos) (this : offset < s.rawEndPos),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun offset h => s.utf8ByteSize - offset.byteIdx)
⟨offset.inc, ⋯⟩ ⟨offset, h⟩ | false |
_private.Mathlib.Analysis.InnerProductSpace.PiL2.0.OrthonormalBasis.singleton._simp_1 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{ι : Type u_4} [inst_3 : DecidableEq ι] {v : ι → E},
Orthonormal 𝕜 v = ∀ (i j : ι), inner 𝕜 (v i) (v j) = if i = j then 1 else 0 | false |
Lean.Meta.mkSub | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
Algebra.RingHom.adjoinAlgebraMap | Mathlib.RingTheory.Adjoin.Singleton | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
[inst : CommSemiring A] →
[inst_1 : CommSemiring B] →
[inst_2 : CommSemiring C] →
[inst_3 : Algebra A B] →
[inst_4 : Algebra B C] →
[inst_5 : Algebra A C] → [IsScalarTower A B C] → (b : B) → ↥A[b] ... | true |
Real.fromBinary._proof_2 | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | ∀ (x : ℕ → Bool),
0 ≤ (Real.ofDigits ∘ ⇑(Homeomorph.piCongrRight fun x => finTwoEquiv.toHomeomorphOfDiscrete.symm)) x ∧
(Real.ofDigits ∘ ⇑(Homeomorph.piCongrRight fun x => finTwoEquiv.toHomeomorphOfDiscrete.symm)) x ≤ 1 | false |
Lean.LocalContext.foldr | Lean.LocalContext | {β : Type u_1} → Lean.LocalContext → (Lean.LocalDecl → β → β) → β → β | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionHom_comp | 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}
[self : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {c c' c'' : C} {d d' d'' : D} (f₁ : c ⟶ c')
(f₂ : c' ⟶ c'') (g₁ : d ⟶ d') (g₂ :... | true |
Affine.Simplex.orthogonalProjection_eq_circumcenter_of_exists_dist_eq | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) {p : P},
(∃ r, ∀ (i : Fin (n + 1)), dist (s.points i) p = r) → ↑(s.orthogonalProjectionSpan p) = s.circumcenter | true |
Commute.sub_dvd_pow_sub_pow | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] {x y : R}, Commute x y → ∀ (n : ℕ), x - y ∣ x ^ n - y ^ n | true |
Erased.join | Mathlib.Data.Erased | {α : Sort u_1} → Erased (Erased α) → Erased α | true |
CategoryTheory.ObjectProperty.SerreClassLocalization.map_eq_zero_iff | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] [L.IsLocalization P.isoModSerre] [inst_5 : CategoryTheory.Preaddit... | true |
_private.Mathlib.RingTheory.DividedPowerAlgebra.Init.0.DividedPowerAlgebra.dp_sum_smul._simp_1_1 | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : CommMonoid M] {f g : ι → M},
(∏ x ∈ s, f x) * ∏ x ∈ s, g x = ∏ x ∈ s, f x * g x | false |
CategoryTheory.SmallCategoryCardinalLT.exists_equivalence | Mathlib.CategoryTheory.SmallRepresentatives | ∀ (κ : Cardinal.{w}) (C : Type u) [inst : CategoryTheory.Category.{v, u} C],
HasCardinalLT (CategoryTheory.Arrow C) κ →
∃ S, Nonempty (CategoryTheory.SmallCategoryCardinalLT.categoryFamily κ S ≌ C) | true |
ClosureOperator.le_closure | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : PartialOrder α] (c : ClosureOperator α) (x : α), x ≤ c x | true |
IsCoveringMap.liftHomotopyRel._proof_1 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_3} {A : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X]
[inst_2 : TopologicalSpace A] {p : E → X} (cov : IsCoveringMap p) {f₀ f₁ : C(A, X)} {S : Set A}
(F : f₀.HomotopyRel f₁ S) {f₀' : C(A, E)} (F_0 : ∀ (a : A), F (0, a) = p (f₀' a)) (t : ↑unitInterval),
∀ a ∈ S, (... | false |
_private.Mathlib.Topology.Separation.Basic.0.t1Space_TFAE._simp_1_7 | Mathlib.Topology.Separation.Basic | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ⊆ {a}ᶜ) = (a ∉ s) | false |
commutator_def | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G], commutator G = ⁅⊤, ⊤⁆ | true |
Pi.mulZeroClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] (a : (i : ι) → α i), a * 0 = 0 | false |
contDiff_one_iff_fderiv | 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},
ContDiff 𝕜 1 f ↔ Differentiable 𝕜 f ∧ Continuous (fderiv 𝕜 f) | true |
FiberBundleCore.mk_mem_localTrivAt_source | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (b : B) (a : F), ⟨b, a⟩ ∈ (Z.localTrivAt b).source | true |
CategoryTheory.SingleObj | Mathlib.CategoryTheory.SingleObj | Type u_1 → Type | true |
Std.Tactic.BVDecide.LRAT.instBEqAction.beq._sparseCasesOn_2 | Std.Tactic.BVDecide.LRAT.Actions | {β : Type u} →
{α : Type v} →
{motive : Std.Tactic.BVDecide.LRAT.Action β α → Sort u_1} →
(t : Std.Tactic.BVDecide.LRAT.Action β α) →
((id : ℕ) → (c : β) → (rupHints : Array ℕ) → motive (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motiv... | false |
AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals_mono | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Monotone AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals | true |
_private.Lean.Level.0.Lean.Level.normLtAux._unary.eq_def | Lean.Level | ∀ (_x : (_ : Lean.Level) ×' (_ : ℕ) ×' (_ : Lean.Level) ×' ℕ),
Lean.Level.normLtAux._unary _x =
PSigma.casesOn _x fun a a_1 =>
PSigma.casesOn a_1 fun a_2 a_3 =>
PSigma.casesOn a_3 fun a_4 a_5 =>
match a, a_2, a_4, a_5 with
| l₁.succ, k₁, l₂, k₂ => Lean.Level.normLtAux._unary ⟨l₁,... | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix.noConfusionType | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | Sort u →
{n m : ℕ} →
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n m →
{n' m' : ℕ} → Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n' m' → Sort u | false |
_private.Mathlib.Analysis.Analytic.Within.0.analyticWithinAt_of_singleton_mem._simp_1_3 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn.eq_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] (f : α → β) (y : α) (ys : List α)
(h_2 : y :: ys ≠ []), List.minIdxOn f (y :: ys) h_2 = List.minIdxOn.go✝ f y 0 1 ys | true |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_4} {D : Type u_3} [inst : CategoryTheory.Category.{u_5, u_4} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
{X Y : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))} (f : X ⟶ Y)
(X' : PresheafOf... | false |
CategoryTheory.StructuredArrow.pre_obj_hom | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (S : D) (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D) (X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S)... | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM.computeCoefficients.go._sunfold | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap →
Lean.Expr →
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarStateM
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.CoefficientsMap | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Pasting_0_CategoryTheory_Limits_termI₂_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.Macro | false |
Prod.Lex.uniqueProd | Mathlib.Order.Hom.Lex | (α : Type u_2) → (β : Type u_3) → [inst : Preorder α] → [Unique α] → [inst_2 : LE β] → Lex (α × β) ≃o β | true |
AnalyticOn.contDiff | 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}
{n : WithTop ℕ∞}, AnalyticOn 𝕜 f Set.univ → ContDiff 𝕜 n f | true |
AlgebraicIndependent.matroid.congr_simp | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ (R : Type u_1) (A : Type w) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : FaithfulSMul R A] [inst_4 : NoZeroDivisors A],
AlgebraicIndependent.matroid R A = AlgebraicIndependent.matroid R A | true |
CategoryTheory.Functor.additive_of_comp_faithful | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Preadditive C] [inst_4 : CategoryTheory.Preadditive D]
[inst_5 : CategoryTheory.Preadditive E] (F : ... | true |
WithLp.prodContinuousLinearEquiv_symm_apply_ofLp | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Semiring 𝕜] [inst_3 : AddCommGroup α] [inst_4 : AddCommGroup β] [inst_5 : Module 𝕜 α] [inst_6 : Module 𝕜 β]
(a : α × β), ((WithLp.prodContinuousLinearEquiv p 𝕜 α β).symm a).ofLp = a | true |
Algebra.intNorm_eq_of_isLocalization | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ {A : Type u_1} {B : Type u_6} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {Aₘ : Type u_9}
{Bₘ : Type u_10} [inst_3 : CommRing Aₘ] [inst_4 : CommRing Bₘ] [inst_5 : Algebra Aₘ Bₘ] [inst_6 : Algebra A Aₘ]
[inst_7 : Algebra B Bₘ] [inst_8 : Algebra A Bₘ] [IsScalarTower A Aₘ Bₘ] [IsScalarTower A B ... | true |
Lean.Elab.Term.LetRecToLift.termination | Lean.Elab.Term.TermElabM | Lean.Elab.Term.LetRecToLift → Lean.Elab.TerminationHints | true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.drop.match_1.eq_1 | Mathlib.Data.WSeq.Basic | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | true |
GromovHausdorff.instMetricSpaceOptimalGHCoupling._proof_22 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ (X : Type u_1) (Y : Type u_2) [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
[inst_3 : MetricSpace Y] [inst_4 : CompactSpace Y] [inst_5 : Nonempty Y],
GromovHausdorff.instMetricSpaceOptimalGHCoupling._aux_20 X Y ≤ Filter.cofinite | false |
TypeVec.prod.diag.eq_1 | Mathlib.Data.TypeVec | ∀ (n : ℕ) (α : TypeVec.{u} n.succ) (a : Fin2 n) (x_4 : α a.fs), TypeVec.prod.diag a.fs x_4 = TypeVec.prod.diag a x_4 | true |
FreeMonoid.of_injective | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, Function.Injective FreeMonoid.of | true |
Lean.Grind.instCommRingBitVec._proof_1 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ), OfNat.ofNat n = ↑n | false |
_private.Mathlib.Data.Finset.Defs.0.Finset.forall_mem_not_eq._proof_1_1 | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {s : Finset α} {a : α}, (∀ b ∈ s, ¬a = b) ↔ a ∉ s | false |
SimplexCategoryGenRel.δ_comp_δ_assoc | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i j : Fin (n + 2)},
i ≤ j →
∀ {Z : SimplexCategoryGenRel} (h : SimplexCategoryGenRel.mk (n + 1 + 1) ⟶ Z),
CategoryTheory.CategoryStruct.comp (SimplexCategoryGenRel.δ i)
(CategoryTheory.CategoryStruct.comp (SimplexCategoryGenRel.δ j.succ) h) =
CategoryTheory.CategoryStruct.comp (... | true |
CategoryTheory.Abelian.Ext.mono_postcomp_mk₀_of_mono | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (L : C) {M N : C} (f : M ⟶ N) [hf : CategoryTheory.Mono f],
CategoryTheory.Mono (AddCommGrpCat.ofHom ((CategoryTheory.Abelian.Ext.mk₀ f).postcomp L ⋯)) | true |
PNat.XgcdType.instSizeOf | Mathlib.Data.PNat.Xgcd | SizeOf PNat.XgcdType | true |
Lean.InductiveType.noConfusionType | Lean.Declaration | Sort u → Lean.InductiveType → Lean.InductiveType → Sort u | false |
IsLocalization.mk'_eq_mk' | Mathlib.Algebra.Module.LocalizedModule.IsLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_2) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] (x : R) (s : ↥S),
IsLocalization.mk' A x s = IsLocalizedModule.mk' (Algebra.linearMap R A) x s | true |
Submodule.ker_inl | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₂]
[inst_3 : Module R M] [inst_4 : Module R M₂], (LinearMap.inl R M M₂).ker = ⊥ | true |
Batteries.Tactic.DiscrTreeCache.getMatch | Batteries.Util.Cache | {α : Type} → Batteries.Tactic.DiscrTreeCache α → Lean.Expr → Lean.MetaM (Array α) | true |
Nat.factorial_pos | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ), 0 < n.factorial | true |
IsAddCyclic.index_nsmulAddMonoidHom_range | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ (G : Type u_2) [inst : AddCommGroup G] [IsAddCyclic G] [Finite G] (d : ℕ),
(nsmulAddMonoidHom d).range.index = (Nat.card G).gcd d | true |
_private.Lean.Server.AsyncList.0.IO.AsyncList.getFinishedPrefixWithTimeout.go.match_1 | Lean.Server.AsyncList | {ε α : Type} →
(motive : Unit ⊕ Except ε (IO.AsyncList ε α) → Sort u_1) →
(r : Unit ⊕ Except ε (IO.AsyncList ε α)) →
((val : Unit) → motive (Sum.inl val)) →
((tl : IO.AsyncList ε α) → motive (Sum.inr (Except.ok tl))) →
((e : ε) → motive (Sum.inr (Except.error e))) → motive r | false |
ValuativeRel.inv_vle_one | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {K : Type u_2} [inst : Field K] [inst_1 : ValuativeRel K] {x : K}, x ≠ 0 → (x⁻¹ ≤ᵥ 1 ↔ 1 ≤ᵥ x) | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Sort u → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u | false |
_private.Init.Data.List.Basic.0.List.getLast?.match_1.eq_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as | true |
TannakaDuality.FiniteGroup.equiv._proof_2 | Mathlib.RepresentationTheory.Tannaka | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G] [Finite G] [IsDomain k],
Function.Injective ⇑(TannakaDuality.FiniteGroup.equivHom k G) ∧
Function.Surjective ⇑(TannakaDuality.FiniteGroup.equivHom k G) | false |
Std.ExtDTreeMap.maxKeyD_alter_eq_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α} {f : Option (β k) → Option (β k)},
t.alter k f ≠ ∅ →
∀ {fallback : α},
(t.alter k f).maxKeyD fallback = k ↔ (f (t.get? k)).isSome = true ∧ ∀ k' ∈ t, (cmp ... | true |
_private.Mathlib.Geometry.Manifold.PartitionOfUnity.0.exists_contMDiff_support_eq_eq_one_iff._simp_1_2 | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a = a + b) = (b = 0) | false |
Lean.Util.ParamMinimizer.Result._sizeOf_inst | Lean.Util.ParamMinimizer | SizeOf Lean.Util.ParamMinimizer.Result | false |
_private.Init.Data.Range.Polymorphic.SInt.0.Int16.toBitVec_minValueSealed_eq_intMinSealed | Init.Data.Range.Polymorphic.SInt | Int16.minValueSealed✝.toBitVec = BitVec.Signed.intMinSealed✝ 16 | true |
Lean.Lsp.DiagnosticTag.deprecated | Lean.Data.Lsp.Diagnostics | Lean.Lsp.DiagnosticTag | true |
Polynomial.ofFinsupp_pow | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : AddMonoidAlgebra R ℕ) (n : ℕ), { toFinsupp := a ^ n } = { toFinsupp := a } ^ n | true |
HahnSeries.instIsOrderedAddMonoidLex | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid R]
[AddLeftStrictMono R], IsOrderedAddMonoid (Lex (HahnSeries Γ R)) | true |
Multiset.map_subset_map | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} {f : α → β} {s t : Multiset α}, s ⊆ t → Multiset.map f s ⊆ Multiset.map f t | true |
CategoryTheory.Functor.IsCoverDense.Types.sheafIso_inv_hom | 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] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} [inst_2 : G.IsCoverDense K] [inst_3 : G.IsLocallyFull K]
{ℱ ℱ' : CategoryTheory.Sheaf K (Type v)} (i : G.op.com... | true |
_private.Mathlib.Data.Multiset.Powerset.0.Multiset.powersetCard_le_powerset._simp_1_1 | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ ≤ ↑l₂) = l₁.Subperm l₂ | false |
CategoryTheory.Limits.coend.hom_ext_iff | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)} [inst_2 : CategoryTheory.Limits.HasCoend F] {X : C}
{f g : CategoryTheory.Limits.coend F ⟶ X},
f = g ↔
∀ (j : J),
CategoryThe... | true |
_private.Mathlib.CategoryTheory.Localization.Monoidal.Basic.0.CategoryTheory.Localization.Monoidal.associator_naturality₃._simp_1_1 | Mathlib.CategoryTheory.Localization.Monoidal.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] (L : CategoryTheory.Functor C D)
(W : CategoryTheory.MorphismProperty C) [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} (ε : ... | false |
Lean.IR.Expr.lit.elim | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) → t.ctorIdx = 11 → ((v : Lean.IR.LitVal) → motive (Lean.IR.Expr.lit v)) → motive t | false |
_private.Batteries.Data.Random.MersenneTwister.0.Batteries.Random.MersenneTwister.Config.init.loop._unary | Batteries.Data.Random.MersenneTwister | (cfg : Batteries.Random.MersenneTwister.Config) →
(_ : BitVec cfg.wordSize) ×' (v : Array (BitVec cfg.wordSize)) ×' v.size ≤ cfg.stateSize →
Vector (BitVec cfg.wordSize) cfg.stateSize | false |
ExistsAndEq.instInhabitedGoTo.default | Mathlib.Tactic.Simproc.ExistsAndEq | ExistsAndEq.GoTo | true |
ConvexOn.le_left_of_right_le' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : SMul 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConvexOn 𝕜 s f ... | true |
String.utf8InductionOn._sunfold | Batteries.Data.String.Lemmas | {motive : List Char → String.Pos.Raw → Sort u} →
(s : List Char) →
(i p : String.Pos.Raw) →
((i : String.Pos.Raw) → motive [] i) →
((c : Char) → (cs : List Char) → motive (c :: cs) p) →
((c : Char) → (cs : List Char) → (i : String.Pos.Raw) → i ≠ p → motive cs (i + c) → motive (c :: cs) i) ... | false |
AlgCat.instRingElemForallObjCompForgetAlgHomCarrierSections._proof_23 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_1} [inst_1 : CategoryTheory.Category.{u_3, u_1} J]
(F : CategoryTheory.Functor J (AlgCat R)) (a : ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections), a * 1 = a | false |
Std.Internal.IO.Async.EAsync.ofETask | Std.Internal.Async.Basic | {ε α : Type} → Std.Internal.IO.Async.ETask ε α → Std.Internal.IO.Async.EAsync ε α | true |
Std.Rxc.Iterator.toList_eq_toList_rxoIterator | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : LT α] [inst_3 : DecidableLT α]
[inst_4 : Std.PRange.UpwardEnumerable α] [Std.Rxc.IsAlwaysFinite α] [Std.Rxo.IsAlwaysFinite α]
[Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerableLT α]
[inst_... | true |
Cardinal.mk_list_eq_max_mk_aleph0 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ (α : Type u) [Nonempty α], Cardinal.mk (List α) = max (Cardinal.mk α) Cardinal.aleph0 | true |
_private.Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong.0._auto_83 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax | false |
CategoryTheory.Iso.cancel_iso_hom_left._simp_2 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ≅ Y) (g g' : Y ⟶ Z),
(CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.comp f.hom g') = (g = g') | false |
DerivedCategory.instHasZeroObject | Mathlib.Algebra.Homology.DerivedCategory.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C], CategoryTheory.Limits.HasZeroObject (DerivedCategory C) | true |
Part._sizeOf_inst | Mathlib.Data.Part | (α : Type u) → [SizeOf α] → SizeOf (Part α) | false |
idealFactorsEquivOfQuotEquiv._proof_6 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : IsDedekindDomain A] {I : Ideal R}
{J : Ideal A} [inst_3 : IsDedekindDomain R] (f : R ⧸ I ≃+* A ⧸ J) (f_surj : Function.Surjective ⇑↑f)
(fsym_surj : Function.Surjective ⇑↑f.symm),
(idealFactorsFunOfQuotHom fsym_surj).comp (idealFac... | false |
Lean.Elab.Structural.State | Lean.Elab.PreDefinition.Structural.Basic | Type | true |
TannakaDuality.FiniteGroup.equivHom._proof_3 | Mathlib.RepresentationTheory.Tannaka | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G],
CategoryTheory.LaxMonoidalFunctor.isoOfComponents (TannakaDuality.FiniteGroup.equivApp 1) ⋯ ⋯ ⋯ = 1 | false |
HahnModule.instAddCommMonoid._proof_8 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_2} {V : Type u_3} [inst : PartialOrder Γ] [inst_1 : SMul R V] [inst_2 : AddCommMonoid V],
autoParam (∀ (x : HahnModule Γ R V), HahnModule.instAddCommMonoid._aux_6 0 x = 0) AddMonoid.nsmul_zero._autoParam | false |
groupHomology.chainsMap_f_hom | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B) (i : ℕ),
ModuleCat.Hom.hom ((groupHomology.chainsMap f φ).f i) =
Finsupp.mapRange.linearMap (Rep.Hom.hom φ).toLinearMap ∘ₗ Finsupp.lmapDomain (↑A) k fun... | true |
_private.Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic.0.ValueDistribution.proximity_mul_top_le._simp_1_2 | Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic | ∀ {α : Type u_2} [inst : Norm α] [inst_1 : Mul α] [NormMulClass α] (a b : α), ‖a‖ * ‖b‖ = ‖a * b‖ | false |
HopfAlgCat.instMonoidalCategoryStruct._proof_1 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : HopfAlgCat R), IsScalarTower R R X.carrier | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.