name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Grind.SplitAnchorRefInfo.ordinal | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitAnchorRefInfo → ℕ | null | true |
CategoryTheory.Functor.OplaxMonoidal.ofChosenFiniteProducts._proof_4 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) (x : C),
(CategoryTheory.MonoidalCategoryStruct... | null | false |
_private.Mathlib.Data.Finset.Insert.0.Finset.pairwise_cons'._proof_1_3 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {a : α},
a ∉ s →
∀ (r : β → β → Prop) (f : α → β),
(((↑s).Pairwise fun x y => r (f x) (f y)) ∧ ∀ b ∈ ↑s, ¬a = b → r (f a) (f b) ∧ r (f b) (f a)) ↔
((↑s).Pairwise fun x y => r (f x) (f y)) ∧ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a) | null | false |
PowerBasis.repr_mul_isIntegral | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {S : Type u_2} [inst : CommRing S] {R : Type u_3} [inst_1 : CommRing R] [inst_2 : Algebra R S] {A : Type u_4}
[inst_3 : CommRing A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A] {B : PowerBasis S A},
IsIntegral R B.gen →
∀ {x y : A},
(∀ (i : Fin B.dim), IsIntegral R ((B.basis.repr ... | Let `B : PowerBasis S A` be such that `IsIntegral R B.gen`, and let `x y : A` be elements with
integral coordinates in the base `B.basis`. Then `IsIntegral R ((B.basis.repr (x * y) i)` for all
`i` if `minpoly S B.gen = (minpoly R B.gen).map (algebraMap R S)`. This is the case if `R` is a GCD
domain and `S` is its fract... | true |
CategoryTheory.ShortComplex.HomologyMapData._sizeOf_inst | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
(φ : S₁ ⟶ S₂) →
(h₁ : S₁.HomologyData) →
(h₂ : S₂.HomologyData) → [SizeOf C] → SizeOf (CategoryTheory.ShortComplex.Homology... | null | false |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.comp_det_mul_pow._simp_1_2 | Mathlib.RingTheory.Norm.Transitivity | ∀ (I : Type u_1) (J : Type u_2) (R : Type u_5) [inst : AddCommMonoid R] [inst_1 : Mul R] [inst_2 : Fintype I]
[inst_3 : Fintype J] (M : Matrix I I (Matrix J J R)), (Matrix.comp I I J J R) M = (Matrix.compRingEquiv I J R) M | null | false |
Condensed.ulift._proof_1 | Mathlib.Condensed.Functors | CategoryTheory.Precoherent CompHaus | null | false |
CategoryTheory.Lax.LaxTrans.naturality_naturality._autoParam | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | Lean.Syntax | null | false |
MonoidAlgebra.of._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : MulOneClass M] (x y : M),
(MonoidAlgebra.ofMagma R M).toFun (x * y) = (MonoidAlgebra.ofMagma R M).toFun x * (MonoidAlgebra.ofMagma R M).toFun y | null | false |
Int32.reduceLE | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | Lean.Meta.Simp.Simproc | null | true |
_private.Mathlib.NumberTheory.MahlerMeasure.0.Polynomial.card_mahlerMeasure._proof_1_6 | Mathlib.NumberTheory.MahlerMeasure | ∀ (n : ℕ) (B : NNReal), ∀ a ∈ Finset.univ, ¬2 * ⌊↑(n.choose ↑a) * B⌋₊ + 1 = 0 | null | false |
ModuleCat.forget₂_reflectsLimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Abelian | ∀ {R : Type u} [inst : Ring R],
CategoryTheory.Limits.ReflectsLimitsOfSize.{v, v, max v w, max v w, max (max u (v + 1)) (w + 1), max (v + 1) (w + 1)}
(CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat) | null | true |
log_deriv_riemannZeta_add_inv_sub_sub_isLittleO | Mathlib.NumberTheory.Harmonic.ZetaAsymp | (fun s => deriv riemannZeta s / riemannZeta s + (s - 1)⁻¹ - ↑Real.eulerMascheroniConstant) =o[nhdsWithin 1 {1}ᶜ]
fun x => 1 | null | true |
ProbabilityTheory.condIndep_of_condIndep_of_le_right | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {m' m₁ m₂ m₃ mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ],
ProbabilityTheory.CondIndep m' m₁ m₂ hm' μ → m₃ ≤ m₂ → ProbabilityTheory.CondIndep m' m₁ m₃ hm' μ | null | true |
LieAlgebra.Orthogonal.invertiblePB._proof_1 | Mathlib.Algebra.Lie.Classical | ∀ (l : Type u_2) (R : Type u_1) [inst : DecidableEq l] [inst_1 : CommRing R] [inst_2 : Fintype l],
IsDedekindFiniteMonoid (Matrix (Unit ⊕ l ⊕ l) (Unit ⊕ l ⊕ l) R) | null | false |
AugmentedSimplexCategory.instMonoidalCategory._proof_11 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (X Y : AugmentedSimplexCategory),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X
(CategoryTheory.MonoidalCategoryStruct.tensorUnit AugmentedSimplexCategory) Y).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X)
... | null | false |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.sum_neg_one_pow_eq_zero._proof_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ}, NeZero (n + 2) | null | false |
Sequential.instCategory._aux_5 | Mathlib.Topology.Category.Sequential | {X Y Z : Sequential} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | null | false |
BddLat.ofHom | Mathlib.Order.Category.BddLat | {X Y : Type u} →
[inst : Lattice X] →
[inst_1 : BoundedOrder X] → [inst_2 : Lattice Y] → [inst_3 : BoundedOrder Y] → BoundedLatticeHom X Y → (↧X ⟶ ↧Y) | Typecheck a `BoundedLatticeHom` as a morphism in `BddLat`. | true |
_private.Mathlib.LinearAlgebra.Transvection.Generation.0.LinearEquiv.mem_transvections_pow_mul_dilatransvections_of_fixedReduce_ne_smul_id._simp_1_1 | Mathlib.LinearAlgebra.Transvection.Generation | ∀ {V : Type u_2} [inst : AddCommGroup V] {K : Type u_3} [inst_1 : DivisionRing K] [inst_2 : Module K V]
[Module.Finite K V] {e : V ≃ₗ[K] V},
(e ∈ LinearEquiv.dilatransvections K V) = (Module.finrank K (V ⧸ (↑e).fixedSubmodule) ≤ 1) | null | false |
_private.Mathlib.Analysis.Calculus.Deriv.Mul.0.derivWithin_fun_const_smul_field._simp_1_1 | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜}, derivWithin f s x = (fderivWithin 𝕜 f s x) 1 | null | false |
Lean.Grind.CommRing.mk._flat_ctor | Init.Grind.Ring.Basic | {α : Type u} →
(add mul : α → α → α) →
[natCast : NatCast α] →
[ofNat : (n : ℕ) → OfNat α n] →
[nsmul : SMul ℕ α] →
[npow : HPow α ℕ α] →
(∀ (a : α), a + 0 = a) →
(∀ (a b : α), a + b = b + a) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
... | null | false |
Sigma.Lex.LT | Mathlib.Order.Sigma | {ι : Type u_1} → {α : ι → Type u_2} → [LT ι] → [(i : ι) → LT (α i)] → LT (Σₗ (i : ι), α i) | The lexicographical `<` on a sigma type. | true |
Std.Do.Iter.foldM_mapM | Std.Do.Triple.SpecLemmas | ∀ {ps : Std.Do.PostShape} {α β γ δ : Type w} {n : Type w → Type w''} {o : Type w → Type w'''}
[inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n]
[WeaklyLawfulMonadAttach n] [inst_6 : Monad o] [LawfulMonad o] [inst_8 : Std.Do.WPMonad o ps]
[inst_9 :... | null | true |
_private.Init.Data.Nat.Internal.Linear.0.Nat.Internal.Linear.instBEqPolyCnstr.beq.match_1.eq_1 | Init.Data.Nat.Internal.Linear | ∀ (motive : Nat.Internal.Linear.PolyCnstr → Nat.Internal.Linear.PolyCnstr → Sort u_1) (a : Bool)
(a_1 a_2 : Nat.Internal.Linear.Poly) (b : Bool) (b_1 b_2 : Nat.Internal.Linear.Poly)
(h_1 :
(a : Bool) →
(a_3 a_4 : Nat.Internal.Linear.Poly) →
(b : Bool) →
(b_3 b_4 : Nat.Internal.Linear.Pol... | null | true |
Lean.Lsp.DocumentSymbol.rec | Lean.Data.Lsp.LanguageFeatures | {motive_1 : Lean.Lsp.DocumentSymbol → Sort u} →
{motive_2 : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol → Sort u} →
{motive_3 : Option (Array Lean.Lsp.DocumentSymbol) → Sort u} →
{motive_4 : Array Lean.Lsp.DocumentSymbol → Sort u} →
{motive_5 : List Lean.Lsp.DocumentSymbol → Sort u} →
... | null | false |
Mathlib.Tactic.Widget.StringDiagram.IdNode.mk.inj | Mathlib.Tactic.Widget.StringDiagram | ∀ {vPos hPosSrc hPosTar : ℕ} {id : Mathlib.Tactic.BicategoryLike.Atom₁} {vPos_1 hPosSrc_1 hPosTar_1 : ℕ}
{id_1 : Mathlib.Tactic.BicategoryLike.Atom₁},
{ vPos := vPos, hPosSrc := hPosSrc, hPosTar := hPosTar, id := id } =
{ vPos := vPos_1, hPosSrc := hPosSrc_1, hPosTar := hPosTar_1, id := id_1 } →
vPos = vP... | null | true |
_private.Mathlib.Data.List.Sublists.0.List.Pairwise.sublists'._simp_1_3 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | null | false |
Std.IterM.step_filterWithPostcondition._proof_4 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_3} {n : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {it : Std.IterM m β}
{f : β → Std.Iterators.PostconditionT n (ULift.{u_1, 0} Bool)} [inst_1 : Monad n] [inst_2 : MonadLiftT m n]
(it' : Std.IterM m β),
it.IsPlausibleStep (Std.IterStep.skip it') →
(Std.IterM.fil... | null | false |
Mathlib.Meta.FunProp.FunPropDecl.funArgId | Mathlib.Tactic.FunProp.Decl | Mathlib.Meta.FunProp.FunPropDecl → ℕ | argument index of a function this function property talks about.
For example, this would be 4 for `@Continuous α β _ _ f` | true |
WithBot.addMonoidWithOne | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {α : Type u} → [AddMonoidWithOne α] → AddMonoidWithOne (WithBot α) | null | true |
_private.Mathlib.CategoryTheory.Limits.MorphismProperty.0.CategoryTheory.StructuredArrow.isClosedUnderLimitsOfShape.match_1_1 | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} T] {A : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} A] {L : CategoryTheory.Functor A T} {J : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} J] {P : CategoryTheory.MorphismProperty T} (X : T)
(Y : CategoryTheory.StructuredArrow X L)
(... | null | false |
Metric.exists_finite_isCover_of_isCompact_closure | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {ε : NNReal} {s : Set X},
ε ≠ 0 → IsCompact (closure s) → ∃ N ⊆ s, N.Finite ∧ Metric.IsCover ε s N | A relatively compact set admits a finite cover. | true |
FirstOrder.Language.DirectLimit.instStructureDirectLimit._aux_1 | Mathlib.ModelTheory.DirectLimit | {L : FirstOrder.Language} →
{ι : Type u_1} →
[inst : Preorder ι] →
(G : ι → Type u_2) →
[inst_1 : (i : ι) → L.Structure (G i)] →
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) →
[inst_2 : IsDirectedOrder ι] →
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] ... | null | false |
Order.succ_eq_zero | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddZeroClass α] [inst_2 : OrderBot α] [IsBotZeroClass α]
[inst_4 : One α] [NoMaxOrder α] [inst_6 : SuccAddOrder α] {a : WithBot α}, a.succ = 0 ↔ a = ⊥ | null | true |
Multiplicative.preorder._proof_2 | Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags | ∀ {α : Type u_1} [inst : Preorder α] (a b c : Multiplicative α), a ≤ b → b ≤ c → a ≤ c | null | false |
CategoryTheory.MorphismProperty.isomorphisms.iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.MorphismProperty.isomorphisms C f = CategoryTheory.IsIso f | null | false |
Lean.Grind.OrderedAdd.zsmul_nonpos | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.IntModule M] [Lean.Grind.OrderedAdd M]
{k : ℤ} {a : M}, 0 ≤ k → a ≤ 0 → k • a ≤ 0 | null | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.isOrdered_iff._simp_1_1 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {L R : Option α} [Std.TransCmp cmp] {t : RBTree.RBNode α},
(RBTree.RBNode.isOrdered cmp t L R = true) =
((∀ a ∈ L, RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp a x) t) ∧
(∀ a ∈ R, RBTree.RBNode.All (fun x => RBTree.RBNode.cmpLT cmp x a) t) ∧
(∀ a ∈ L,... | null | false |
Mathlib.Tactic.CategoryTheory.Map.mapExprHom | Mathlib.Tactic.CategoryTheory.Map | (type : Q(Prop)) → Q(«$type») → Lean.Level → Lean.Level → Lean.Elab.TermElabM Lean.Expr | Build the functor `map` lemma for `e : f = g` with target category levels `uLev`, `vLev`. | true |
Equiv.completeDistribLattice._proof_4 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CompleteDistribLattice β] (a b : α),
e (e.symm (e a ⊓ e b)) = e a ⊓ e b | null | false |
Affine.Simplex.dist_lt_of_mem_interior_of_strictConvexSpace | Mathlib.Analysis.Convex.StrictCombination | ∀ {V : Type u_2} {P : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [StrictConvexSpace ℝ V]
[inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) {r : ℝ} {p₀ p : P},
p ∈ s.interior → (∀ (i : Fin (n + 1)), dist (s.points i) p₀ ≤ r) → dist p p₀ < r | null | true |
Lean.Parser.Term.arrow | Lean.Parser.Term | Lean.Parser.TrailingParser | null | true |
Int.sub_fdiv_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b c : ℤ}, c ∣ b → (a - b).fdiv c = a.fdiv c - b.fdiv c | null | true |
Lean.Elab.DefViewElabHeaderData.mk.noConfusion | Lean.Elab.DefView | {P : Sort u} →
{shortDeclName declName : Lean.Name} →
{levelNames : List Lean.Name} →
{binderIds : Array Lean.Syntax} →
{numParams : ℕ} →
{type : Lean.Expr} →
{shortDeclName' declName' : Lean.Name} →
{levelNames' : List Lean.Name} →
{binderIds' : A... | null | false |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.ofPermHom_support._simp_1_2 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {b : β},
(b ∈ s.biUnion t) = ∃ a ∈ s, b ∈ t a | null | false |
SSet.Truncated.hoFunctor.monoidal._proof_18 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | autoParam
(∀ (X : SSet),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (SSet.hoFunctor.obj X)).inv =
CategoryTheory.CategoryStruct.comp (SSet.hoFunctor.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv)
(CategoryTheory.CategoryStruct.comp
(SSet.Truncated.hoFunctor.monoidal... | null | false |
Nat.instNeZeroHPow | Init.Data.Nat.Basic | ∀ {n m : ℕ} [NeZero n], NeZero (n ^ m) | null | true |
IsSelfAdjoint.natCast._simp_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : StarRing R] (n : ℕ), IsSelfAdjoint ↑n = True | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.Const.balanced_modify._proof_1_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] {k : α} {f : β → β} (sz : ℕ) (k_1 : α) (v : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
(Std.DTreeMap.Internal.Impl.inner sz k_1 v l r).Balanced →
(Std.DTreeMap.Internal.Impl.Const.modify k f l).Balanced →
(Std.DTreeMap.Internal.Impl.Const.modify k f ... | null | false |
Ideal.Quotient.algebra_isIntegral_of_liesOver | Mathlib.RingTheory.Ideal.GoingUp | ∀ {A : Type u_1} [inst : CommRing A] {B : Type u_2} [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Algebra.IsIntegral A B] (P : Ideal B) (p : Ideal A) [inst_4 : P.LiesOver p], Algebra.IsIntegral (A ⧸ p) (B ⧸ P) | `B ⧸ P` is an integral `A ⧸ p`-algebra if `B` is an integral `A`-algebra. | true |
Std.Time.PlainDateTime.recOn | Std.Time.DateTime.PlainDateTime | {motive : Std.Time.PlainDateTime → Sort u} →
(t : Std.Time.PlainDateTime) →
((date : Std.Time.PlainDate) → (time : Std.Time.PlainTime) → motive { date := date, time := time }) → motive t | null | false |
inv_eq_one_divp' | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), ↑(1 / u) = 1 /ₚ u | null | true |
List.countPBefore.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (xs : List α) (i : ℕ), List.countPBefore p xs i = List.countPBefore.go p xs i 0 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_insertMany_list._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Finset.le_min_iff | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {m : WithTop α} {s : Finset α}, m ≤ s.min ↔ ∀ a ∈ s, m ≤ ↑a | null | true |
CochainComplex.HomComplex.Cocycle.leftShift._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cocycle K L n) (a n' : ℤ) (hn' : n + a = n'),
CochainComplex.HomComplex.δ n' (n' + 1) ((↑γ).leftShift a n' hn') = 0 | null | false |
Relation.map_le_iff_le_bicompl | Mathlib.Logic.Relation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {r : α → β → Prop} {s : γ → δ → Prop} {f : α → γ}
{g : β → δ}, Relation.Map r f g ≤ s ↔ r ≤ Function.bicompl s f g | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₄_eq_some_of_toBitVec._simp_1_5 | Init.Data.String.Decode | ∀ {a b : UInt32}, (a < b) = (a.toBitVec < b.toBitVec) | null | false |
NNReal.instPosSMulStrictMono | Mathlib.Basic.NNReal.Defs | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : MulAction ℝ α] [PosSMulStrictMono ℝ α], PosSMulStrictMono NNReal α | null | true |
Lean.Elab.Tactic.Conv.matchPattern? | Lean.Elab.Tactic.Conv.Pattern | Lean.Meta.AbstractMVarsResult → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Array Lean.Expr)) | null | true |
Std.HashMap.Raw.ofArray | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → Array (α × β) → Std.HashMap.Raw α β | Creates a hash map from a list of mappings. If the same key appears multiple times, the last
occurrence takes precedence. | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.responseForbidsFramingHeaders | Std.Http.Protocol.H1 | Std.Http.Status → Bool | Returns `true` when response status forbids framing headers entirely
(informational and `204` responses).
| true |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.toOption.eq_1 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type} {pat : ρ} [inst : String.Slice.Pattern.ToForwardSearcher pat σ]
{s : String.Slice} (currPos : s.Pos) (s_1 : Std.Iter (String.Slice.Pattern.SearchStep s)),
String.Slice.SplitIterator.toOption✝ (String.Slice.SplitIterator.operating currPos s_1) = some s_1 | null | true |
VectorField.mlieBracketWithin_def | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {V W : (x : M) → TangentSpa... | null | true |
wrapped._@.Mathlib.Topology.Algebra.InfiniteSum.Defs.1210274395._hygCtx._hyg.8 | Mathlib.Topology.Algebra.InfiniteSum.Defs | Subtype (Eq @definition✝) | null | false |
CategoryTheory.Idempotents.Karoubi.Hom.recOn | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P Q : CategoryTheory.Idempotents.Karoubi C} →
{motive : P.Hom Q → Sort u} →
(t : P.Hom Q) →
((f : P.X ⟶ Q.X) →
(comm : CategoryTheory.CategoryStruct.comp P.p (CategoryTheory.CategoryStruct.comp f Q.p) = f) →
... | null | false |
_private.Init.Data.Nat.Div.Lemmas.0.Nat.add_div._proof_1_2 | Init.Data.Nat.Div.Lemmas | ∀ {a b c : ℕ}, 0 < c → ¬c ≤ a % c + b % c → ¬a % c + b % c ≤ c - 1 → False | null | false |
HahnSeries.instNatCast | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} → [Zero Γ] → [inst : PartialOrder Γ] → [inst_1 : Zero R] → [NatCast R] → NatCast (HahnSeries Γ R) | null | true |
_private.Init.Data.Char.Basic.0.Char.isValidUInt32.match_1_1 | Init.Data.Char.Basic | ∀ (n : ℕ) (motive : Char.isValidCharNat n → Prop) (h : Char.isValidCharNat n),
(∀ (h : n < 55296), motive ⋯) → (∀ (left : 57343 < n) (h₂ : n < 1114112), motive ⋯) → motive h | null | false |
Cardinal.lift_mk_fin | Mathlib.SetTheory.Cardinal.Defs | ∀ (n : ℕ), Cardinal.lift.{u_1, 0} (Cardinal.mk (Fin n)) = ↑n | null | true |
AEMeasurable.lintegral_prod_right | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {f : α → β → ENNReal},
AEMeasurable (Function.uncurry f) (μ.prod ν) → AEMeasurable (fun x => ∫⁻ (y : β), f x y ∂ν) μ | null | true |
Asymptotics.wrapped._@.Mathlib.Analysis.Asymptotics.Defs.2970832229._hygCtx._hyg.2 | Mathlib.Analysis.Asymptotics.Defs | Subtype (Eq @Asymptotics.definition✝) | null | false |
Lean.Expr.getBoundedAppFn._f | Lean.Expr | (x : ℕ) → Nat.below (motive := fun x => Lean.Expr → Lean.Expr) x → Lean.Expr → Lean.Expr | null | false |
zsmul_right_inj | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : AddGroup G] [HasUniqueDiv G] {n : ℤ} {a b : G}, n ≠ 0 → (n • a = n • b ↔ a = b) | null | true |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Real.0.Real.finiteSpanningSetsInIooRat._simp_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Lean.Compiler.LCNF.instInhabitedLiveVars.default | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.LiveVars✝ | null | true |
CategoryTheory.Functorial.map_comp | Mathlib.CategoryTheory.Functor.Functorial | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : C → D} [self : CategoryTheory.Functorial F] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.map F (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (Catego... | A functorial map preserves composition of morphisms. | true |
Std.Time.WallTime.subDuration | Std.Time.DateTime.WallTime | Std.Time.WallTime → Std.Time.Duration → Std.Time.WallTime | Subtracts a `Duration` from the given `WallTime`.
| true |
Std.IterM.forIn_filterMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {n : Type u_1 → Type u_3} {o : Type u_1 → Type u_4} {α β β₂ γ : Type u_1} [inst : Monad m]
[LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n] [inst_4 : Monad o] [LawfulMonad o] [inst_6 : MonadAttach n]
[WeaklyLawfulMonadAttach n] [inst_8 : MonadLiftT m n] [LawfulMonadLiftT m n] [inst_10 ... | null | true |
WeierstrassCurve.Affine.CoordinateRing.instAlgebraPolynomial | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} → [inst : CommRing R] → {W' : WeierstrassCurve.Affine R} → Algebra (Polynomial R) W'.CoordinateRing | null | true |
NNReal.agm_le_max | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {x y : NNReal}, x.agm y ≤ max x y | null | true |
SimpleGraph.Walk.isHamiltonianCycle_reverse | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a : α} {p : G.Walk a a},
p.reverse.IsHamiltonianCycle ↔ p.IsHamiltonianCycle | null | true |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.getTransitionTheorems.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive :
Lean.Meta.RefinedDiscrTree.MatchResult Mathlib.Meta.FunProp.GeneralTheorem ×
Lean.Meta.RefinedDiscrTree Mathlib.Meta.FunProp.GeneralTheorem →
Sort u_1) →
(x :
Lean.Meta.RefinedDiscrTree.MatchResult Mathlib.Meta.FunProp.GeneralTheorem ×
Lean.Meta.RefinedDiscrTree Mathlib.Meta.... | null | false |
Affine.Simplex.volume_eq_euclideanHausdorffMeasure_real_closedInterior | Mathlib.Geometry.Euclidean.Volume.MeasureSimplex | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [inst_4 : MeasurableSpace P] [inst_5 : BorelSpace P] {n : ℕ}
(s : Affine.Simplex ℝ P n), s.volume = (MeasureTheory.Measure.euclideanHausdorffMeasure n).real s.closed... | `Affine.Simplex.volume` is equal to the Euclidean Hausdorff measure of the closed interior. | true |
RBTree.RBSet.Slow.instDecidableMem | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → {x : α} → {t : RBTree.RBSet α cmp} → Decidable (RBTree.RBSet.Mem x t) | null | true |
_private.Mathlib.Analysis.Distribution.ContDiffMapSupportedIn.0.ContDiffMapSupportedIn.continuous_iff_comp_order_le._simp_1_2 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (a : Prop), (False → a) = True | null | false |
TensorProduct.AlgebraTensorModule.rightComm._proof_29 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_1) (S : Type u_6) (B : Type u_2) (M : Type u_3) (P : Type u_4) (Q : Type u_5) [inst : CommSemiring R]
[inst_1 : Semiring B] [inst_2 : Algebra R B] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module B M]
[inst_6 : IsScalarTower R B M] [inst_7 : AddCommMonoid P] [inst_8 : AddCommMonoid Q]... | null | false |
HomologicalComplex.pathObject.mapHomologicalComplexObjIso | Mathlib.Algebra.Homology.HomotopyFiber | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{α : Type u_2} →
{c : ComplexShape α} →
(K : HomologicalComplex C c) →
[inst_2 : DecidableRel c.Rel] →
[inst_3 : ∀ (i : α), CategoryTheory.Limits.HasBinaryBi... | The isomorphism expressing the commutation between taking
the path object of a homological complex and applying an additive functor. | true |
ascPochhammer_succ_eval | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ {S : Type u_1} [inst : Semiring S] (n : ℕ) (k : S),
Polynomial.eval k (ascPochhammer S (n + 1)) = Polynomial.eval k (ascPochhammer S n) * (k + ↑n) | null | true |
RegularWreathProduct.instGroup._proof_5 | Mathlib.GroupTheory.RegularWreathProduct | ∀ {D : Type u_1} {Q : Type u_2} [inst : Group D] [inst_1 : Group Q] (n : ℕ) (x : D ≀ᵣ Q), x ^ (n + 1) = x ^ n * x | null | false |
ContinuousAt.enorm | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ContinuousENorm E] {X : Type u_8} [inst_2 : TopologicalSpace X]
{f : X → E} {a : X}, ContinuousAt f a → ContinuousAt (fun x => ‖f x‖ₑ) a | null | true |
Multiset.subsingletonEquiv._proof_1 | Mathlib.Data.Multiset.Basic | ∀ (α : Type u_1) [inst : Subsingleton α], Function.LeftInverse (Quot.lift id ⋯) Multiset.ofList | null | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.restrictIsoSpec.eq_1 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ (X : AlgebraicGeometry.Scheme),
AlgebraicGeometry.Scheme.AffineZariskiSite.restrictIsoSpec X =
CategoryTheory.NatIso.ofComponents (fun U => ⋯.isoSpec) ⋯ | null | true |
ULift.seminormedCommRing._proof_20 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (x y : ULift.{u_1, u_2} α), dist x y = ‖-x + y‖ | null | false |
SimpleGraph.Walk.IsTrail.map | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {V' : Type v} {G : SimpleGraph V} {G' : SimpleGraph V'} {f : G →g G'} {u v : V} {p : G.Walk u v},
Function.Injective ⇑f → p.IsTrail → (SimpleGraph.Walk.map f p).IsTrail | **Alias** of the reverse direction of `SimpleGraph.Walk.isTrail_map_iff_of_injective`. | true |
Configuration.HasLines.hasPoints | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} →
[inst : Membership P L] →
[Configuration.HasLines P L] →
[inst_2 : Fintype P] → [inst_3 : Fintype L] → Fintype.card P = Fintype.card L → Configuration.HasPoints P L | If a nondegenerate configuration has a unique line through any two points, and if `|P| = |L|`,
then there is a unique point on any two lines. | true |
Mathlib.Tactic.BicategoryLike.HorizontalComp.tgtM._sunfold | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.HorizontalComp → m Mathlib.Tactic.BicategoryLike.Mor₁ | null | false |
_private.Mathlib.Order.Disjointed.0.partialSups_disjointed.match_1_3 | Mathlib.Order.Disjointed | ∀ {ι : Type u_1} [inst : PartialOrder ι] (i r : ι) (motive : (∃ a < i, r ≤ a) → Prop) (x : ∃ a < i, r ≤ a),
(∀ (a : ι) (ha : a < i ∧ r ≤ a), motive ⋯) → motive x | null | false |
Substring.prev | Init.Data.String.Substring | Substring.Raw → String.Pos.Raw → String.Pos.Raw | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.