name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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) → ↥(Algebra.adjoin A {b}) →+* ↥(Algebra.adjoin A {(algebraMap B C) b}) |
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 |
Lean.LocalContext.foldr | Lean.LocalContext | {β : Type u_1} → Lean.LocalContext → (Lean.LocalDecl → β → β) → β → β |
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₂ : d' ⟶ d''),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHom (CategoryTheory.CategoryStruct.comp f₁ f₂)
(CategoryTheory.CategoryStruct.comp g₁ g₂) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHom f₁ g₁)
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHom f₂ g₂) |
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 |
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 |
Erased.join | Mathlib.Data.Erased | {α : Sort u_1} → Erased (Erased α) → Erased α |
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.Preadditive D] [L.Additive]
{X Y : C} (f : X ⟶ Y), L.map f = 0 ↔ P (CategoryTheory.Abelian.image f) |
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) |
ClosureOperator.le_closure | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : PartialOrder α] (c : ClosureOperator α) (x : α), x ≤ c x |
CategoryTheory.Mon_Class.comp_mul | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M X Y : C} [inst_2 : CategoryTheory.MonObj M] (f : X ⟶ Y) (g₁ g₂ : Y ⟶ M),
CategoryTheory.CategoryStruct.comp f (g₁ * g₂) =
CategoryTheory.CategoryStruct.comp f g₁ * CategoryTheory.CategoryStruct.comp f g₂ |
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, (cov.liftHomotopy (↑F) f₀' F_0) (t, a) = f₀' a |
_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) |
commutator_def | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G], commutator G = ⁅⊤, ⊤⁆ |
Pi.mulZeroClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] (a : (i : ι) → α i), a * 0 = 0 |
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) |
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 |
CategoryTheory.SingleObj | Mathlib.CategoryTheory.SingleObj | Type u_1 → Type |
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) → motive t |
AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals_mono | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Monotone AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals |
_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₁, ⟨k₁ + 1, ⟨l₂, k₂⟩⟩⟩
| l₁, k₁, l₂.succ, k₂ => Lean.Level.normLtAux._unary ⟨l₁, ⟨k₁, ⟨l₂, k₂ + 1⟩⟩⟩
| l₁@h:(l₁₁.max l₁₂), k₁, l₂@h_1:(l₂₁.max l₂₂), k₂ =>
if (l₁ == l₂) = true then decide (k₁ < k₂)
else
if (l₁₁ != l₂₁) = true then Lean.Level.normLtAux._unary ⟨l₁₁, ⟨0, ⟨l₂₁, 0⟩⟩⟩
else Lean.Level.normLtAux._unary ⟨l₁₂, ⟨0, ⟨l₂₂, 0⟩⟩⟩
| l₁@h:(l₁₁.imax l₁₂), k₁, l₂@h_1:(l₂₁.imax l₂₂), k₂ =>
if (l₁ == l₂) = true then decide (k₁ < k₂)
else
if (l₁₁ != l₂₁) = true then Lean.Level.normLtAux._unary ⟨l₁₁, ⟨0, ⟨l₂₁, 0⟩⟩⟩
else Lean.Level.normLtAux._unary ⟨l₁₂, ⟨0, ⟨l₂₂, 0⟩⟩⟩
| Lean.Level.param n₁, k₁, Lean.Level.param n₂, k₂ => if (n₁ == n₂) = true then decide (k₁ < k₂) else n₁.lt n₂
| Lean.Level.mvar n₁, k₁, Lean.Level.mvar n₂, k₂ =>
if (n₁ == n₂) = true then decide (k₁ < k₂) else n₁.name.lt n₂.name
| l₁, k₁, l₂, k₂ => if (l₁ == l₂) = true then decide (k₁ < k₂) else decide (l₁.ctorToNat < l₂.ctorToNat) |
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 |
_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) |
_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 |
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) (F.comp G)),
((CategoryTheory.StructuredArrow.pre S F G).obj X).hom = X.hom |
_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 |
_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 |
Prod.Lex.uniqueProd | Mathlib.Order.Hom.Lex | (α : Type u_2) → (β : Type u_3) → [inst : Preorder α] → [Unique α] → [inst_2 : LE β] → Lex (α × β) ≃o β |
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 |
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 |
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 : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [G.Additive]
[(F.comp G).Additive] [G.Faithful], F.Additive |
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 |
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 Bₘ] (M : Submonoid A)
[IsLocalization M Aₘ] [IsLocalization (Algebra.algebraMapSubmonoid B M) Bₘ] [inst_13 : IsIntegrallyClosed A]
[inst_14 : IsDomain A] [inst_15 : IsDomain B] [inst_16 : IsIntegrallyClosed B] [inst_17 : Algebra.IsIntegral A B]
[inst_18 : Module.IsTorsionFree A B] [inst_19 : IsDomain Aₘ] [inst_20 : IsIntegrallyClosed Aₘ] [inst_21 : IsDomain Bₘ]
[inst_22 : IsIntegrallyClosed Bₘ] [inst_23 : Module.IsTorsionFree Aₘ Bₘ] [inst_24 : Algebra.IsIntegral Aₘ Bₘ]
[FiniteDimensional (FractionRing A) (FractionRing B)] (x : B),
(algebraMap A Aₘ) ((Algebra.intNorm A B) x) = (Algebra.intNorm Aₘ Bₘ) ((algebraMap B Bₘ) x) |
Lean.Elab.Term.LetRecToLift.termination | Lean.Elab.Term.TermElabM | Lean.Elab.Term.LetRecToLift → Lean.Elab.TerminationHints |
_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 () |
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 |
FreeMonoid.of_injective | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, Function.Injective FreeMonoid.of |
Lean.Grind.instCommRingBitVec._proof_1 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ), OfNat.ofNat n = ↑n |
_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 |
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 (SimplexCategoryGenRel.δ j)
(CategoryTheory.CategoryStruct.comp (SimplexCategoryGenRel.δ i.castSucc) h) |
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 ⋯)) |
PNat.XgcdType.instSizeOf | Mathlib.Data.PNat.Xgcd | SizeOf PNat.XgcdType |
Lean.InductiveType.noConfusionType | Lean.Declaration | Sort u → Lean.InductiveType → Lean.InductiveType → Sort u |
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 |
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 = ⊥ |
Batteries.Tactic.DiscrTreeCache.getMatch | Batteries.Util.Cache | {α : Type} → Batteries.Tactic.DiscrTreeCache α → Lean.Expr → Lean.MetaM (Array α) |
Nat.factorial_pos | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ), 0 < n.factorial |
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 |
_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 |
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) |
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 |
_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 |
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) |
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 k' k).isLE = 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) |
Lean.Util.ParamMinimizer.Result._sizeOf_inst | Lean.Util.ParamMinimizer | SizeOf Lean.Util.ParamMinimizer.Result |
_private.Init.Data.Range.Polymorphic.SInt.0.Int16.toBitVec_minValueSealed_eq_intMinSealed | Init.Data.Range.Polymorphic.SInt | Int16.minValueSealed✝.toBitVec = BitVec.Signed.intMinSealed✝ 16 |
Lean.Lsp.DiagnosticTag.deprecated | Lean.Data.Lsp.Diagnostics | Lean.Lsp.DiagnosticTag |
Polynomial.ofFinsupp_pow | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : AddMonoidAlgebra R ℕ) (n : ℕ), { toFinsupp := a ^ n } = { toFinsupp := a } ^ n |
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)) |
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 |
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.comp ℱ.obj ≅ G.op.comp ℱ'.obj),
(CategoryTheory.Functor.IsCoverDense.Types.sheafIso i).inv.hom =
(CategoryTheory.Functor.IsCoverDense.Types.presheafIso i).inv |
_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₂ |
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),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coend.ι F j) f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coend.ι F j) g |
_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} (ε : L.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ unit)
(X : CategoryTheory.LocalizedMonoidal L W ε) {Y₁ Y₂ : CategoryTheory.LocalizedMonoidal L W ε} (f : Y₁ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X) f |
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 |
_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 |
ExistsAndEq.instInhabitedGoTo.default | Mathlib.Tactic.Simproc.ExistsAndEq | ExistsAndEq.GoTo |
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 →
∀ {x y : E},
x ∈ s → y ∈ s → ∀ {a b : 𝕜}, 0 < a → 0 ≤ b → a + b = 1 → f y ≤ f (a • x + b • y) → f (a • x + b • y) ≤ f x |
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) →
motive s i |
Std.Internal.IO.Async.EAsync.ofETask | Std.Internal.Async.Basic | {ε α : Type} → Std.Internal.IO.Async.ETask ε α → Std.Internal.IO.Async.EAsync ε α |
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_10 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α] {it : Std.Iter α},
it.toList =
{
internalState :=
{ next := it.internalState.next, upperBound := Std.PRange.succ it.internalState.upperBound } }.toList |
Cardinal.mk_list_eq_max_mk_aleph0 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ (α : Type u) [Nonempty α], Cardinal.mk (List α) = max (Cardinal.mk α) Cardinal.aleph0 |
_private.Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong.0._auto_83 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax |
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') |
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) |
Part._sizeOf_inst | Mathlib.Data.Part | (α : Type u) → [SizeOf α] → SizeOf (Part α) |
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 (idealFactorsFunOfQuotHom f_surj) = OrderHom.id |
Lean.Elab.Structural.State | Lean.Elab.PreDefinition.Structural.Basic | Type |
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 |
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 k G} {B : Rep k H} (f : G →* H)
(φ : A ⟶ (Action.res (ModuleCat k) f).obj B) (i : ℕ),
ModuleCat.Hom.hom ((groupHomology.chainsMap f φ).f i) =
Finsupp.mapRange.linearMap (ModuleCat.Hom.hom φ.hom) ∘ₗ Finsupp.lmapDomain (↑A.V) k fun x => ⇑f ∘ x |
_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‖ |
HopfAlgCat.instMonoidalCategoryStruct._proof_1 | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X : HopfAlgCat R), IsScalarTower R R X.carrier |
Turing.ToPartrec.Cont.eval.eq_4 | Mathlib.Computability.TMConfig | ∀ (f : Turing.ToPartrec.Code) (k : Turing.ToPartrec.Cont),
(Turing.ToPartrec.Cont.comp f k).eval = fun v => f.eval v >>= k.eval |
Real.two_mul_cos_mul_cos | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), 2 * Real.cos x * Real.cos y = Real.cos (x - y) + Real.cos (x + y) |
Multiset.pairwise_zero._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (r : α → α → Prop), Multiset.Pairwise r 0 = True |
Module.Relations.Solution.IsPresentationCore | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} →
[inst : Ring A] →
{relations : Module.Relations A} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] → relations.Solution M → Type (max (max (max u v) (w' + 1)) w₀) |
continuous_multiset_sum | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid M] [ContinuousAdd M] {f : ι → X → M} (s : Multiset ι),
(∀ i ∈ s, Continuous (f i)) → Continuous fun a => (Multiset.map (fun i => f i a) s).sum |
CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono'_ι | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.RightHomologyData) [inst_2 : CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
(CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono' φ h).ι = h.ι |
MDifferentiableAt.sum_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : TopologicalSpace B]
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : (x : B) → TopologicalSpace (E x)]
[inst_3 : NormedAddCommGroup F] [inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : FiberBundle F E] [inst_7 : (x : B) → AddCommGroup (E x)] [inst_8 : (x : B) → Module 𝕜 (E x)]
[VectorBundle 𝕜 F E] {HB : Type u_7} [inst_10 : TopologicalSpace HB] [inst_11 : ChartedSpace HB B] {EB : Type u_8}
[inst_12 : NormedAddCommGroup EB] [inst_13 : NormedSpace 𝕜 EB] {I : ModelWithCorners 𝕜 EB HB} {ι : Type u_9}
{s : Finset ι} {t : ι → (x : B) → E x} {x₀ : B},
(∀ (i : ι), MDiffAt (T% t) x₀) → (MDiffAt fun x => ⟨x, ∑ i ∈ s, t i x⟩) x₀ |
ShowMessageRequestParams.noConfusion | Lean.Data.Lsp.Window | {P : Sort u} → {t t' : ShowMessageRequestParams} → t = t' → ShowMessageRequestParams.noConfusionType P t t' |
Lean.Lsp.instFromJsonDefinitionParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.DefinitionParams |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.bojanic_mahler_step1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoidWithOne M] [inst_1 : AddCommGroup G] (f : M → G) (n : ℕ) {R : ℕ},
1 ≤ R →
(fwdDiff 1)^[n + R] f 0 =
-∑ j ∈ Finset.range (R - 1), R.choose (j + 1) • (fwdDiff 1)^[n + (j + 1)] f 0 +
∑ k ∈ Finset.range (n + 1), ((-1) ^ (n - k) * ↑(n.choose k)) • (f (↑k + ↑R) - f ↑k) |
sameRay_neg_iff._simp_1 | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {x y : M}, SameRay R (-x) (-y) = SameRay R x y |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_390 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
ModuleCat.free_hom_ext | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ {R : Type u} [inst : Ring R] {X : Type u} {M : ModuleCat R} {f g : (ModuleCat.free R).obj X ⟶ M},
(∀ (x : X),
(CategoryTheory.ConcreteCategory.hom f) (ModuleCat.freeMk x) =
(CategoryTheory.ConcreteCategory.hom g) (ModuleCat.freeMk x)) →
f = g |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_8 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r : ℤ), autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_5 → r₀ ≤ r |
CategoryTheory.Under.mapId_eq | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (Y : T),
CategoryTheory.Under.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Under Y) |
Lean.Meta.Grind.Arith.CommRing.State.typeIdOf | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.State → Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ) |
Std.Net.SocketAddress.v6.inj | Std.Net.Addr | ∀ {addr addr_1 : Std.Net.SocketAddressV6},
Std.Net.SocketAddress.v6 addr = Std.Net.SocketAddress.v6 addr_1 → addr = addr_1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.