name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Functor.pointwiseRightKanExtensionCompIsoOfPreserves._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_2} {B : Type u_8} {C : Type u_6} {D : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} A]
[inst_1 : CategoryTheory.Category.{u_7, u_8} B] [inst_2 : CategoryTheory.Category.{u_5, u_6} C]
[inst_3 : CategoryTheory.Category.{u_3, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | null | false |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.inf_neBot_iff_frequently_left._simp_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {l l' : Filter α}, (l ⊓ l').NeBot = ∀ ⦃s : Set α⦄, s ∈ l → ∀ ⦃s' : Set α⦄, s' ∈ l' → (s ∩ s').Nonempty | null | false |
InformationTheory.continuous_klFun | Mathlib.InformationTheory.KullbackLeibler.KLFun | Continuous InformationTheory.klFun | `klFun` is continuous. | true |
UniformContinuous.exists_contDiff_dist_le | Mathlib.Analysis.Calculus.BumpFunction.SmoothApprox | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E]
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] [CompleteSpace F] {f : E → F} {ε : ℝ},
UniformContinuous f → 0 < ε → ∃ g, ContDiff ℝ (↑⊤) g ∧ ∀ (a : E), dist (g a) (f a) < ε | null | true |
CategoryTheory.MorphismProperty.HasLocalization.L | Mathlib.CategoryTheory.Localization.HasLocalization | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
[self : W.HasLocalization] → CategoryTheory.Functor C (CategoryTheory.MorphismProperty.HasLocalization.D W) | the localization functor. | true |
Polynomial.Chebyshev.chebyshevTsequence | Mathlib.RingTheory.Polynomial.Chebyshev | (R : Type u_1) → [inst : CommRing R] → [IsDomain R] → [NeZero 2] → Polynomial.Sequence R | **Alias** of `Polynomial.Chebyshev.chebyshevTSequence`.
---
ChebyshevT as a polynomial sequence. | true |
CompactIccSpace.mk'' | Mathlib.Topology.Order.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : PartialOrder α],
(∀ {a b : α}, a < b → IsCompact (Set.Icc a b)) → CompactIccSpace α | null | true |
BialgEquiv.ofAlgEquiv.congr_simp | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Bialgebra R A] [inst_4 : Bialgebra R B] (f f_1 : A ≃ₐ[R] B) (e_f : f = f_1)
(counit_comp : (Bialgebra.counitAlgHom R B).comp ↑f = Bialgebra.counitAlgHom R A)
(map_comp_comul :
(Algebra.Tensor... | null | true |
WittVector.frobeniusEquiv._proof_4 | Mathlib.RingTheory.WittVector.Frobenius | ∀ (p : ℕ) (R : Type u_1) [hp : Fact (Nat.Prime p)] [inst : CommRing R] [CharP R p], ExpChar R p | null | false |
sInfHom.dual | Mathlib.Order.Hom.CompleteLattice | {α : Type u_2} → {β : Type u_3} → [inst : InfSet α] → [inst_1 : InfSet β] → sInfHom α β ≃ sSupHom αᵒᵈ βᵒᵈ | Reinterpret an `⨅`-homomorphism as a `⨆`-homomorphism between the dual orders. | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr.0.Std.Tactic.BVDecide.BVExpr.bitblast.go.match_17.splitter | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) →
(w : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) →
((w a : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var a)) →
((w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val)) →
((w : ℕ) →
(lhsExpr : ... | null | true |
CategoryTheory.WithTerminal.opEquiv_unitIso_hom_app | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (X : (CategoryTheory.WithTerminal C)ᵒᵖ),
(CategoryTheory.WithTerminal.opEquiv C).unitIso.hom.app X =
(match Opposite.unop X with
| CategoryTheory.WithTerminal.of x => CategoryTheory.Iso.refl (Opposite.op (CategoryTheory.WithTerminal.of x))
| Cat... | null | true |
isOpen_univ._simp_1 | Mathlib.Topology.Defs.Basic | ∀ {X : Type u} [inst : TopologicalSpace X], IsOpen Set.univ = True | null | false |
CliffordAlgebra.instAlgebra._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | null | false |
MvPolynomial.prod_X_pow | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] (x : σ → ℕ) (t : Finset σ),
∏ y ∈ t, MvPolynomial.X y ^ x y = (MvPolynomial.monomial (Finsupp.indicator t fun i x_1 => x i)) 1 | null | true |
Fin.zero_le | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] (a : Fin n), 0 ≤ a | null | true |
CategoryTheory.Limits.coconeLeftOpOfConeEquiv | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J Cᵒᵖ} → (CategoryTheory.Limits.Cone F)ᵒᵖ ≌ CategoryTheory.Limits.Cocone F.leftOp | Cones on `F : J ⥤ Cᵒᵖ` are equivalent to cocones on `F.leftOp : Jᵒᵖ ⥤ C`. | true |
AddCommGrpCat.enoughInjectives | Mathlib.Algebra.Category.Grp.EnoughInjectives | CategoryTheory.EnoughInjectives AddCommGrpCat | null | true |
List.sortedGE_cons | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : LinearOrder α] {a : α}, (a :: l).SortedGE ↔ (∀ b ∈ l, b ≤ a) ∧ l.SortedGE | null | true |
Equiv.Perm.applyMulAction | Mathlib.Algebra.Group.Action.End | (α : Type u_5) → MulAction (Equiv.Perm α) α | The tautological action by `Equiv.Perm α` on `α`.
This generalizes `Function.End.applyMulAction`. | true |
SL2Simple.PSL_nontrivial | Mathlib.LinearAlgebra.Projectivization.PSL.PSL2 | ∀ {ι : Type u_1} {F : Type u_2} [inst : Field F] [inst_1 : DecidableEq ι] [inst_2 : Fintype ι] [Nontrivial ι],
Nontrivial (Matrix.ProjectiveSpecialLinearGroup ι F) | `PSL ι F` is nontrivial whenever `ι` has at least two elements (and `F` is a field,
hence in particular nontrivial). | true |
_private.Mathlib.Topology.Instances.CantorSet.0.ofDigits_zero_two_sequence_mem_cantorSet._simp_1_2 | Mathlib.Topology.Instances.CantorSet | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
OrdinalApprox.lfpApprox_mono_left | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Type u} [inst : CompleteLattice α], Monotone OrdinalApprox.lfpApprox | null | true |
MagmaCat.Hom.ext_iff | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {A B : MagmaCat} {x y : A.Hom B}, x = y ↔ x.hom' = y.hom' | null | true |
GromovHausdorff.eq_toGHSpace_iff | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ {X : Type u} [inst : MetricSpace X] [inst_1 : CompactSpace X] [inst_2 : Nonempty X]
{p : TopologicalSpace.NonemptyCompacts ↥(lp (fun n => ℝ) ⊤)},
⟦p⟧ = GromovHausdorff.toGHSpace X ↔ ∃ Ψ, Isometry Ψ ∧ Set.range Ψ = ↑p | null | true |
ChevalleyThm.MvPolynomialC.degBound_le_degBound | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {k₁ k₂ : ℕ} {D₁ D₂ : ℕ → ℕ},
k₁ ≤ k₂ →
∀ (n : ℕ),
(∀ i < n, D₁ i ≤ D₂ i) → ChevalleyThm.MvPolynomialC.degBound k₁ D₁ n ≤ ChevalleyThm.MvPolynomialC.degBound k₂ D₂ n | null | true |
Finsupp.sumFinsuppEquivProdFinsupp.eq_1 | Mathlib.RingTheory.Extension.Generators | ∀ {α : Type u_12} {β : Type u_13} {γ : Type u_14} [inst : Zero γ],
Finsupp.sumFinsuppEquivProdFinsupp =
{ toFun := fun f => (Finsupp.comapDomain Sum.inl f ⋯, Finsupp.comapDomain Sum.inr f ⋯),
invFun := fun fg => fg.1.sumElim fg.2, left_inv := ⋯, right_inv := ⋯ } | null | true |
Lean.Grind.NoopConfig.lia._default | Init.Grind.Config | Bool | null | false |
SetRel.isCover_id._simp_1 | Mathlib.Basic.Rel.Cover | ∀ {X : Type u_1} {s N : Set X}, SetRel.id.IsCover s N = (s ⊆ N) | null | false |
_private.Mathlib.SetTheory.ZFC.VonNeumann.0.ZFSet.mem_vonNeumann._simp_1_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {o : Ordinal.{u}} {x : ZFSet.{u}}, (x ∈ ZFSet.vonNeumann o) = ∃ a < o, x ⊆ ZFSet.vonNeumann a | null | false |
CategoryTheory.Adjunction.ofCat_unit | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {C D : CategoryTheory.Cat} {F : C ⟶ D} {G : D ⟶ C} (adj : CategoryTheory.Bicategory.Adjunction F G),
(CategoryTheory.Adjunction.ofCat adj).unit = adj.unit.toNatTrans | null | true |
SimpleGraph.cliqueNum | Mathlib.Combinatorics.SimpleGraph.Clique | {α : Type u_3} → SimpleGraph α → ℕ | The maximum number of vertices in a clique of a graph `G`. | true |
Lean.Meta.Sym.DSimp.Config.maxSteps | Lean.Meta.Sym.DSimp.DSimpM | Lean.Meta.Sym.DSimp.Config → ℕ | Maximum number of steps that can be performed by the simplifier. | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Log.0.Complex.exp_eq_exp_iff_exists_int._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {G : Type u_3} [inst : AddCommGroup G] {a b c : G}, (a - b = c) = (a = b + c) | null | false |
Lean.Grind.Linarith.Poly.denoteN_mul' | Init.Grind.Module.NatModuleNorm | ∀ {α : Type u_1} [inst : Lean.Grind.NatModule α] (ctx : Lean.Grind.Linarith.Context α) (p : Lean.Grind.Linarith.Poly)
(k : ℕ),
p.NonnegCoeffs → Lean.Grind.Linarith.Poly.denoteN ctx (p.mul' ↑k) = k • Lean.Grind.Linarith.Poly.denoteN ctx p | null | true |
ModuleCat.adj._proof_3 | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ (R : Type u_1) [inst : Ring R] {X : Type u_1} {Y Y' : ModuleCat R} (f : (ModuleCat.free R).obj X ⟶ Y) (g : Y ⟶ Y'),
ModuleCat.freeHomEquiv (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (ModuleCat.freeHomEquiv f) ((CategoryTheory.forget (ModuleCat R)).map g) | null | false |
_private.Mathlib.Topology.MetricSpace.Antilipschitz.0.antilipschitzWith_iff_le_mul_dist._simp_1_1 | Mathlib.Topology.MetricSpace.Antilipschitz | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
AntilipschitzWith K f = ∀ (x y : α), nndist x y ≤ K * nndist (f x) (f y) | null | false |
Prod.instCompleteAtomicBooleanAlgebra | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u} →
{β : Type v} →
[CompleteAtomicBooleanAlgebra α] → [CompleteAtomicBooleanAlgebra β] → CompleteAtomicBooleanAlgebra (α × β) | null | true |
Set.Finite.ecard_strictMonoOn | Mathlib.SetTheory.Cardinal.NatCard | ∀ {α : Type u_1}, StrictMonoOn (ENat.card ∘ Set.Elem) (Set.ofPred Set.Finite) | null | true |
CategoryTheory.Over.sections._proof_2 | Mathlib.CategoryTheory.LocallyCartesianClosed.Sections | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(I : C) [inst_2 : CategoryTheory.Closed I] {X Y : CategoryTheory.Over I} (u : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.ihom I).map X.hom) (CategoryTheory.CategoryStruct.id (I ⟹ I))... | null | false |
SSet.horn₃₂.desc | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | {X : SSet} →
(f₀ f₁ f₃ : SSet.stdSimplex.obj { len := 2 } ⟶ X) →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₁ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 1) f₃ →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₀ =
CategoryTheory.CategoryStruct.comp (SSe... | The morphism `Λ[3, 2] ⟶ X` which is obtained by gluing three
morphisms `Δ[2] ⟶ X`. | true |
OrdinalApprox.exists_lfpApprox_eq_lfpApprox | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) (x : α),
∃ a < (Order.succ (Cardinal.mk α)).ord,
∃ b < (Order.succ (Cardinal.mk α)).ord, a ≠ b ∧ OrdinalApprox.lfpApprox f x a = OrdinalApprox.lfpApprox f x b | There are distinct indices smaller than the successor of the domain's cardinality
yielding the same value | true |
GroupFilterBasis.rec | Mathlib.Topology.Algebra.FilterBasis | {G : Type u} →
[inst : Group G] →
{motive : GroupFilterBasis G → Sort u_1} →
((toFilterBasis : FilterBasis G) →
(one' : ∀ {U : Set G}, U ∈ toFilterBasis.sets → 1 ∈ U) →
(mul' : ∀ {U : Set G}, U ∈ toFilterBasis.sets → ∃ V ∈ toFilterBasis.sets, V * V ⊆ U) →
(inv' : ∀ {U : S... | null | false |
Std.LawfulEqCmp.recOn | Init.Data.Order.Ord | {α : Type u} →
{cmp : α → α → Ordering} →
{motive : Std.LawfulEqCmp cmp → Sort u_1} →
(t : Std.LawfulEqCmp cmp) →
([toReflCmp : Std.ReflCmp cmp] → (eq_of_compare : ∀ {a b : α}, cmp a b = Ordering.eq → a = b) → motive ⋯) →
motive t | null | false |
PositiveContinuousLinearMap.map_smul_of_tower | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] [inst_7 : TopologicalSpace E₁] [inst_8 : TopologicalSpace E₂] {S : Type u_6}
[inst_9 : SM... | null | true |
_private.Mathlib.Tactic.Matrix.ListMatrix.0.Mathlib.Tactic.Matrix.ListMatrix.getD_transpose._proof_1_4 | Mathlib.Tactic.Matrix.ListMatrix | ∀ {α : Type u_1} [inst : Zero α] {n j : ℕ} (row : List α) (tl : List (List α)),
(∀ (i : ℕ), j < (Mathlib.Tactic.Matrix.ListMatrix.transpose n (row :: tl)).length) →
j < (List.rightpad n 0 row).length | null | false |
TensorAlgebra.toDirectSum.eq_1 | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
TensorAlgebra.toDirectSum =
(TensorAlgebra.lift R)
(DirectSum.lof R ℕ (fun n => TensorPower R n M) 1 ∘ₗ ↑(PiTensorProduct.subsingletonEquiv 0).symm) | null | true |
CategoryTheory.Pretriangulated.rotateRotateRotateIso._proof_3 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Pretriangulated.rotate C).comp
((CategoryTheory.Pret... | null | false |
Std.HashMap.Raw.getKey | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [inst : BEq α] → [inst_1 : Hashable α] → (m : Std.HashMap.Raw α β) → (a : α) → a ∈ m → α | Retrieves the key from the mapping that matches `a`. Ensures that such a mapping exists by
requiring a proof of `a ∈ m`. The result is guaranteed to be pointer equal to the key in the map.
| true |
CategoryTheory.Limits.isColimitSigmaConstCokernelCofork._proof_4 | Mathlib.CategoryTheory.Limits.Preserves.SigmaConst | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(R : C) {α : Type u_3} {β : Type u_4} (f : α → β) [inst_2 : CategoryTheory.Limits.HasCoproduct fun x => R]
[inst_3 : CategoryTheory.Limits.HasCoproduct fun x => R] [inst_4 : CategoryTheory.Limits.HasCo... | null | false |
Std.DTreeMap.Internal.Impl.mem_keys | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.LawfulEqOrd α]
[Std.TransOrd α] {k : α}, t.WF → (k ∈ t.keys ↔ k ∈ t) | null | true |
Turing.TM1to0.trAux.eq_3 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (M : Λ → Turing.TM1.Stmt Γ Λ σ) (s : Γ) (x : σ) (a : Γ → σ → σ)
(q : Turing.TM1.Stmt Γ Λ σ), Turing.TM1to0.trAux M s (Turing.TM1.Stmt.load a q) x = Turing.TM1to0.trAux M s q (a s x) | null | true |
ContinuousMap.isometryEquivBoundedOfCompact._proof_1 | Mathlib.Topology.ContinuousMap.Compact | ∀ (α : Type u_1) (β : Type u_2) [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : PseudoMetricSpace β]
(x x_1 : C(α, β)),
edist ((ContinuousMap.equivBoundedOfCompact α β).toFun x) ((ContinuousMap.equivBoundedOfCompact α β).toFun x_1) =
edist ((ContinuousMap.equivBoundedOfCompact α β).toFun x) ((Co... | null | false |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Tactic.sepBy1IndentSemicolon._regBuiltin.Lean.Parser.Tactic.sepBy1IndentSemicolon.docString_1 | Lean.Parser.Term.Basic | IO Unit | null | false |
CategoryTheory.GrothendieckTopology.over_forget_coverPreserving | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (X : C),
CategoryTheory.CoverPreserving (J.over X) J (CategoryTheory.Over.forget X) | null | true |
StarAlgHom.noConfusionType | Mathlib.Algebra.Star.StarAlgHom | Sort u →
{R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
[inst_3 : Star A] →
[inst_4 : Semiring B] →
[inst_5 : Algebra R B] →
[inst_... | null | false |
CategoryTheory.evaluationAdjunctionRight._proof_6 | Mathlib.CategoryTheory.Adjunction.Evaluation | ∀ {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]
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasCoproductsOfShape (a ⟶ b) D] (c : C) {X' X : D}
{Y : CategoryTheory.Functor C D} (f : X' ⟶ X) (g : X ⟶ ((CategoryTheory.evaluation C D).obj ... | null | false |
CliffordAlgebra.equivOfIsometry_symm | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M₁ : Type u_4} {M₂ : Type u_5} [inst_1 : AddCommGroup M₁]
[inst_2 : AddCommGroup M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {Q₁ : QuadraticForm R M₁}
{Q₂ : QuadraticForm R M₂} (e : QuadraticMap.IsometryEquiv Q₁ Q₂),
(CliffordAlgebra.equivOfIsometry e).symm = CliffordAl... | null | true |
CategoryTheory.Cat.typeToCatObjectsAdj | Mathlib.CategoryTheory.Category.Cat.Adjunction | CategoryTheory.typeToCat ⊣ CategoryTheory.Cat.objects | `typeToCat : Type ⥤ Cat` is left adjoint to `Cat.objects : Cat ⥤ Type` | true |
Subfield.relrank_comap_comap_eq_relrank_of_surjective | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B : Subfield E) {L : Type v} [inst_1 : Field L] (f : L →+* E),
Function.Surjective ⇑f → (Subfield.comap f A).relrank (Subfield.comap f B) = A.relrank B | null | true |
Asymptotics.isBigOWith_top._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {c : ℝ} {f : α → E} {g : α → F},
Asymptotics.IsBigOWith c ⊤ f g = ∀ (x : α), ‖f x‖ ≤ c * ‖g x‖ | null | false |
FreeLieAlgebra.Rel.subLeft | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] (a : FreeNonUnitalNonAssocAlgebra R X)
{b c : FreeNonUnitalNonAssocAlgebra R X}, FreeLieAlgebra.Rel R X b c → FreeLieAlgebra.Rel R X (a - b) (a - c) | null | true |
DFinsupp.lapply._proof_2 | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {M : ι → Type u_2} [inst : Semiring R] [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] (i : ι) (c : R) (f : Π₀ (i : ι), M i), (c • f) i = c • f i | null | false |
AlgebraicGeometry.ProjectiveSpectrum.Proj.specStalkEquiv._proof_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (f : A) (x : ↥(ProjectiveSpectrum.basicOpen 𝒜 f)), (↑x).asHomogeneousIdeal.toIdeal.IsPrime | null | false |
SimpleGraph.UnitDistEmbedding.copy._proof_1 | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | ∀ {V : Type u_3} {W : Type u_1} {G : SimpleGraph V} {H : SimpleGraph W} {E : Type u_2} [inst : MetricSpace E]
(U : G.UnitDistEmbedding E) (f : H.Copy G) {u v : W},
H.Adj u v → dist (U.p (f.toEmbedding u)) (U.p (f.toEmbedding v)) = 1 | null | false |
Mathlib.Tactic.Ring.Common.ExProd.rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
{motive_1 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExBase BaseType sα e → Sort u} →
{motive_2 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExProd BaseType sα e → Sort u} →
{moti... | null | false |
InnerProductSpace.isSymmetric_rankOne_self._simp_1 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x : E), (↑(((InnerProductSpace.rankOne 𝕜) x) x)).IsSymmetric = True | null | false |
Finset.sym.match_1 | Mathlib.Data.Finset.Sym | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
Polynomial.natDegree_mul_le | Mathlib.Algebra.Polynomial.Degree.Defs | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, (p * q).natDegree ≤ p.natDegree + q.natDegree | null | true |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_none_iff._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, (xs = #[]) = (xs.size = 0) | null | false |
CategoryTheory.Functor.pointwiseRightKanExtensionIsPointwiseRightKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} H] →
(L : CategoryTheory.Functor C D) →
(F : CategoryTheory.Functor C ... | The functor `pointwiseRightKanExtension L F` is a pointwise right Kan
extension of `F` along `L`. | true |
CategoryTheory.CostructuredArrow.isoMk | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{T : D} →
{S : CategoryTheory.Functor C D} →
{f f' : CategoryTheory.CostructuredArrow S T} →
(g : f.left ≅ f'.left) →
auto... | To construct an isomorphism of costructured arrows,
we need an isomorphism of the objects underlying the source,
and to check that the triangle commutes.
| true |
ofBoolAlg_bot | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α], ofBoolAlg ⊥ = 0 | null | true |
OpenPartialHomeomorph.EqOnSource.symm_eqOn_target | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e e' : OpenPartialHomeomorph X Y}, e ≈ e' → Set.EqOn (↑e.symm) (↑e'.symm) e.target | Two equivalent open partial homeomorphisms have coinciding `invFun` on the target | true |
List.inits._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → List α → List (List α) | null | false |
CategoryTheory.Limits.CategoricalPullback.instIsIsoFst | 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)
{x y : CategoryTheory.Limits.CategoricalPullback F G} (f : x ⟶ y) [C... | null | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.mod_two_pow_shiftLeft_mod_two_pow._proof_1_2 | Init.Data.Nat.Bitwise.Lemmas | ∀ {b c : ℕ}, ∀ i < c, ¬i - b < c → False | null | false |
bddBelow_empty._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], BddBelow ∅ = True | null | false |
RingHom.toOpposite_apply | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S)
(hf : ∀ (x y : R), Commute (f x) (f y)), ⇑(f.toOpposite hf) = MulOpposite.op ∘ ⇑f | null | true |
WType.ofList.eq_def | Mathlib.Data.W.Constructions | ∀ (γ : Type u) (x : List γ),
WType.ofList γ x =
match x with
| [] => WType.mk WType.Listα.nil PEmpty.elim
| hd :: tl => WType.mk (WType.Listα.cons hd) fun x => WType.ofList γ tl | null | true |
_private.Init.Data.List.Nat.TakeDrop.0.List.lt_length_right_of_zipWith._proof_1_1 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {β : Type u_2} {i : ℕ} {l : List α} {l' : List β}, i < min l.length l'.length → ¬i < l'.length → False | null | false |
Filter.TendstoCofinite.mapDomain | Mathlib.Order.Filter.TendstoCofinite | {α : Type u_1} →
{β : Type u_2} → {M : Type u_5} → (f : α → β) → [AddCommMonoid M] → [Filter.TendstoCofinite f] → (α → M) → β → M | Given `f : α → β` with `Filter.TendstoCofinite f` and `v : α → M`,
`Filter.TendstoCofinite.mapDomain f v : β → M` is the function whose value at `b : β` is
the sum of `v x` over all `x` such that `f x = b`. | true |
Array.toList_mapIdxM | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array α}
{f : ℕ → α → m β}, Array.toList <$> Array.mapIdxM f xs = List.mapIdxM f xs.toList | null | true |
CategoryTheory.FreeMonoidalCategory.normalizeObj_unitor | Mathlib.CategoryTheory.Monoidal.Free.Coherence | ∀ {C : Type u} (n : CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C),
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.FreeMonoidalCategory C)).normalizeObj n = n | null | true |
MeasureTheory.UniformIntegrable.spec | Mathlib.MeasureTheory.Function.UniformIntegrable | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup β] {p : ENNReal} {f : ι → α → β},
p ≠ 0 →
p ≠ ⊤ →
MeasureTheory.UniformIntegrable f p μ →
∀ {ε : ENNReal}, 0 < ε → ∃ C, ∀ (i : ι), MeasureTheory.eLpNorm ({x | C ≤ ‖f i x‖... | null | true |
Finset.mulETransformRight_snd | Mathlib.Combinatorics.Additive.ETransform | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Group α] (e : α) (x : Finset α × Finset α),
(Finset.mulETransformRight e x).2 = x.2 ∩ e⁻¹ • x.2 | null | true |
_private.Mathlib.Data.List.Sort.0.List.orderedInsert_erase._proof_1_3 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] [inst_1 : DecidableEq α] [Std.Antisymm r] (x head : α)
(tail : List α),
(x ∈ tail → List.Pairwise r tail → List.orderedInsert r x (tail.erase x) = tail) →
x ∈ head :: tail → List.Pairwise r (head :: tail) → List.orderedInsert r x ((head :: tail).erase ... | null | false |
AlgebraicGeometry.LocallyRingedSpace.toΓSpecSheafedSpace_app_eq | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) (r : ↑(AlgebraicGeometry.LocallyRingedSpace.Γ.obj (Opposite.op X))),
X.toΓSpecSheafedSpace.hom.c.app (Opposite.op (PrimeSpectrum.basicOpen r)) = X.toΓSpecCApp r | null | true |
TwoP.concreteCategory._proof_5 | Mathlib.CategoryTheory.Category.TwoP | autoParam
(∀ {X Y : TwoP} (f : X.toBipointed.HomSubtype Y.toBipointed),
TwoP.concreteCategory._aux_1 (TwoP.concreteCategory._aux_3 f) = f)
CategoryTheory.ConcreteCategory.hom_ofHom._autoParam | null | false |
ContinuousLinearMap.opNorm_comp_le | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_5} {G : Type u_7}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜... | The operator norm is submultiplicative. | true |
_private.Mathlib.RingTheory.WittVector.Defs.0.term𝕎 | Mathlib.RingTheory.WittVector.Defs | Lean.ParserDescr | null | true |
Std.ExtTreeSet.isEmpty_inter_comm | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp],
(t₁ ∩ t₂).isEmpty = (t₂ ∩ t₁).isEmpty | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Presentable.0.SSet.Finite.exists_epi_from_isCardinalPresentable._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.Presentable | ∀ (X : SSet), ⊤ = ⨆ s, s.subcomplex | null | false |
ValuativeRel.instLinearOrderValueGroupWithZero._proof_2 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] (a b : ValuativeRel.ValueGroupWithZero R),
a ≤ b ∧ ¬b ≤ a ↔ a ≤ b ∧ ¬b ≤ a | null | false |
Matrix.conjTransposeAlgEquiv_symm_apply | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ (n : Type u_3) {R : Type u_5} (α : Type v) [inst : Fintype n] [inst_1 : CommSemiring R] [inst_2 : StarRing R]
[inst_3 : TrivialStar R] [inst_4 : Semiring α] [inst_5 : StarRing α] [inst_6 : Algebra R α] [inst_7 : StarModule R α]
(a : (Matrix n n α)ᵐᵒᵖ), (Matrix.conjTransposeAlgEquiv n α).symm a = (MulOpposite.unop... | null | true |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.braiding._proof_5 | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X₁ X₂ : CategoryTheory.Arrow C),
CategoryTheory.CategoryStruct.comp (β_ X₁.left X₂.left).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X₂.left X₁.ho... | null | false |
Lean.Macro.withIncRecDepth | Init.Prelude | {α : Type} → Lean.Syntax → Lean.MacroM α → Lean.MacroM α | Run `x` with an incremented recursion depth counter. | true |
LieIdeal.incl_isIdealMorphism | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
I.incl.IsIdealMorphism | null | true |
Std.Async.ETask | Std.Async.Basic | Type → Type → Type | A `Task` that may resolve to either a value of type `α` or an error value of type `ε`.
| true |
Lean.Meta.Grind.EMatch.Context.thm._default | Lean.Meta.Tactic.Grind.EMatch | Lean.Meta.Grind.EMatchTheorem | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.