name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Ordinal.natCast_log._simp_1 | Mathlib.SetTheory.Ordinal.Exponential | ∀ (m n : ℕ), Ordinal.log ↑m ↑n = ↑(Nat.log m n) | null | false |
CommGrpTypeEquivalenceCommGrp.inverse_obj_inv | Mathlib.CategoryTheory.Monoidal.Internal.Types.CommGrp_ | ∀ {A : CommGrpCat} {x : (fun X => X) (CommGrpTypeEquivalenceCommGrp.inverse.obj A).X},
(CategoryTheory.ConcreteCategory.hom CategoryTheory.GrpObj.inv) x = x⁻¹ | null | true |
UInt64.lt_of_le_of_ne | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a ≤ b → a ≠ b → a < b | null | true |
CategoryTheory.NatTrans.unop_whiskerLeft_assoc._to_dual_1 | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} {E : Type u_1} [inst_2 : CategoryTheory.Category.{v_1, u_1} E]
{H : CategoryTheory.Functor Eᵒᵖ Cᵒᵖ} (α : G ⟶ F) {Z : CategoryTheory.Functor E D} (h : Z ⟶ (H.... | null | false |
SimpleGraph.cliqueFree_two | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α}, G.CliqueFree 2 ↔ G = ⊥ | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal.0.SSet.Truncated.StrictSegal.spineToSimplex_map._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {n : ℕ}, ∀ m ≤ n, m + 1 ≤ n + 1 | null | false |
PartOrd.Iso.mk._proof_1 | Mathlib.Order.Category.PartOrd | ∀ {α β : PartOrd},
RelHomClass ((fun x1 x2 => x1 ≤ x2) ≃r fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 | null | false |
isLinearSet_iff | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsLinearSet s ↔ ∃ a t, s = a +ᵥ ↑(AddSubmonoid.closure ↑t) | An equivalent expression of `IsLinearSet` in terms of `Finset` instead of `Set.Finite`. | true |
Mathlib.Tactic.Matrix.MulEq.recOn | Mathlib.Tactic.Matrix.MulExpand | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{aα : Q(Add «$α»)} →
{mα : Q(Mul «$α»)} →
{l m n : ℕ} →
{motive : Mathlib.Tactic.Matrix.MulEq zα aα mα l m n → Sort u} →
(t : Mathlib.Tactic.Matrix.MulEq zα aα mα l m n) →
((A B : Q(List (L... | null | false |
Array.findSome?_eq_none_iff | Init.Data.Array.Find | ∀ {α : Type u_1} {α_1 : Type u_2} {p : α → Option α_1} {xs : Array α},
Array.findSome? p xs = none ↔ ∀ x ∈ xs, p x = none | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPolyC.go.match_4.eq_8 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a b : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (L... | null | true |
AlgebraicGeometry.instBraidedCategoryScheme | Mathlib.AlgebraicGeometry.Limits | CategoryTheory.BraidedCategory AlgebraicGeometry.Scheme | null | true |
hasFTaylorSeriesUpToOn_pi' | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_3} [inst_3 : Fintype ι] {F' : ι → Type u_5}
[inst_4 : (i : ι) → NormedAddCommGroup (F' i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i}
{P'... | null | true |
PresheafOfModulesOfCommRing.Monoidal.tensorHom._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Monoidal | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {R : CategoryTheory.Functor Cᵒᵖ CommRingCat}
{M₁ M₂ M₃ M₄ : PresheafOfModulesOfCommRing R} (f : M₁ ⟶ M₂) (g : M₃ ⟶ M₄) {X Y : Cᵒᵖ} (φ : X ⟶ Y) (m₁ : ↑(M₁.obj X))
(m₃ : ↑(M₃.obj X)),
(ModuleCat.Hom.hom
(CategoryTheory.CategoryStruct.comp ((Pres... | null | false |
Vector.instSub | Init.Data.Vector.Algebra | {α : Type u_1} → {n : ℕ} → [Sub α] → Sub (Vector α n) | null | true |
dimH.eq_1 | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {X : Type u_2} [inst : EMetricSpace X] (s : Set X),
dimH s = ⨆ d, ⨆ (_ : (MeasureTheory.Measure.hausdorffMeasure ↑d) s = ⊤), ↑d | null | true |
Std.Tactic.BVDecide.BVLogicalExpr.bitblast.go.eq_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Substructure | ∀ (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (cache : Std.Tactic.BVDecide.BVExpr.Cache aig)
(g : Std.Tactic.BVDecide.Gate) (lhs rhs : Std.Tactic.BVDecide.BoolExpr Std.Tactic.BVDecide.BVPred),
Std.Tactic.BVDecide.BVLogicalExpr.bitblast.go aig (Std.Tactic.BVDecide.BoolExpr.gate g lhs rhs) cache =
match Std.Tac... | null | true |
Polynomial.abs_div_tendsto_atTop_atTop_of_degree_gt | Mathlib.Analysis.Polynomial.Basic | ∀ {𝕜 : Type u_1} [inst : NormedField 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (P Q : Polynomial 𝕜)
[OrderTopology 𝕜],
Q.degree < P.degree →
Q ≠ 0 → Filter.Tendsto (fun x => |Polynomial.eval x P / Polynomial.eval x Q|) Filter.atTop Filter.atTop | null | true |
Profinite.NobelingProof.GoodProducts.SumEval.eq_1 | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}}
(ho : o < Ordinal.type fun x1 x2 => x1 < x2),
Profinite.NobelingProof.GoodProducts.SumEval C ho =
Sum.elim (fun l => Profinite.NobelingProof.Products.eval C ↑l) fun l => Profinite.NobelingProof.Products.eval ... | null | true |
OneMemClass.coe_one | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {A : Type u_3} {M₁ : Type u_4} [inst : SetLike A M₁] [inst_1 : One M₁] [hA : OneMemClass A M₁] (S' : A), ↑1 = 1 | null | true |
Std.DTreeMap.Internal.Impl.balanced_rotateR | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (ls : ℕ) (lk : α) (lv : β lk)
(ll lr r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
r.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond ls r.size ∨
Std.DTreeMap.Internal.Impl.BalanceLEra... | null | true |
Subarray.take | Init.Data.Array.Subarray.Split | {α : Type u_1} → Subarray α → ℕ → Subarray α | Keeps only the first `i` elements of the subarray. If there are `i` or fewer elements, the resulting
subarray is empty.
| true |
CochainComplex.mappingCone.descShortComplex._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex (CochainComplex C ℤ)), HomologicalComplex.HasHomotopyCofiber S.f | null | false |
rank_fin_fun | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {R : Type u} [inst : Semiring R] [StrongRankCondition R] (n : ℕ), Module.rank R (Fin n → R) = ↑n | null | true |
CategoryTheory.Pretriangulated.Opposite.instHasShiftOppositeInt._proof_7 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ],
autoParam
(∀ {X Y : CategoryTheory.Discrete ℤ} (f : X ⟶ Y) (X' : CategoryTheory.Discrete ℤ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
((C... | null | false |
HomotopicalAlgebra.trivialFibrations_eq_unop | Mathlib.AlgebraicTopology.ModelCategory.CategoryWithCofibrations | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithFibrations C],
HomotopicalAlgebra.trivialFibrations C = (HomotopicalAlgebra.trivialCofibrations Cᵒᵖ).unop | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.exists_ne_and_degree_eq_one._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V} (u v : V) (p : G.Walk u v),
(∀ (u' v' : V) (p' : G.Walk u' v'), p'.IsPath → p'.length ≤ p.length) →
∀ (w : V) (hadj : (fun w => G.Adj v w) w), ¬(p.concat hadj).IsPath | null | false |
CochainComplex.HomComplex.Cochain.comp_assoc._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {n₁ n₂ n₃ n₂₃ n₁₂₃ : ℤ}, n₂ + n₃ = n₂₃ → n₁ + n₂ + n₃ = n₁₂₃ → n₁ + n₂₃ = n₁₂₃ | null | false |
Polynomial.toFinsuppIsoLinear_apply | Mathlib.Algebra.Polynomial.Basic | ∀ (R : Type u) [inst : Semiring R] (a : Polynomial R), (Polynomial.toFinsuppIsoLinear R) a = a.toFinsupp | null | true |
neg_one_lt_zero | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Ring R] [inst_1 : LinearOrder R] [ZeroLEOneClass R] [NeZero 1] [AddLeftStrictMono R], -1 < 0 | null | true |
CategoryTheory.MonObj.instIsMonHomHomRightUnitor | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X : C} [inst_3 : CategoryTheory.MonObj X],
CategoryTheory.IsMonHom (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom | null | true |
CategoryTheory.Abelian.instAdditiveOppositeFunctorAddCommGrpCatExtFunctor | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] (n : ℕ), (CategoryTheory.Abelian.extFunctor n).Additive | null | true |
TopRep.d_succ | Mathlib.RepresentationTheory.Homological.ContCohomology.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Ring k] [inst_1 : Group G] [inst_2 : TopologicalSpace k]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (X : TopRep k G) (n : ℕ),
X.d (n + 1) = TopRep.ofHom (X.resolutionX (n + 1)).ρ.coind₁ι - (TopRep.coind₁Functor k G).map (X.d n) | null | true |
_private.Mathlib.Algebra.Module.Presentation.Basic.0.Module.Relations.Solution.ext.match_1 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u_4} {inst : Ring A} {relations : Module.Relations A} {M : Type u_3} {inst_1 : AddCommGroup M}
{inst_2 : Module A M} (motive : relations.Solution M → Prop) (h : relations.Solution M),
(∀ (var : relations.G → M)
(linearCombination_var_relation :
∀ (r : relations.R), (Finsupp.linearCombinati... | null | false |
TypeVec.append1.match_1.congr_eq_1 | Mathlib.Control.Functor.Multivariate | ∀ {n : ℕ} (motive : Fin2 (n + 1) → Sort u_1) (x : Fin2 (n + 1)) (h_1 : (i : Fin2 n) → motive i.fs)
(h_2 : Unit → motive Fin2.fz) (i : Fin2 n),
x = i.fs →
(match x with
| i.fs => h_1 i
| Fin2.fz => h_2 ()) ≍
h_1 i | null | true |
CategoryTheory.ShortComplex.RightHomologyData.ofAbelian_H | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C),
(CategoryTheory.ShortComplex.RightHomologyData.ofAbelian S).H =
CategoryTheory.Abelian.image
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι S.g) (CategoryT... | null | true |
Sum.elim_single_zero | Mathlib.Algebra.Group.Pi.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq β] [inst_2 : Zero γ] (i : α)
(c : γ), Sum.elim (Pi.single i c) 0 = Pi.single (Sum.inl i) c | null | true |
Valuation.valuationSubring_eq_top_iff._simp_1 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] {Γ : Type u_1} [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation K Γ),
(v.valuationSubring = ⊤) = ¬v.IsNontrivial | null | false |
instMulFloat | Init.Data.Float.Float | Mul Float | null | true |
Lean.IR.Expr.lit.sizeOf_spec | Lean.Compiler.IR.Basic | ∀ (v : Lean.IR.LitVal), sizeOf (Lean.IR.Expr.lit v) = 1 + sizeOf v | null | true |
Lean.Lsp.WorkspaceClientCapabilities | Lean.Data.Lsp.Capabilities | Type | null | true |
Lean.Syntax.setHeadInfoAux._unsafe_rec | Init.Meta.Defs | Lean.SourceInfo → Lean.Syntax → Option Lean.Syntax | null | false |
neg_eq_of_add_eq_zero_right | Mathlib.Algebra.Group.DivInvMonoid | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a b : G}, a + b = 0 → -a = b | null | true |
MeasureTheory.memLp_stoppedProcess_of_mem_finset | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Nonempty ι] {μ : MeasureTheory.Measure Ω}
{τ : Ω → WithTop ι} {E : Type u_4} {p : ENNReal} {u : ι → Ω → E} [inst_1 : LinearOrder ι]
[inst_2 : TopologicalSpace ι] [OrderTopology ι] [FirstCountableTopology ι] {ℱ : MeasureTheory.Filtration ι m}
[inst_5 ... | null | true |
NumberField.AdeleRing.algebraMap_injective | Mathlib.NumberTheory.NumberField.AdeleRing | ∀ (R : Type u_1) (K : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] [NumberField K],
Function.Injective ⇑(algebraMap K (NumberField.AdeleRing R K)) | null | true |
Lean.Compiler.LCNF.Cases.getCtorNames | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Cases pu → Lean.NameSet | Return the constructor names that have an explicit (non-default) alternative.
| true |
Submonoid.LocalizationMap.ofMulEquivOfDom_id | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N), f.ofMulEquivOfDom ⋯ = f | A special case of `f ∘ id = f`, `f` a Localization map. | true |
Subgroup.coe_toAddSubgroup_symm_apply | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (S : AddSubgroup (Additive G)),
↑((RelIso.symm Subgroup.toAddSubgroup) S) = ⇑Multiplicative.toAdd ⁻¹' ↑S | null | true |
Std.Http.Internal.ChunkedBuffer.rec | Std.Http.Internal.ChunkedBuffer | {motive : Std.Http.Internal.ChunkedBuffer → Sort u} →
((data : Array ByteArray) → (size : ℕ) → motive { data := data, size := size }) →
(t : Std.Http.Internal.ChunkedBuffer) → motive t | null | false |
PMF.ofMultiset_apply_of_notMem | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {s : Multiset α} {a : α},
a ∉ s → (MeasureTheory.Measure.ofMultiset s) {a} = 0 | **Alias** of `MeasureTheory.Measure.ofMultiset_apply_singleton_of_notMem`. | true |
_private.Mathlib.Topology.Semicontinuity.Basic.0.LowerSemicontinuousWithinAt.add'._simp_1_1 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
polynomialFunctions.starClosure_eq_adjoin_X | Mathlib.Topology.ContinuousMap.Polynomial | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : TopologicalSpace R] [inst_2 : IsTopologicalSemiring R]
[inst_3 : StarRing R] [inst_4 : ContinuousStar R] (s : Set R),
(polynomialFunctions s).starClosure = StarAlgebra.adjoin R {(Polynomial.toContinuousMapOnAlgHom s) Polynomial.X} | null | true |
affineHomeomorph_image_Ioc | Mathlib.Topology.Algebra.Field | ∀ {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[inst_4 : IsTopologicalRing 𝕜] (a b c d : 𝕜) (h : 0 < a),
⇑(affineHomeomorph a b ⋯) '' Set.Ioc c d = Set.Ioc (a * c + b) (a * d + b) | null | true |
Set.initialSegIic._proof_5 | Mathlib.Order.Interval.Set.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] (j : α) (x : ↑(Set.Iic j)),
∀ k < { toFun := fun j_1 => ↑j_1, inj' := ⋯, map_rel_iff' := ⋯ } x,
k ∈ Set.range ⇑{ toFun := fun j_1 => ↑j_1, inj' := ⋯, map_rel_iff' := ⋯ } | null | false |
Std.DTreeMap.Internal.Impl.getKeyD_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF → ∀ {km fallback : α}, t.minKey? = some km → t.getKeyD km fallback = km | null | true |
Int.emod_eq_add_self_emod | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, a % b = (a + b) % b | null | true |
Lean.Elab.WF.GuessLex.MutualMeasure.args.inj | Lean.Elab.PreDefinition.WF.GuessLex | ∀ {a a_1 : Array ℕ}, Lean.Elab.WF.GuessLex.MutualMeasure.args a = Lean.Elab.WF.GuessLex.MutualMeasure.args a_1 → a = a_1 | null | true |
EMetricSpace.ofRiemannianMetric | Mathlib.Geometry.Manifold.Riemannian.Basic | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
{H : Type u_2} →
[inst_2 : TopologicalSpace H] →
(I : ModelWithCorners ℝ E H) →
(M : Type u_3) →
[inst_3 : TopologicalSpace M] →
[inst_4 : ChartedSpace H M] →
... | The emetric space structure associated to a Riemannian metric on a manifold. Designed
so that the topology is defeq to the original one.
This should only be used when constructing data in specific situations. To develop the theory,
one should rather assume that there is an already existing emetric space structure, whi... | true |
UInt16.isValue._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.3273093604._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Meta.Simp.DSimproc | Return `.done` for UInt values. We don't want to unfold in the symbolic evaluator. | false |
ModuleCat.instPreservesProjectiveObjectsUliftFunctorOfSmall | Mathlib.Algebra.Category.ModuleCat.Ulift | ∀ (R : Type u) [inst : Ring R] [Small.{v, u} R], (ModuleCat.uliftFunctor.{v', v, u} R).PreservesProjectiveObjects | null | true |
ExteriorAlgebra.toTrivSqZeroExt | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | {R : Type u1} →
[inst : CommRing R] →
{M : Type u2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : Module Rᵐᵒᵖ M] → [inst_4 : IsCentralScalar R M] → ExteriorAlgebra R M →ₐ[R] TrivSqZeroExt R M | The canonical map from `ExteriorAlgebra R M` into `TrivSqZeroExt R M` that sends
`ExteriorAlgebra.ι` to `TrivSqZeroExt.inr`. | true |
Finset.Colex.toColex_image_le_toColex_image | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : α → β} {s t : Finset α},
StrictMono f → (toColex (Finset.image f s) ≤ toColex (Finset.image f t) ↔ toColex s ≤ toColex t) | Strictly monotone functions preserve the colex ordering. | true |
Submodule.comap_dualAnnihilator | Mathlib.LinearAlgebra.Dual.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(Φ : Submodule R (Module.Dual R M)), Submodule.comap (Module.Dual.eval R M) Φ.dualAnnihilator = Φ.dualCoannihilator | null | true |
PointDerivation | Mathlib.Geometry.Manifold.DerivationBundle | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H →
{M : Type u_4} → [inst : Topological... | The derivations at a point of a manifold. Some regard this as a possible definition of the
tangent space, as this coincides with the usual tangent space for finite-dimensional `C^∞` real
manifolds. The identification is not true in general, though. | true |
Algebra.PreSubmersivePresentation.ofBijectiveAlgebraMap | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
Function.Bijective ⇑(algebraMap R S) → Algebra.PreSubmersivePresentation R S PEmpty.{w + 1} PEmpty.{t + 1} | If `algebraMap R S` is bijective, the empty generators are a pre-submersive
presentation with no relations. | true |
MeasureTheory.ComplexMeasure.re._proof_3 | Mathlib.MeasureTheory.Measure.Complex | ContinuousAdd ℂ | null | false |
SimpleGraph.UnitDistEmbedding.subsingleton_p_apply | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | ∀ {V : Type u_1} (G : SimpleGraph V) {E : Type u_3} [inst : MetricSpace E] [inst_1 : Subsingleton V] (x : E) (x_1 : V),
(SimpleGraph.UnitDistEmbedding.subsingleton G x).p x_1 = x | null | true |
Lean.defaultMaxRecDepth | Init.Prelude | ℕ | The default maximum recursion depth. This is adjustable using the `maxRecDepth` option. | true |
_private.Mathlib.MeasureTheory.Constructions.Cylinders.0.MeasureTheory.generateFrom_measurableCylinders._simp_1_1 | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
RingPreordering.copy._proof_8 | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] (P : RingPreordering R) (S : Set R), S = ↑P → 0 ∈ S | null | false |
CategoryTheory.MonoidalCategory.ofTensorHom._proof_5 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategoryStruct C],
(∀ {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂)
(Categor... | null | false |
CategoryTheory.Adjunction.isLocalization_leftAdjoint | Mathlib.CategoryTheory.Localization.CalculusOfFractions.OfAdjunction | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {G : CategoryTheory.Functor C₁ C₂} {F : CategoryTheory.Functor C₂ C₁}
[F.Full] [F.Faithful] (adj : G ⊣ F) (W : CategoryTheory.MorphismProperty C₁),
W.IsInvertedBy G → W.functorCategory... | null | true |
_private.Mathlib.Algebra.Group.Commute.Defs.0.Commute.mul_pow.match_1_1 | Mathlib.Algebra.Group.Commute.Defs | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
_private.Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle.0.CategoryTheory.ShortComplex.ShortExact.singleTriangle.map._simp_1 | Mathlib.Algebra.Homology.DerivedCategory.SingleTriangle | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
smul_set_closure_subset | Mathlib.Topology.Algebra.MulAction | ∀ {M : Type u_1} {X : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace X] [inst_2 : SMul M X]
[ContinuousSMul M X] (K : Set M) (L : Set X), closure K • closure L ⊆ closure (K • L) | null | true |
PolynomialLaw.zero_smul | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f : M →ₚₗ[R] N), 0 • f = 0 | null | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_mul_coe_coe | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (a b : ℝ), ContinuousAt (fun p => p.1 * p.2) (↑a, ↑b) | null | true |
Module.Grassmannian.map_id | Mathlib.RingTheory.Grassmannian | ∀ {R : Type u} [inst : CommRing R] {M : Type v} [inst_1 : AddCommGroup M] [inst_2 : Module R M] (k : ℕ)
(A : CommAlgCat R) (N : Module.Grassmannian (↑A) (TensorProduct R (↑A) M) k),
Module.Grassmannian.map (AlgHom.id R ↑A) N = N | null | true |
Differentiable.finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i : Fin n) → F... | null | true |
RestrictedProduct.instCommMonoidCoeOfSubmonoidClass._proof_5 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → CommMonoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)]
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (x_1 : ℕ), ⇑(x ^ x_1) = ⇑(x ^ x_1) | null | false |
CategoryTheory.Presheaf.IsSheaf' | Mathlib.CategoryTheory.Sites.Sheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{A : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
CategoryTheory.GrothendieckTopology C →
[CategoryTheory.Limits.HasProducts A] →
[CategoryTheory.Limits.HasPullbacks C] → CategoryTheory.Functor Cᵒᵖ A → ... | An alternative definition of the sheaf condition in terms of equalizers. This is shown to be
equivalent in `CategoryTheory.Presheaf.isSheaf_iff_isSheaf'`.
| true |
Function.Injective.addCancelCommMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Add M₁] →
[inst_1 : Zero M₁] →
[inst_2 : SMul ℕ M₁] →
[inst_3 : AddCancelCommMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 0 = 0 →
(∀ (x y : M₁), f (x + y) = f x + f y) →
... | A type endowed with `0` and `+` is an additive cancel commutative monoid if it
admits an injective map that preserves `0` and `+` to an additive cancel commutative monoid. | true |
HomologicalComplex.congr_hom | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C D : HomologicalComplex V c} {f g : C ⟶ D},
f = g → ∀ (i : ι), f.f i = g.f i | null | true |
Lean.PrettyPrinter.Delaborator.whenPPOption | Lean.PrettyPrinter.Delaborator.Basic | (Lean.Options → Bool) → Lean.PrettyPrinter.Delaborator.Delab → Lean.PrettyPrinter.Delaborator.Delab | null | true |
DividedPowers.dpow_span_isSubideal | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (hI : DividedPowers I) {S : Set A},
S ⊆ ↑I → Ideal.span {y | ∃ n, ∃ (_ : n ≠ 0), ∃ x, ∃ (_ : x ∈ S), y = hI.dpow n x} ≤ I | null | true |
PrimrecRel.comp₂ | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β]
[inst_2 : Primcodable γ] [inst_3 : Primcodable δ] {R : γ → δ → Prop} {f : α → β → γ} {g : α → β → δ},
PrimrecRel R → Primrec₂ f → Primrec₂ g → PrimrecRel fun a b => R (f a b) (g a b) | null | true |
Polynomial.iterate_derivative_X_pow_eq_natCast_mul | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u} [inst : CommSemiring R] (n k : ℕ),
(⇑Polynomial.derivative)^[k] (Polynomial.X ^ n) = ↑(n.descFactorial k) * Polynomial.X ^ (n - k) | null | true |
Polynomial.leadingCoeff_cons_eraseLead | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} [inst : Semiring R] {P : Polynomial R},
P.nextCoeff ≠ 0 → P.leadingCoeff :: P.eraseLead.coeffList = P.coeffList | null | true |
Lean.instInhabitedLeanOptionValue | Lean.Util.LeanOptions | Inhabited Lean.LeanOptionValue | null | true |
ModuleCat.ofHom₂._proof_3 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_1} [inst : CommRing R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
CategoryTheory.ObjectProperty.triangEnvelopeIter_add._auto_1 | Mathlib.CategoryTheory.Triangulated.Generators | Lean.Syntax | null | false |
fourierLp._proof_5 | Mathlib.Analysis.Fourier.AddCircle | IsBoundedSMul ℂ ℂ | null | false |
CategoryTheory.Subobject.functor_map | Mathlib.CategoryTheory.Subobject.Lattice | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {X Y : Cᵒᵖ}
(f : X ⟶ Y), (CategoryTheory.Subobject.functor C).map f = TypeCat.ofHom (CategoryTheory.Subobject.pullback f.unop).obj | null | true |
_private.Mathlib.Geometry.Euclidean.Volume.Measure.0.MeasureTheory.Measure.euclideanHausdorffMeasure._proof_4 | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ (d : ℕ), BorelSpace (PiLp 2 fun x => ℝ) | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.tactic_extension._regBuiltin.Lean.Parser.Command.tactic_extension.docString_3 | Lean.Parser.Command | IO Unit | null | false |
SimpleGraph.Walk.bypass | Mathlib.Combinatorics.SimpleGraph.Paths | {V : Type u} → {G : SimpleGraph V} → [DecidableEq V] → {u v : V} → G.Walk u v → G.Walk u v | Given a walk, produces a walk from it by bypassing subwalks between repeated vertices.
The result is a path, as shown in `SimpleGraph.Walk.bypass_isPath`.
This is packaged up in `SimpleGraph.Walk.toPath`. | true |
Module.Basis.reindex | Mathlib.LinearAlgebra.Basis.Defs | {ι : Type u_1} →
{ι' : Type u_2} →
{R : Type u_3} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Module.Basis ι R M → ι ≃ ι' → Module.Basis ι' R M | `b.reindex (e : ι ≃ ι')` is a basis indexed by `ι'` | true |
CategoryTheory._aux_Mathlib_Combinatorics_Quiver_ReflQuiver___unexpand_CategoryTheory_ReflQuiver_id_1 | Mathlib.Combinatorics.Quiver.ReflQuiver | Lean.PrettyPrinter.Unexpander | null | false |
RightOrdContinuous.map_inf | Mathlib.Order.OrdContinuous | ∀ {α : Type u} {β : Type v} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] {f : α → β},
RightOrdContinuous f → ∀ (x y : α), f (x ⊓ y) = f x ⊓ f y | null | true |
_private.Mathlib.NumberTheory.Padics.Measure.Monoid.0.AbstractMeasure.convolveFunRight._proof_6 | Mathlib.NumberTheory.Padics.Measure.Monoid | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.