name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.Algebra.IsUniformGroup.Basic.0.IsTopologicalGroup.tendstoUniformlyOn_iff.match_1_1 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {G : Type u_1} [inst : Group G] [u : UniformSpace G] [inst_1 : IsTopologicalGroup G] (x : Set (G × G))
(motive : x ∈ uniformity G → Prop) (x_1 : x ∈ uniformity G),
(∀ (u_1 : Set G) (hu : u_1 ∈ nhds 1) (hv : (fun p => p.2 * p.1⁻¹) ⁻¹' u_1 ⊆ x), motive ⋯) → motive x_1 | null | false |
MulOpposite.instAddLeftCancelSemigroup._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : AddLeftCancelSemigroup α] (x x_1 : αᵐᵒᵖ),
MulOpposite.unop (x + x_1) = MulOpposite.unop (x + x_1) | null | false |
Mathlib.CrossRef.Database.rec | Mathlib.Tactic.CrossRefAttribute | {motive : Mathlib.CrossRef.Database → Sort u} →
motive Mathlib.CrossRef.Database.dlmf →
motive Mathlib.CrossRef.Database.kerodon →
motive Mathlib.CrossRef.Database.lmfdb →
((topic : Mathlib.CrossRef.PiBaseTopic) → motive (Mathlib.CrossRef.Database.pibase topic)) →
motive Mathlib.CrossRef.D... | null | false |
List.rotate.eq_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u_1} (l : List α) (n : ℕ),
l.rotate n =
match List.splitAt (n % l.length) l with
| (l₁, l₂) => l₂ ++ l₁ | null | true |
RightCancelMonoid.finite_powers._simp_2 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : RightCancelMonoid G] {a : G}, (↑(Submonoid.powers a)).Finite = IsOfFinOrder a | null | false |
Option.toArray | Init.Data.Option.Basic | {α : Type u_1} → Option α → Array α | Converts an optional value to an array with zero or one element.
Examples:
* `(some "value").toArray = #["value"]`
* `none.toArray = #[]`
| true |
Sigma.curry_uncurry | Mathlib.Data.Sigma.Basic | ∀ {α : Type u_1} {β : α → Type u_4} {γ : (a : α) → β a → Type u_7} (f : (x : α) → (y : β x) → γ x y),
Sigma.curry (Sigma.uncurry f) = f | null | true |
Nat.ceil_add_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R} [IsOrderedAddMonoid R]
[AddLeftStrictMono R], 0 ≤ a → ∀ (n : ℕ) [inst_5 : n.AtLeastTwo], ⌈a + OfNat.ofNat n⌉₊ = ⌈a⌉₊ + OfNat.ofNat n | null | true |
CategoryTheory.Limits.Types.isPushout_of_isPullback_of_mono' | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {X₁ X₂ X₃ X₄ : Type u} {t : X₁ ⟶ X₂} {r : X₂ ⟶ X₄} {l : X₁ ⟶ X₃} {b : X₃ ⟶ X₄},
CategoryTheory.IsPullback t l r b →
∀ [CategoryTheory.Mono r],
Set.range ⇑(CategoryTheory.ConcreteCategory.hom r) ⊔ Set.range ⇑(CategoryTheory.ConcreteCategory.hom b) =
Set.univ →
(∀ (x₃ y₃ : X₃),
... | Consider a pullback square of types where the right map is a monomorphism.
If the right and bottom map are jointly surjective, and the bottom map
is injective on the complement on the range of the left map, then the square
is a pushout square. | true |
WithTop.coe_iInf | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : Preorder α] [Nonempty ι] [inst_2 : InfSet α] {f : ι → α},
BddBelow (Set.range f) → ↑(⨅ i, f i) = ⨅ i, ↑(f i) | null | true |
Std.DHashMap.Raw.get_filterMap | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α] {f : (a : α) → β a → Option (γ a)} {k : α} {h' : k ∈ Std.DHashMap.Raw.filterMap f m}
(h : m.WF), (Std.DHashMap.Raw.filterMap f m).get k h' = (f k (m.get k ⋯)).get ⋯ | null | true |
AlgEquiv.apply_smulCommClass' | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁] {S : Type u_1}
[inst_3 : SMul S R] [inst_4 : SMul S A₁] [IsScalarTower S R A₁], SMulCommClass (A₁ ≃ₐ[R] A₁) S A₁ | null | true |
_private.Mathlib.Algebra.MvPolynomial.Division.0.MvPolynomial.dvd_monomial_mul_iff_exists._simp_1_6 | Mathlib.Algebra.MvPolynomial.Division | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a' = a) = p a' | null | false |
CategoryTheory.ShortComplex.moduleCatOpcyclesIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u_2} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)), S.HasRightHomology | null | false |
PontryaginDual.instDiscreteTopologyOfCompactSpace | Mathlib.Topology.Algebra.PontryaginDual | ∀ {A : Type u_1} [inst : Monoid A] [inst_1 : TopologicalSpace A] [CompactSpace A], DiscreteTopology (PontryaginDual A) | A compact monoid has discrete Pontryagin dual. | true |
CategoryTheory.GradedObject.mapBifunctor_triangle | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {D : Type u_4} {I₁ : Type u_5} {I₂ : Type u_6} {I₃ : Type u_7}
{J : Type u_8} [inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4... | null | true |
NFA.ctorIdx | Mathlib.Computability.NFA | {α : Type u} → {σ : Type v} → NFA α σ → ℕ | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.ExtractAndExtendBitTarget.mk.sizeOf_spec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Cpop | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} {w : ℕ} [inst_2 : SizeOf α] (start : ℕ)
(x : aig.RefVec w), sizeOf { start := start, x := x } = 1 + sizeOf start + sizeOf x | null | true |
_private.Mathlib.RingTheory.Kaehler.Basic.0.KaehlerDifferential.range_kerCotangentToTensor._simp_1_4 | Mathlib.RingTheory.Kaehler.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x | null | false |
Algebra.QuasiFinite.instIsArtinianRingQuotientAtPrimeIdealMapRingHomAlgebraMapOfLiesOver | Mathlib.RingTheory.QuasiFinite.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (p : Ideal R)
(q : Ideal S) [q.LiesOver p] [inst_4 : q.IsPrime] [Algebra.QuasiFinite R S],
IsArtinianRing (Localization.AtPrime q ⧸ Ideal.map (algebraMap R (Localization.AtPrime q)) p) | null | true |
Complex.imLm_coe | Mathlib.LinearAlgebra.Complex.Module | ⇑Complex.imLm = Complex.im | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.structure.parenthesizer_405 | Lean.Parser.Command | IO Unit | null | false |
Batteries.Tactic._aux_Batteries_Tactic_Init___elabRules_Batteries_Tactic_tacticFapply__1 | Batteries.Tactic.Init | Lean.Elab.Tactic.Tactic | `fapply e` is like `apply e` but it adds goals in the order they appear,
rather than putting the dependent goals first.
| false |
IsLocalization.orderIsoOfPrime._proof_3 | Mathlib.RingTheory.Localization.Ideal | ∀ {R : Type u_2} [inst : CommSemiring R] (M : Submonoid R) (S : Type u_1) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] (p : { p // p.IsPrime ∧ Disjoint ↑M ↑p }),
(Ideal.map (algebraMap R S) ↑p).IsPrime | null | false |
PLift._sizeOf_1 | Init.SizeOf | {α : Sort u} → [SizeOf α] → PLift α → ℕ | null | false |
GaloisInsertion.monotoneIntro._proof_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α},
Monotone u → Monotone l → (∀ (a : α), a ≤ u (l a)) → (∀ (b : β), l (u b) = b) → GaloisConnection l u | null | false |
Std.ExtTreeMap.insertIfNew_ne_empty._simp_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β}, (t.insertIfNew k v = ∅) = False | null | false |
Option.pure_apply | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {x : α}, pure x = some x | null | true |
IsUpperSet.disjoint_lowerClosure_right._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s t : Set α}, IsUpperSet s → Disjoint s ↑(lowerClosure t) = Disjoint s t | null | false |
AddMonoid.End.instModule | Mathlib.Algebra.Module.Hom | {R : Type u_1} →
{A : Type u_4} → [inst : Semiring R] → [inst_1 : AddCommMonoid A] → [Module R A] → Module R (AddMonoid.End A) | null | true |
nsmulBinRec | Mathlib.Algebra.Group.Monoid | {M : Type u_2} → [Zero M] → [Add M] → ℕ → M → M | Scalar multiplication by repeated self-addition,
the additive version of exponentiation by repeated squaring. | true |
_private.Std.Data.DHashMap.Internal.AssocList.Basic.0.Std.DHashMap.Internal.AssocList.filterMap.go._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} →
((a : α) → β a → Option (γ a)) →
Std.DHashMap.Internal.AssocList α γ → Std.DHashMap.Internal.AssocList α β → Std.DHashMap.Internal.AssocList α γ | null | false |
Part.eq_get_iff_mem | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α} {a : α} (h : o.Dom), a = o.get h ↔ a ∈ o | null | true |
VectorBundleCore.addCommGroupFiber._proof_21 | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_4} (Z : VectorBundleCore R B F ι) (x : B),
autoParam (∀ (n : ℕ) (a : Z.Fiber x), Int.negSucc n • a = -(↑n.succ • a)) SubNegMonoid.zsm... | null | false |
StructureGroupoid.partialOrder._proof_1 | Mathlib.Geometry.Manifold.StructureGroupoid | ∀ {H : Type u_1} [inst : TopologicalSpace H] (a b : StructureGroupoid H), a.members = b.members → a = b | null | false |
Int16.ofIntLE_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec 16), Int16.ofIntLE n.toInt ⋯ ⋯ = Int16.ofBitVec n | null | true |
MeasureTheory.IntegrableOn.mul_continuousOn_of_subset | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {R : Type u_8} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] {μ : MeasureTheory.Measure X}
[OpensMeasurableSpace X] {A K : Set X} [inst_3 : NormedRing R] [SecondCountableTopologyEither X R] {g g' : X → R},
MeasureTheory.IntegrableOn g A μ →
ContinuousOn g' K → MeasurableSet A → IsCom... | null | true |
IsUltrametricDist.nnnorm_eq_of_mul_nnnorm_lt_max | Mathlib.Analysis.Normed.Group.Ultra | ∀ {S : Type u_1} [inst : SeminormedGroup S] [IsUltrametricDist S] {x y : S}, ‖x * y‖₊ < max ‖x‖₊ ‖y‖₊ → ‖x‖₊ = ‖y‖₊ | null | true |
Std.ExtDTreeMap.size_insertIfNew | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β k}, (t.insertIfNew k v).size = if k ∈ t then t.size else t.size + 1 | null | true |
Eq | Init.Prelude | {α : Sort u_1} → α → α → Prop | The equality relation. It has one introduction rule, `Eq.refl`.
We use `a = b` as notation for `Eq a b`.
A fundamental property of equality is that it is an equivalence relation.
```
variable (α : Type) (a b c d : α)
variable (hab : a = b) (hcb : c = b) (hcd : c = d)
example : a = d :=
Eq.trans (Eq.trans hab (Eq.sym... | true |
Std.TreeSet.min!_erase_eq_of_not_compare_min!_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).isEmpty = false → ¬cmp k t.min! = Ordering.eq → (t.erase k).min! = t.min! | null | true |
MvPowerSeries.commute_X_pow | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (φ : MvPowerSeries σ R) (s : σ) (n : ℕ),
Commute φ (MvPowerSeries.X s ^ n) | null | true |
ProofWidgets.checkRequest | ProofWidgets.Cancellable | ProofWidgets.RequestId → Lean.Server.RequestM (Lean.Server.RequestTask ProofWidgets.CheckRequestResponse) | Check whether a request has finished computing,
and return the response if so.
The request is removed from `runningRequests` the first time it is checked
and found to have finished.
Throws an error if the `rid` is invalid,
or if the request itself threw an error. | true |
AddMonoidHom.liftOfRightInverse | Mathlib.Algebra.Group.Subgroup.Basic | {G₁ : Type u_4} →
{G₂ : Type u_5} →
{G₃ : Type u_6} →
[inst : AddGroup G₁] →
[inst_1 : AddGroup G₂] →
[inst_2 : AddGroup G₃] →
(f : G₁ →+ G₂) → (f_neg : G₂ → G₁) → Function.RightInverse f_neg ⇑f → { g // f.ker ≤ g.ker } ≃ (G₂ →+ G₃) | `liftOfRightInverse f f_inv hf g hg` is the unique additive group homomorphism `φ`
* such that `φ.comp f = g` (`AddMonoidHom.liftOfRightInverse_comp`),
* where `f : G₁ →+ G₂` has a RightInverse `f_inv` (`hf`),
* and `g : G₂ →+ G₃` satisfies `hg : f.ker ≤ g.ker`.
See `AddMonoidHom.eq_liftOfRightInverse` for the uniquene... | true |
Prod.comul_comp_fst | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u) (A : Type v) (B : Type w) [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R A] [inst_4 : Module R B] [inst_5 : Coalgebra R A] [inst_6 : Coalgebra R B],
CoalgebraStruct.comul ∘ₗ LinearMap.fst R A B =
TensorProduct.map (LinearMap.fst R A B) (LinearMap.... | null | true |
MvPowerSeries.trunc'_C_mul | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : DecidableEq σ] [inst_1 : CommSemiring R] (n : σ →₀ ℕ) (a : R)
(p : MvPowerSeries σ R),
(MvPowerSeries.trunc' R n) (MvPowerSeries.C a * p) = MvPolynomial.C a * (MvPowerSeries.trunc' R n) p | null | true |
Ordinal.nfpFamily | Mathlib.SetTheory.Ordinal.FixedPoint | {ι : Type u_1} → (ι → Ordinal.{u} → Ordinal.{u}) → Ordinal.{u} → Ordinal.{u} | The next common fixed point, at least `a`, for a family of normal functions.
This is defined for any family of functions, as the supremum of all values reachable by applying
finitely many functions in the family to `a`.
`Ordinal.nfpFamily_fp` shows this is a fixed point, `Ordinal.le_nfpFamily` shows it's at
least `a`... | true |
_private.Mathlib.CategoryTheory.Sites.Coverage.0.CategoryTheory.Coverage.saturate_iff_saturate_toPrecoverage._proof_1_14 | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (K : CategoryTheory.Coverage C) (X : C),
∀ S ∈ K.coverings X, K.Saturate X (CategoryTheory.Sieve.generate S) | null | false |
Lean.mkApp9 | Lean.Expr | Lean.Expr →
Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr | null | true |
CauSeq.add_equiv_add | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] {f1 f2 g1 g2 : CauSeq β abv},
f1 ≈ f2 → g1 ≈ g2 → f1 + g1 ≈ f2 + g2 | null | true |
MeasureTheory.setIntegral_neg_eq_setIntegral_nonpos | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{μ : MeasureTheory.Measure X} [inst_2 : PartialOrder E] {f : X → E},
MeasureTheory.AEStronglyMeasurable f μ → ∫ (x : X) in {x | f x < 0}, f x ∂μ = ∫ (x : X) in {x | f x ≤ 0}, f x ∂μ | null | true |
Nonneg.unitsEquivPos_apply_coe | Mathlib.Algebra.Order.Nonneg.Field | ∀ (R : Type u_2) [inst : DivisionSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R]
[inst_3 : PosMulReflectLT R] (r : (Nonneg R)ˣ), ↑((Nonneg.unitsEquivPos R) r) = ↑↑r | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Util.0.Lean.Grind.Linarith.Poly.eval?.go._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.Util | Lean.PArray ℚ → ℚ → Lean.Grind.Linarith.Poly → Option ℚ | null | false |
_private.Mathlib.Tactic.Inclusion.Core.Elab.0.Inclusion.collectInclusionArgs._sparseCasesOn_1 | Mathlib.Tactic.Inclusion.Core.Elab | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.Range.Polymorphic.SInt.0.Int32.instLawfulUpwardEnumerable | Init.Data.Range.Polymorphic.SInt | Std.PRange.LawfulUpwardEnumerable Int32 | null | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.State.mk.injEq | Lean.Elab.Tactic.Induction | ∀ (argPos targetPos : ℕ) (motive : Option Lean.MVarId) (f fType : Lean.Expr) (alts : Array Lean.Elab.Tactic.ElimApp.Alt)
(insts : Array Lean.MVarId) (argPos_1 targetPos_1 : ℕ) (motive_1 : Option Lean.MVarId) (f_1 fType_1 : Lean.Expr)
(alts_1 : Array Lean.Elab.Tactic.ElimApp.Alt) (insts_1 : Array Lean.MVarId),
({ ... | null | true |
MeasureTheory.VectorMeasure.integral_smul | Mathlib.MeasureTheory.VectorMeasure.Integral | ∀ {X : Type u_2} {E : Type u_4} {F : Type u_5} {G : Type u_6} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G]
[inst_5 : NormedSpace ℝ G] (f : X → E) (μ : MeasureTheory.VectorMeasure X F) (B :... | null | true |
Int.Internal.Linear.Poly._sizeOf_inst | Init.Data.Int.Linear | SizeOf Int.Internal.Linear.Poly | null | false |
Polynomial.ofFinsupp | Mathlib.Algebra.Polynomial.Basic | {R : Type u_1} → [inst : Semiring R] → AddMonoidAlgebra R ℕ → Polynomial R | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne.0.SimplexCategory.δ_comp_toMk₁_of_le._proof_1_2 | Mathlib.AlgebraicTopology.SimplexCategory.ToMkOne | ∀ {n : ℕ} (j i : Fin (n + 2)),
i ≤ j →
∀ (k : Fin ({ len := n }.len + 1)),
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.toMk₁ i.castSucc)) (j.succAbove k) =
(CategoryTheory.ConcreteCategory.hom (SimplexCategory.toMk₁ i)) k | null | false |
_private.Mathlib.Combinatorics.Additive.CauchyDavenport.0.DevosAddRel | Mathlib.Combinatorics.Additive.CauchyDavenport | {α : Type u_2} → [AddGroup α] → [DecidableEq α] → Finset α × Finset α → Finset α × Finset α → Prop | The relation we induct along in the proof by DeVos of the Cauchy-Davenport theorem.
`(s₁, t₁) < (s₂, t₂)` iff
* `|s₁ + t₁| < |s₂ + t₂|`
* or `|s₁ + t₁| = |s₂ + t₂|` and `|s₂| + |t₂| < |s₁| + |t₁|`
* or `|s₁ + t₁| = |s₂ + t₂|` and `|s₁| + |t₁| = |s₂| + |t₂|` and `|s₁| < |s₂|`. | true |
PartialOrder.OfStdArgs.mk.sizeOf_spec | Mathlib.Order.Std | ∀ {α : Type u_1} [inst : SizeOf α] (toPreorderArgs : Preorder.OfStdArgs α)
(isPartialOrder :
autoParam
(let this := toPreorderArgs.le;
Std.IsPartialOrder α)
PartialOrder.OfStdArgs.isPartialOrder._autoParam),
sizeOf { toPreorderArgs := toPreorderArgs, isPartialOrder := isPartialOrder } =
1 ... | null | true |
AlgebraicGeometry.Scheme.descResidueField_fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | ∀ {K : Type u_1} [inst : Field K] (X : AlgebraicGeometry.Scheme) {x : ↥X} (f : X.presheaf.stalk x ⟶ ↧K)
[inst_1 : IsLocalHom (CommRingCat.Hom.hom f)],
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Spec.map (AlgebraicGeometry.Scheme.descResidueField f))
(X.fromSpecResidueField x) =
CategoryTheory.C... | null | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.HasFiniteIntegral.tendsto_setIntegral_nhds_zero._simp_1_3 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_2} {f : Filter α} {m : α → NNReal} {x : NNReal},
Filter.Tendsto (fun a => ↑(m a)) f (nhds ↑x) = Filter.Tendsto m f (nhds x) | null | false |
MeromorphicOn.divisor_ball_comp_sub_const_eq_divisor_ball | Mathlib.Analysis.Meromorphic.Divisor | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {z : 𝕜} {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {c : 𝕜} {R : ℝ} {f : 𝕜 → E},
(MeromorphicOn.divisor (f ∘ fun x => x - c) (Metric.ball c R)) (z + c) = (MeromorphicOn.divisor f (Metric.ball 0 R)) z | Divisors are invariant under translation, special case where the set is a ball.. | true |
Std.Tactic.BVDecide.BVExpr.WithCache.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | Sort u_1 →
{α : Type u} →
{aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
Std.Tactic.BVDecide.BVExpr.WithCache α aig →
{α' : Type u} →
{aig' : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} → Std.Tactic.BVDecide.BVExpr.WithCache α' aig' → Sort u_1 | null | false |
Nat.dvd_ofDigits_sub_ofDigits | Mathlib.Data.Nat.Digits.Lemmas | ∀ {α : Type u_1} [inst : CommRing α] {a b k : α}, k ∣ a - b → ∀ (L : List ℕ), k ∣ Nat.ofDigits a L - Nat.ofDigits b L | null | true |
TestFunction.instT3Space | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_4}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞}, T3Space (TestFunction Ω F n) | null | true |
_private.Lean.Parser.Extension.0.Lean.Parser.mkInputContext._proof_1 | Lean.Parser.Extension | ∀ (input : String) (normalizeLineEndings : Bool) (endPos : String.Pos.Raw),
(if normalizeLineEndings = true then
(Lean.FileMap.ofString (Lean.FileMap.ofString input).source.crlfToLf,
(Lean.FileMap.ofString (Lean.FileMap.ofString input).source.crlfToLf).ofPosition
((Lean.FileM... | null | false |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageXIso | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | {C : Type u_1} →
{ι : Type u_2} →
{κ : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : Preorder ι] →
(X : CategoryTheory.Abelian.SpectralObject C ι) →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →... | The object on position `pq` on the `r`th page of the spectral sequence identifies
to `E^{deg pq}(i₀ ≤ i₁ ≤ i₂ ≤ i₃)`. | true |
Std.Http.Method.versionControl | Std.Http.Data.Method | Std.Http.Method | Put a resource under version control.
Source: https://www.rfc-editor.org/rfc/rfc3253#section-3.5
| true |
Mathlib.Tactic.ClickSuggestions.RwLemma.mk.sizeOf_spec | Mathlib.Tactic.ClickSuggestions.Rewrite | ∀ (name : Mathlib.Tactic.ClickSuggestions.Premise) (symm : Bool),
sizeOf { name := name, symm := symm } = 1 + sizeOf name + sizeOf symm | null | true |
Finsupp.optionElim_some | Mathlib.Data.Finsupp.Option | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (f : Option α →₀ M), Finsupp.optionElim (f none) f.some = f | null | true |
Std.Slice.Internal.ListSliceData.list | Init.Data.Slice.List.Basic | {α : Type u} → Std.Slice.Internal.ListSliceData α → List α | The relevant suffix of the underlying list. | true |
_private.Mathlib.Combinatorics.Enumerative.Catalan.Basic.0.gosper_trick._simp_1_5 | Mathlib.Combinatorics.Enumerative.Catalan.Basic | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
_private.Mathlib.RingTheory.SimpleRing.DivisionRing.0.isSimpleModule_iff_eq_zero_or_injective._simp_1_3 | Mathlib.RingTheory.SimpleRing.DivisionRing | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p q : Submodule R M},
(p = q) = ∀ (x : M), x ∈ p ↔ x ∈ q | null | false |
Fin.map_rev_find? | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {p : Fin n → Bool}, Option.map Fin.rev (Fin.find? fun x => p x.rev) = Fin.findRev? p | null | true |
CategoryTheory.Functor.fullSubcategoryInclusion_additive | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(Z : CategoryTheory.ObjectProperty C), Z.ι.Additive | null | true |
CategoryTheory.Closed.rec | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
{motive : CategoryTheory.Closed X → Sort u_1} →
((rightAdj : CategoryTheory.Functor C C) →
(adj : CategoryTheory.MonoidalCategory.tensorLeft X ⊣ rightAdj) →
... | null | false |
Lean.Parser.instInhabitedPrattParsingTables | Lean.Parser.Basic | Inhabited Lean.Parser.PrattParsingTables | null | true |
Mathlib.Meta.Positivity.evalMap | Mathlib.Tactic.Positivity.Basic | Mathlib.Meta.Positivity.PositivityExt | Extension for the `positivity` tactic: nonnegative maps take nonnegative values. | true |
YoungDiagram.transpose_mono | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ ≤ ν → μ.transpose ≤ ν.transpose | null | true |
_private.Mathlib.AlgebraicTopology.Quasicategory.Basic.0.SSet.Quasicategory.hornFilling._proof_1_4 | Mathlib.AlgebraicTopology.Quasicategory.Basic | ∀ {S : SSet} (i : Fin (0 + 1)),
0 < i →
∀ (σ₀ : (SSet.horn 0 i).toSSet ⟶ S),
∃ σ, σ₀ = CategoryTheory.CategoryStruct.comp (CategoryTheory.Subfunctor.ι (SSet.horn 0 i)) σ | null | false |
Std.DHashMap.instEmptyCollection | Std.Data.DHashMap.Basic | {α : Type u} → {β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → EmptyCollection (Std.DHashMap α β) | null | true |
List.findSome?.match_1 | Init.Data.List.Basic | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → ((b : β) → motive (some b)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.lambdaTelescopeReduce._unsafe_rec | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | {m : Type → Type u_1} →
{α : Type} →
[Nonempty (m α)] →
[Monad m] →
[MonadLiftT Lean.MetaM m] →
[MonadControlT Lean.MetaM m] →
Lean.Expr → List Lean.FVarId → (List Lean.FVarId → m α) → (Lean.Expr → List Lean.FVarId → m α) → m α | null | false |
Dyadic.toReal_lt_toReal | Mathlib.Data.Dyadic | ∀ {a b : Dyadic}, a.toReal < b.toReal ↔ a < b | null | true |
CategoryTheory.Functor.LeftLinear.δₗ_comp_μₗ_assoc | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | ∀ {D : Type u_1} {D' : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} D}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} (F : CategoryTheory.Functor D D') {C : Type u_3}
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} {inst_3 : CategoryTheory.MonoidalCategory C}
{inst_4 : CategoryTheory.MonoidalCategory.Mo... | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.D2_inv._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a = -b) = (a + b = 0) | null | false |
CategoryTheory.Limits.Multicofork.fst_app_right | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
{I : CategoryTheory.Limits.MultispanIndex J C} (K : CategoryTheory.Limits.Multicofork I) (a : J.L),
K.ι.app (CategoryTheory.Limits.WalkingMultispan.left a) = CategoryTheory.CategoryStruct.comp (I.fst a) (K.π (J.fst a... | null | true |
Submodule.instModuleQuotientIdealSpanSingletonSetSubtypeMemTorsionBy | Mathlib.Algebra.Module.Torsion.Basic | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] → (a : R) → Module (R ⧸ Ideal.span {a}) ↥(Submodule.torsionBy R M a) | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD_eq._proof_1_2 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (pq : κ) (n₂ n₃ : ℤ),
n₂ + 1 = n₃ → data.deg pq + 1 = n₂ → n₂ = data.deg pq + 1 | null | false |
CategoryTheory.IsConnected.recOn | Mathlib.CategoryTheory.IsConnected | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{motive : CategoryTheory.IsConnected J → Sort u} →
(t : CategoryTheory.IsConnected J) →
([toIsPreconnected : CategoryTheory.IsPreconnected J] → [is_nonempty : Nonempty J] → motive ⋯) → motive t | null | false |
ClosedSubgroup.instSemilatticeInfClosedSubgroup.eq_1 | Mathlib.Topology.Algebra.Group.ClosedSubgroup | ∀ (G : Type u) [inst : Group G] [inst_1 : TopologicalSpace G],
ClosedSubgroup.instSemilatticeInfClosedSubgroup G = Function.Injective.semilatticeInf SetLike.coe ⋯ ⋯ ⋯ ⋯ | null | true |
Lean.Lsp.CallHierarchyPrepareParams._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.CallHierarchyPrepareParams | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.IsIndex.eq_of_isType₂_δ._proof_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {u : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N},
NeZero (u.dim + 1) | null | false |
DirectSum.sigmaCurryEquiv._proof_1 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type u_3} [inst : DecidableEq ι] {α : ι → Type u_2} {δ : (i : ι) → α i → Type u_1}
[inst_1 : (i : ι) → (j : α i) → AddCommMonoid (δ i j)],
Function.LeftInverse DFinsupp.sigmaCurryEquiv.invFun DFinsupp.sigmaCurryEquiv.toFun | null | false |
ContinuousWithinAt.inf' | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} {X : Type u_2} [inst : TopologicalSpace L] [inst_1 : TopologicalSpace X] [inst_2 : Min L]
[ContinuousInf L] {f g : X → L} {s : Set X} {x : X},
ContinuousWithinAt f s x → ContinuousWithinAt g s x → ContinuousWithinAt (f ⊓ g) s x | null | true |
_private.Mathlib.RingTheory.Support.0.Module.notMem_support_iff'._simp_1_3 | Mathlib.RingTheory.Support | ∀ {M : Type u_1} [inst : MulOneClass M] {s : Subsemigroup M} {x : M} (h_one : 1 ∈ s.carrier),
(x ∈ { toSubsemigroup := s, one_mem' := h_one }) = (x ∈ s) | null | false |
AlgCat.coe_of | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u) [inst : CommRing R] (X : Type v) [inst_1 : Ring X] [inst_2 : Algebra R X], ↑↧X = X | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.