name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Elab.Term.LetRecToLift.termination | Lean.Elab.Term.TermElabM | Lean.Elab.Term.LetRecToLift → Lean.Elab.TerminationHints | null | true |
MvPolynomial.eval₂_const_uniqueAlgEquiv | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {σ : Type u_1} {R : Type u_2} {S : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Unique σ]
{f : MvPolynomial σ R} {φ : R →+* S} {a : S},
Polynomial.eval₂ φ a ((MvPolynomial.uniqueAlgEquiv R σ) f) = MvPolynomial.eval₂ φ (fun x => a) f | null | 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 () | null | 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 | null | 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 | null | true |
CategoryTheory.SimplicialObject.σ_δ₀Iter'._auto_3 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | Lean.Syntax | null | false |
FreeMonoid.of_injective | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, Function.Injective FreeMonoid.of | null | true |
Lean.Grind.instCommRingBitVec._proof_1 | Init.GrindInstances.Ring.BitVec | ∀ {w : ℕ} (n : ℕ), OfNat.ofNat n = ↑n | null | 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 | null | 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 (... | null | 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 ⋯)) | null | true |
PNat.XgcdType.instSizeOf | Mathlib.Data.PNat.Xgcd | SizeOf PNat.XgcdType | null | true |
Lean.InductiveType.noConfusionType | Lean.Declaration | Sort u → Lean.InductiveType → Lean.InductiveType → Sort u | null | 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 | `IsLocalization.mk'` agrees with `IsLocalizedModule.mk'`. | 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 = ⊥ | null | true |
Batteries.Tactic.DiscrTreeCache.getMatch | Batteries.Util.Cache | {α : Type} → Batteries.Tactic.DiscrTreeCache α → Lean.Expr → Lean.MetaM (Array α) | Get matches from both the discrimination tree for declarations in the current file,
and for the imports.
Note that if you are calling this multiple times with the same environment,
it will rebuild the discrimination tree for the current file multiple times,
and it would be more efficient to call `c.get` once,
and then... | true |
Nat.factorial_pos | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ), 0 < n.factorial | null | 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 | null | true |
_private.Std.Sync.Semaphore.0.Std.SemaphoreState | Std.Sync.Semaphore | Type | null | true |
ValuativeRel.inv_vle_one | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {K : Type u_2} [inst : DivisionRing K] [inst_1 : ValuativeRel K] {x : K}, x ≠ 0 → (x⁻¹ ≤ᵥ 1 ↔ 1 ≤ᵥ x) | null | 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 | null | 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 | null | 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) | null | 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 ... | null | 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) | null | false |
Lean.Util.ParamMinimizer.Result._sizeOf_inst | Lean.Util.ParamMinimizer | SizeOf Lean.Util.ParamMinimizer.Result | null | false |
TopPair.HomologyPretheory.inv_hom_iso_homₚ | Mathlib.AlgebraicTopology.EilenbergSteenrod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} {HP HP' : TopPair.HomologyPretheory C c} (f : HP ⟶ HP') (i : ι),
CategoryTheory.CategoryStruct.comp (HP.iso i).inv (CategoryTheory.CategoryStruct.comp (f.hom i) (HP'... | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.Int16.toBitVec_minValueSealed_eq_intMinSealed | Init.Data.Range.Polymorphic.SInt | Int16.minValueSealed✝.toBitVec = BitVec.Signed.intMinSealed✝ 16 | null | true |
_private.Lean.Parser.Extension.0.Lean.Parser.optionValueToDataValue?._sparseCasesOn_1 | Lean.Parser.Extension | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Lean.Lsp.DiagnosticTag.deprecated | Lean.Data.Lsp.Diagnostics | Lean.Lsp.DiagnosticTag | Deprecated or obsolete code. Rendered with a strike-through. | true |
Polynomial.ofFinsupp_pow | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (a : AddMonoidAlgebra R ℕ) (n : ℕ), { toFinsupp := a ^ n } = { toFinsupp := a } ^ n | null | 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)) | null | true |
LucasLehmer.norm_num_ext.sModNat._f | Mathlib.NumberTheory.LucasLehmer | ℕ → (x : ℕ) → Nat.below x → ℕ | null | false |
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 | null | true |
Int.Internal.Linear.Poly.combine'.match_1 | Init.Data.Int.Linear | (motive : Int.Internal.Linear.Poly → Int.Internal.Linear.Poly → Sort u_1) →
(p₁ p₂ : Int.Internal.Linear.Poly) →
((k₁ k₂ : ℤ) → motive (Int.Internal.Linear.Poly.num k₁) (Int.Internal.Linear.Poly.num k₂)) →
((k₁ a : ℤ) →
(x : Int.Internal.Linear.Var) →
(p : Int.Internal.Linear.Poly) →
... | null | false |
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... | null | 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₂ | null | 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... | null | 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} (ε : ... | null | 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 | null | 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 | Inner loop for Mersenne Twister initalization. | false |
ExistsAndEq.instInhabitedGoTo.default | Mathlib.Tactic.Simproc.ExistsAndEq | ExistsAndEq.GoTo | null | 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 ... | null | 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) ... | null | 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)),
autoParam (∀ (n : ℕ) (x : ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections), x ^ (n + 1) = x ^ n * x)
Monoid.npow_succ._autoParam | null | false |
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_... | null | true |
Cardinal.mk_list_eq_max_mk_aleph0 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ (α : Type u) [Nonempty α], Cardinal.mk (List α) = max (Cardinal.mk α) Cardinal.aleph0 | null | true |
_private.Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong.0._auto_83 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | Lean.Syntax | null | 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') | null | 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) | null | true |
setOf_sub_mem_closedBall_eq_closedBall | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] {a : E} {r : ℝ},
{x | x - a ∈ Metric.closedBall 0 r} = Metric.closedBall a r | A translated closed ball is a closed ball. | true |
Part._sizeOf_inst | Mathlib.Data.Part | (α : Type u) → [SizeOf α] → SizeOf (Part α) | null | false |
String.Pos.prev_le | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {h : p ≠ s.startPos}, p.prev h ≤ p | null | true |
eVariationOn_smul_le | Mathlib.Analysis.BoundedVariation | ∀ {α : Type u_2} [inst : LinearOrder α] {F : Type u_4} [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ F]
{𝕜 : Type u_6} {f : α → 𝕜} {g : α → F} [inst_3 : NormedRing 𝕜] [inst_4 : NormedAlgebra ℝ 𝕜] [inst_5 : Module 𝕜 F]
[NormSMulClass 𝕜 F] [IsScalarTower ℝ 𝕜 F] {C D : ENNReal} {s : Set α},
(∀ x ∈ s... | null | true |
_private.Mathlib.MeasureTheory.VectorMeasure.Variation.Basic.0.MeasureTheory.VectorMeasure.exists_lt_sum_of_lt_variation._simp_1_5 | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
TannakaDuality.FiniteGroup.equivHom._proof_3 | Mathlib.RepresentationTheory.Tannaka | ∀ (k G : Type u_1) [inst : CommRing k] [inst_1 : Group G] (g : G) {X Y : FDRep k G} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f.hom (Y.ρ g).asHom = CategoryTheory.CategoryStruct.comp (X.ρ g).asHom f.hom | null | 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), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | 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... | null | true |
Convexity.ConvexSpace.AffineMap.instFunLike._proof_1 | Mathlib.Geometry.Convex.ConvexSpace.AffineMap | ∀ {R : Type u_1} [inst : PartialOrder R] [inst_1 : Semiring R] [inst_2 : IsStrictOrderedRing R] {X : Type u_2}
{Y : Type u_3} [inst_3 : Convexity.ConvexSpace R X] [inst_4 : Convexity.ConvexSpace R Y]
(x x_1 : Convexity.ConvexSpace.AffineMap R X Y), x.toFun = x_1.toFun → x = x_1 | null | 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 | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Cartan.Basic.0.CartanMatrix.D_off_diag_nonpos._proof_1_2 | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | ∀ (n : ℕ) (i j : Fin n), i ≠ j → i = j → 2 ≤ 0 | null | false |
Turing.ToPartrec.Cont.eval.eq_4 | Mathlib.Computability.TuringMachine.Config | ∀ (f : Turing.ToPartrec.Code) (k : Turing.ToPartrec.Cont),
(Turing.ToPartrec.Cont.comp f k).eval = fun v => f.eval v >>= k.eval | null | true |
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) | null | true |
Multiset.pairwise_zero._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (r : α → α → Prop), Multiset.Pairwise r 0 = True | null | false |
_private.Lean.Meta.Tactic.Grind.EMatchDiagnostics.0.Lean.Meta.Grind.counterMsgs.match_4 | Lean.Meta.Tactic.Grind.EMatchDiagnostics | (motive : Lean.Meta.Grind.Origin → Sort u_1) →
(origin : Lean.Meta.Grind.Origin) →
((fvarId : Lean.FVarId) → motive (Lean.Meta.Grind.Origin.fvar fvarId)) →
((n : Lean.Name) → motive (Lean.Meta.Grind.Origin.decl n)) →
((n : Lean.Name) → motive (Lean.Meta.Grind.Origin.local n)) →
((n : Lean.... | null | false |
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₀) | Helper structure in order to prove `Module.Relations.Solutions.IsPresentation`
by showing the universal property of the module defined by generators and relations.
The universal property is restricted to modules that are in `Type w'` for
an auxiliary universe `w'`. See `IsPresentationCore.isPresentation`. | true |
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 | null | true |
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 φ.τ₃],
(Category... | null | true |
Ordnode.size_toOrdNode | Mathlib.Data.Ordmap.Ordnode | ∀ {α : Type u_1} (b : BinaryTree α), b.toOrdNode.size = b.numNodes | null | true |
MDifferentiableAt.sum_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_5} [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... | null | true |
Lean.Lsp.instFromJsonDefinitionParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.DefinitionParams | null | true |
_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 (... | First step in Bojanić's proof of Mahler's theorem (equation (10) of [bojanic74]): rewrite
`Δ^[n + R] f 0` in a shape that makes it easy to bound `p`-adically. | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty.0.SimplexCategory.Truncated.epi_induction._proof_1_2 | Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty | ∀ {d : ℕ} {x : CategoryTheory.ObjectProperty.FullSubcategory fun a => a.len ≤ d}, x.obj.len ≤ d | null | false |
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 | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_390 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
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 | null | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_8 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r : ℤ), autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_5 → r₀ ≤ r | null | false |
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) | Mapping by the identity morphism is just the identity functor. | true |
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 ℕ) | Mapping from types to its "ring id". We cache failures using `none`.
`typeIdOf[type]` is `some id`, then `id < rings.size`. | true |
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 | null | true |
Submodule.submodule_torsionBy_orderIso._proof_5 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M],
AddSubmonoidClass (Submodule R M) M | null | false |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.reduceCoefficientwise.match_9 | Mathlib.Tactic.Module | {u v : Lean.Level} →
{M : Q(Type v)} →
{R : Q(Type u)} →
{x : Q(AddCommMonoid «$M»)} →
{x_1 : Q(Semiring «$R»)} →
(iRM : Q(Module «$R» «$M»)) →
(l₁ : Mathlib.Tactic.Module.qNF R M) →
(L₂ : List ((Q(«$R») × Q(«$M»)) × ℕ)) →
(motive :
... | null | false |
Std.DTreeMap.Internal.Const.toList_ric | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] (t : Std.DTreeMap.Internal.Impl α fun x => β),
t.Ordered →
∀ (bound : α),
Std.Slice.toList (Std.Ric.Sliceable.mkSlice t *...=bound) =
List.filter (fun e => (compare e.1 bound).isLE) (Std.DTreeMap.Internal.Impl.Const.toList t) | null | true |
ProfiniteAddGrp.ProfiniteCompletion.etaFn | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | (G : AddGrpCat) → ↑G → ↑(ProfiniteAddGrp.ProfiniteCompletion.completion G).toProfinite.toTop | The canonical map from `G` to its profinite completion, as a function. | true |
CategoryTheory.Limits.CokernelCofork.π_mapOfIsColimit | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f}
(hf : CategoryTheory.Limits.IsColimit cc) (cc' : CategoryTheory.Limits.CokernelCofork f')
(φ : CategoryTheory.... | null | true |
Std.DTreeMap.Internal.Impl.Equiv.minKeyD_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ {fallback : α}, t₁.minKeyD fallback = t₂.minKeyD fallback | null | true |
Std.TreeSet.le_min | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α} {he : t.isEmpty = false},
(cmp k (t.min he)).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
Array.replace_extract | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α} {xs : Array α} {i : ℕ},
(xs.extract 0 i).replace a b = (xs.replace a b).extract 0 i | null | true |
CategoryTheory.Comma.post | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{C : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C] →
... | The functor `(L, R) ⥤ (L ⋙ F, R ⋙ F)` | true |
CategoryTheory.CommMon.equivLaxBraidedFunctorPUnit_functor | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.CommMon.equivLaxBraidedFunctorPUnit.functor =
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon C | null | true |
Aesop.GoalUnsafe.rec_6 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
... | null | false |
CategoryTheory.TransfiniteCompositionOfShape.F | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
CategoryTheory.Transfinit... | a well order continuous functor `F : J ⥤ C` | true |
AbsoluteValue.coe_toMonoidWithZeroHom | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_4} {S : Type u_5} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : PartialOrder S]
(abv : AbsoluteValue R S) [inst_3 : IsDomain S] [inst_4 : Nontrivial R], ⇑↑abv = ⇑abv | null | true |
SchwartzMap.toBoundedContinuousFunctionCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | (𝕜 : Type u_2) →
(E : Type u_5) →
(F : Type u_6) →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
[inst_4 : RCLike 𝕜] →
[inst_5 : NormedSpace 𝕜 F] →
[... | The inclusion map from Schwartz functions to bounded continuous functions as a continuous linear
map. | true |
FloatArray.mk | Init.Data.FloatArray.Basic | Array Float → FloatArray | null | true |
PartialEquiv.IsImage.of_symm_preimage_eq | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t → e.IsImage s t | **Alias** of the reverse direction of `PartialEquiv.IsImage.iff_symm_preimage_eq`. | true |
_private.Mathlib.RingTheory.Localization.Finiteness.0.Submodule.of_localizationSpan'._simp_1_1 | Mathlib.RingTheory.Localization.Finiteness | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M}, N.FG = Module.Finite R ↥N | null | false |
KaehlerDifferential.derivationQuotKerTotal | Mathlib.RingTheory.Kaehler.Basic | (R : Type u) →
(S : Type v) →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → Derivation R S ((S →₀ S) ⧸ KaehlerDifferential.kerTotal R S) | The (universal) derivation into `(S →₀ S) ⧸ KaehlerDifferential.kerTotal R S`. | true |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.Matrix.SpecialLinearGroup.diag_decompose._proof_1_1 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {ι : Type u_1} [inst : Fintype ι] [inst_1 : DecidableEq ι] (i₀ : ι), Finset.univ = insert i₀ {i | ¬i = i₀} | null | false |
AlgHom.coeOutAddMonoidHom | Mathlib.Algebra.Algebra.Hom | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] → [inst_3 : Algebra R A] → [inst_4 : Algebra R B] → CoeOut (A →ₐ[R] B) (A →+ B) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.