name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.findM?'.match_1 | Mathlib.Data.List.Defs | (motive : ULift.{u_1, 0} Bool → Sort u_2) →
(__discr : ULift.{u_1, 0} Bool) → ((px : Bool) → motive { down := px }) → motive __discr | null | false |
CategoryTheory.Limits.PreservesPullback.iso.eq_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | null | true |
SeqCompactSpace.tendsto_subseq | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] [SeqCompactSpace X] (x : ℕ → X),
∃ a φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (nhds a) | null | true |
Lean.Meta.LazyDiscrTree.patternPath | Lean.Meta.LazyDiscrTree | Lean.Expr → Lean.MetaM (Array Lean.Meta.LazyDiscrTree.Key) | Create a key path from an expression using the function used for patterns.
This differs from Lean.Meta.DiscrTree.mkPath and targetPath in that the expression
should uses free variables rather than meta-variables for holes.
| true |
Lean.Grind.Field.IsOrdered.mul_lt_mul_iff_of_pos_left | Init.Grind.Ordered.Field | ∀ {R : Type u} [inst : Lean.Grind.Field R] [inst_1 : LE R] [inst_2 : LT R] [Std.LawfulOrderLT R]
[inst_4 : Std.IsLinearOrder R] [Lean.Grind.OrderedRing R] {a b c : R}, 0 < c → (c * a < c * b ↔ a < b) | null | true |
Substring.Raw.ValidFor.atEnd | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {p : ℕ} {s : Substring.Raw},
Substring.Raw.ValidFor l m r s → (s.atEnd { byteIdx := p } = true ↔ p = String.utf8Len m) | null | true |
_private.Mathlib.GroupTheory.OrderOfElement.0.isMulTorsionFree_iff_not_isOfFinOrder._simp_1_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α) (n : ℕ), a ^ n / b ^ n = (a / b) ^ n | null | false |
List.Vector.scanl.eq_1 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} {β : Type u_6} (f : β → α → β) (b : β) (v : List.Vector α n),
List.Vector.scanl f b v = ⟨List.scanl f b v.toList, ⋯⟩ | null | true |
CategoryTheory.MonoidalLinear.casesOn | Mathlib.CategoryTheory.Monoidal.Linear | {R : Type u_1} →
[inst : Semiring R] →
{C : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_2} C] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Linear R C] →
[inst_4 : CategoryTheory.MonoidalCategory C] →
[inst_5 : CategoryTheory.Monoi... | null | false |
MeasureTheory.OuterMeasure.isCaratheodory_disjointed | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {ι : Type u_1} [inst : Preorder ι] [inst_1 : LocallyFiniteOrderBot ι]
{s : ι → Set α}, (∀ (i : ι), m.IsCaratheodory (s i)) → ∀ (i : ι), m.IsCaratheodory (disjointed s i) | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.X_eq_of_equiv._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 1 = u ^ 3 * P 1 | null | false |
Std.ExtDTreeMap.Const.size_alter_eq_add_one | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : Option β → Option β},
k ∉ t → (f (Std.ExtDTreeMap.Const.get? t k)).isSome = true → (Std.ExtDTreeMap.Const.alter t k f).size = t.size + 1 | null | true |
instSelfSliceSubarrayDataSubarray | Init.Data.Array.Subarray | ∀ {α : Type u}, Std.Slice.Self (Std.Slice (Std.Slice.Internal.SubarrayData α)) (Subarray α) | null | true |
inseparable_iff_forall_isOpen | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y ↔ ∀ (s : Set X), IsOpen s → (x ∈ s ↔ y ∈ s) | null | true |
PowerSeries.invUnitsSub_mul_X | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ {R : Type u_1} [inst : Ring R] (u : Rˣ),
PowerSeries.invUnitsSub u * PowerSeries.X = PowerSeries.invUnitsSub u * PowerSeries.C ↑u - 1 | null | true |
norm_div | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_2} [inst : NormedDivisionRing α] (a b : α), ‖a / b‖ = ‖a‖ / ‖b‖ | null | true |
TietzeExtension.of_homeo | Mathlib.Topology.TietzeExtension | ∀ {Y : Type v} {Z : Type w} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z] [TietzeExtension Z] (e : Y ≃ₜ Z),
TietzeExtension Y | Any homeomorphism from a `TietzeExtension` space is one itself. | true |
Polynomial.X_pow_sub_one_splits | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {n : ℕ}, IsPrimitiveRoot ζ n → (Polynomial.X ^ n - Polynomial.C 1).Splits | If there is a primitive `n`-th root of unity in `K`, then `X ^ n - 1` splits. | true |
CategoryTheory.Limits.Cotrident.mkHom._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J]
{s t : CategoryTheory.Limits.Cotrident f} (k : s.pt ⟶ t.pt),
CategoryTheory.CategoryStruct.comp s.π k = t.π →
∀ (j : CategoryTheory.Limits.WalkingParallelFamily J), CategoryTheory.CategoryStruc... | null | false |
derivWithin_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (Function.const 𝕜 c) s = 0 | null | true |
CochainComplex.mappingCone.inr_fst_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{d e f : ℤ} (γ : CochainComplex.HomComplex.Cochain F K d) (he : 1 + d = e) (hf : 0 + e = f),
(Coch... | null | true |
CategoryTheory.Comonad.ComonadicityInternal.main_pair_coreflexive | Mathlib.CategoryTheory.Monad.Comonadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (A : adj.toComonad.Coalgebra),
CategoryTheory.IsCoreflexivePair (G.map A.a) (adj.unit.app (G.obj A.A)) | The "main pair" for a coalgebra `(A, α)` is the pair of morphisms `(G α, η_GA)`. It is always a
coreflexive pair, and will be used to construct the left adjoint to the comparison functor and show
it is an equivalence.
| true |
Lean.Elab.Tactic.Grind.SimpCacheKey._sizeOf_inst | Lean.Elab.Tactic.Grind.Basic | SizeOf Lean.Elab.Tactic.Grind.SimpCacheKey | null | false |
Batteries.Tactic.Lint.LintVerbosity.low.elim | Batteries.Tactic.Lint.Frontend | {motive : Batteries.Tactic.Lint.LintVerbosity → Sort u} →
(t : Batteries.Tactic.Lint.LintVerbosity) → t.ctorIdx = 0 → motive Batteries.Tactic.Lint.LintVerbosity.low → motive t | null | false |
_private.Lean.Meta.Sym.Simp.Discharger.0.Lean.Meta.Sym.Simp.resultToDischargeResult.match_1 | Lean.Meta.Sym.Simp.Discharger | (motive : Lean.Meta.Sym.Simp.Result → Sort u_1) →
(result : Lean.Meta.Sym.Simp.Result) →
((done cd : Bool) → motive (Lean.Meta.Sym.Simp.Result.rfl done cd)) →
((e' h : Lean.Expr) → (done cd : Bool) → motive (Lean.Meta.Sym.Simp.Result.step e' h done cd)) → motive result | null | false |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe._proof_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X), Topology.IsOpenEmbedding Subtype.val | null | false |
finsum_mem_def | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M),
∑ᶠ (a : α) (_ : a ∈ s), f a = ∑ᶠ (a : α), s.indicator f a | null | true |
Finset.prod_mulIndicator_eq_prod_inter | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq ι] (s t : Finset ι) (f : ι → β),
∏ i ∈ s, (↑t).mulIndicator f i = ∏ i ∈ s ∩ t, f i | null | true |
Equiv.Perm.sigmaCongrRightHom | Mathlib.Algebra.Group.End | {α : Type u_7} → (β : α → Type u_8) → ((a : α) → Equiv.Perm (β a)) →* Equiv.Perm ((a : α) × β a) | `Equiv.Perm.sigmaCongrRight` as a `MonoidHom`.
This is particularly useful for its `MonoidHom.range` projection, which is the subgroup of
permutations which do not exchange elements between fibers. | true |
ContMDiffMap.coeFnAlgHom._proof_7 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_5} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {N : Type u_2}
[inst_4 : TopologicalSpace N] [inst_5 : ChartedSpace H N] {n : WithTop ℕ∞} {A : Type u_1} [inst_6... | null | false |
TensorPower.toTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {n : ℕ} → TensorPower R n M →ₗ[R] TensorAlgebra R M | The canonical embedding from a tensor power to the tensor algebra | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter.0.SimplexCategory.δ₀Iter_σ._proof_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ}, n + (i + 1) = m + 1 → ∀ (k : Fin ({ len := n }.len + 1)), i + ↑k + 1 < m + 1 + 1 | null | false |
Lean.Lsp.CodeActionTriggerKind | Lean.Data.Lsp.CodeActions | Type | null | true |
StrictAntiOn.antitoneOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictAntiOn f s → AntitoneOn f s | null | true |
instOrOpInt64 | Init.Data.SInt.Basic | OrOp Int64 | null | true |
Submodule.map_iInf | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [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 σ₁₂] {ι : Sort u_9} [Nonempty ι] {p : ι → Submodule R M} (f : M... | null | true |
TensorialAt.add | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : 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] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | null | true |
StarSubalgebra.subtype._proof_6 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A) (x : ↥S),
↑(star x) = ↑(star x) | null | false |
Matrix.toSquareBlockProp | Mathlib.Data.Matrix.Block | {m : Type u_2} → {α : Type u_12} → Matrix m m α → (p : m → Prop) → Matrix { a // p a } { a // p a } α | Let `p` pick out certain rows and columns of a square matrix `M`. Then
`toSquareBlockProp M p` is the corresponding block matrix. | true |
CategoryTheory.IsFiltered.of_right_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor D C} {R : CategoryTheory.Functor C D}
(h : L ⊣ R), CategoryTheory.IsFiltered D | If `C` is filtered, and we have a functor `R : C ⥤ D` with a left adjoint, then `D` is filtered.
| true |
AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | CategoryTheory.Functor AlgebraicGeometry.LocallyRingedSpace (AlgebraicGeometry.SheafedSpace CommRingCat) | The forgetful functor from `LocallyRingedSpace` to `SheafedSpace CommRing`. | true |
VectorBundle.continuousLinearEquivAt | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
(F : Type u_3) →
(E : B → Type u_4) →
[inst : NontriviallyNormedField R] →
[inst_1 : (x : B) → AddCommMonoid (E x)] →
[inst_2 : (x : B) → Module R (E x)] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace R ... | A continuous linear equivalence between the fiber at `b` and the model fiber,
induced by the preferred trivialisation at each `b`. | true |
Lean.Elab.Do.ControlStack.restoreCont | Lean.Elab.Do.Control | Lean.Elab.Do.ControlStack → Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont | null | true |
instAssociativeMax_mathlib | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α], Std.Associative fun x1 x2 => x1 ⊔ x2 | null | true |
Lean.Parser.Command.declModifiers | Lean.Parser.Command | Bool → Lean.Parser.Parser | `declModifiers` is the collection of modifiers on a declaration:
* a doc comment `/-- ... -/`
* a list of attributes `@[attr1, attr2]`
* a visibility specifier, `private` or `public`
* `protected`
* `noncomputable`
* `unsafe`
* `partial` or `nonrec`
All modifiers are optional, and have to come in the listed order.
`n... | true |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Free___macroRules__private_Mathlib_CategoryTheory_Bicategory_Free_0_CategoryTheory_FreeBicategory_termλ__1» | Mathlib.CategoryTheory.Bicategory.Free | Lean.Macro | null | false |
_private.Mathlib.Data.Finset.Powerset.0.Finset.pairwiseDisjoint_pair_insert._simp_1_3 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
_private.Mathlib.Data.Finset.Sum.0.Finset.disjSum_subset._simp_1_1 | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
CategoryTheory.CategoryOfElements.toStructuredArrow._proof_1 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1))
{X Y : F.Elements} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.mk (TypeCat.ofHom fun x => X.snd)).hom (F.map ↑f) =
(CategoryTheory.StructuredArrow.mk (TypeCat.ofHom fun x ... | null | false |
CategoryTheory.Functor.splitMonoEquiv._proof_4 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[inst_2 : F.Full] [inst_3 : F.Faithful],
Function.LeftInverse (fun s => { retraction := F.preimage s.retraction, id := ⋯ }) fun f_1 =... | null | false |
AddCommGroup.modEq_iff_toIcoDiv_eq_toIocDiv_add_one | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) {a b : α}, a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b + 1 | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.opEquiv.match_15.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (x y : CategoryTheory.WithTerminal Cᵒᵖ) → (x ⟶ y) → Sort u_3)
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star)
(h_1 :
(x y : C) →
(f : CategoryTheory.WithTerminal.of (Opposite.op x) ⟶ CategoryTheory.WithTer... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {newWidth : ℕ}, 0 ≤ newWidth | null | false |
SetLike.smul_subset_self | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {S : Type u_1} {R : Type u_2} {M : Type u_3} [inst : SetLike S M] [inst_1 : SMul R M] [SMulMemClass S R M] (r : R)
(s : S), r • ↑s ⊆ ↑s | null | true |
Std.Iterators.Types.StepSizeIterator.instProductive | Std.Data.Iterators.Combinators.Monadic.StepSize | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] [inst_1 : Std.IteratorAccess α m]
[inst_2 : Monad m] [Std.Iterators.Productive α m],
Std.Iterators.Productive (Std.Iterators.Types.StepSizeIterator α m β) m | null | true |
ContDiffWithinAt.ccosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E}
{n : WithTop ℕ∞}, ContDiffWithinAt ℂ n f s x → ContDiffWithinAt ℂ n (fun x => Complex.cosh (f x)) s x | null | true |
MultilinearMap.uncurry_curryLeft | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂),
f.curryLeft.uncurryLeft = f | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.reduceMod.declare_46._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.3686920086._hygCtx._hyg.19 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | null | false |
Std.TreeSet.minD_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
(t.insert k).minD fallback = t.min?.elim k fun k' => if cmp k k' = Ordering.lt then k else k' | null | true |
StarAlgEquiv.mk.inj | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {inst : Add A} {inst_1 : Add B} {inst_2 : Mul A} {inst_3 : Mul B}
{inst_4 : SMul R A} {inst_5 : SMul R B} {inst_6 : Star A} {inst_7 : Star B} {toStarRingEquiv : A ≃⋆+* B}
{map_smul' : ∀ (r : R) (a : A), toStarRingEquiv.toFun (r • a) = r • toStarRingEquiv.toFun a}
{to... | null | true |
Std.Http.Header.instBEqValue | Std.Http.Data.Headers.Value | BEq Std.Http.Header.Value | null | true |
_private.Mathlib.RingTheory.Flat.EquationalCriterion.0.Module.Flat.exists_factorization_of_finitePresentation.match_1_1 | Mathlib.RingTheory.Flat.EquationalCriterion | ∀ {R : Type u_1} [inst : CommRing R] {P : Type u_2} [inst_1 : AddCommGroup P] [inst_2 : Module R P]
(motive : (∃ n K x, K.FG) → Prop) (x : ∃ n K x, K.FG),
(∀ (w : ℕ) (K : Submodule R (Fin w → R)) (ϕ : P ≃ₗ[R] (Fin w → R) ⧸ K) (hK : K.FG), motive ⋯) → motive x | null | false |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.not_summable_residueClass_prime_div._simp_1_2 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) | null | false |
Std.Format.FlattenBehavior.fill.sizeOf_spec | Init.Data.Format.Basic | sizeOf Std.Format.FlattenBehavior.fill = 1 | null | true |
Polynomial.eval_sumIDeriv_of_pos | Mathlib.Algebra.Polynomial.SumIteratedDerivative | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R] [NoZeroDivisors R] (p : Polynomial R) {q : ℕ},
0 < q →
∃ gp,
gp.natDegree ≤ p.natDegree - q ∧
∀ (r : R) {p' : Polynomial R},
p = (Polynomial.X - Polynomial.C r) ^ (q - 1) * p' →
Polynomial.eval r (Polynomial.sumIDeriv p) =
... | null | true |
List.isChain_range | Mathlib.Data.List.Range | ∀ (r : ℕ → ℕ → Prop) (n : ℕ), List.IsChain r (List.range n) ↔ ∀ m < n - 1, r m m.succ | null | true |
CategoryTheory.GradedObject.comapEq_trans | Mathlib.CategoryTheory.GradedObject | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {β γ : Type w} {f g h : β → γ} (k : f = g) (l : g = h),
CategoryTheory.GradedObject.comapEq C ⋯ =
CategoryTheory.GradedObject.comapEq C k ≪≫ CategoryTheory.GradedObject.comapEq C l | null | true |
Lean.Doc.Inline.footnote.noConfusion | Lean.DocString.Types | {i : Type u} →
{P : Sort u_1} →
{name : String} →
{content : Array (Lean.Doc.Inline i)} →
{name' : String} →
{content' : Array (Lean.Doc.Inline i)} →
Lean.Doc.Inline.footnote name content = Lean.Doc.Inline.footnote name' content' →
(name = name' → content ≍ conten... | null | false |
isScalarTower_closedBall_closedBall_closedBall | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜' E] {r : ℝ}
[inst_5 : NormedAlgebra 𝕜 𝕜'] [IsScalarTower 𝕜 𝕜' E],
IsScalarTower ↑(Metric.closedBall 0 1) ↑(Metric.closed... | null | true |
Lean.Grind.Linarith.imp_eq_cert | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Var → Lean.Grind.Linarith.Var → Bool | null | true |
ExistsAndEq.withExistsElimAlongPath | Mathlib.Tactic.Simproc.ExistsAndEq | {u : Lean.Level} →
{α : Q(Sort u)} →
{P goal : Q(Prop)} →
Q(«$P») →
{a a' : Q(«$α»)} →
List ExistsAndEq.VarQ →
ExistsAndEq.Path → (Q(«$a» = «$a'») → List ExistsAndEq.HypQ → Lean.MetaM Q(«$goal»)) → Lean.MetaM Q(«$goal») | Given `act : (a = a') → hb₁ → hb₂ → ... → hbₙ → goal` where `hb₁, ..., hbₙ` are hypotheses
obtained when unpacking existential quantifiers with variables from `exs`, it proves `goal` using
`Exists.elim`. We use this to prove implication in the forward direction. | true |
ProbabilityTheory.gaussianPDFReal_mul | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {c : ℝ},
c ≠ 0 →
∀ (x : ℝ),
ProbabilityTheory.gaussianPDFReal μ v (c * x) =
|c⁻¹| * ProbabilityTheory.gaussianPDFReal (c⁻¹ * μ) (NNReal.mk (c ^ 2)⁻¹ ⋯ * v) x | null | true |
HasFibers.inducedMap_comp_assoc | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} [inst_2 : HasFibers p] {R S : 𝒮} {a : 𝒳} {b b' : HasFibers.Fib p R} (f : R ⟶ S)
(ψ : (HasFibers.ι R).obj b' ⟶ a) [inst_3 : p.IsCartesian f ψ] (φ : (HasFibe... | null | true |
CategoryTheory.CommGrp.instCategory._proof_9 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {W X Y Z : CategoryTheory.CommGrp C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Catego... | null | false |
Ideal.IsTwoSided.mk | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, (∀ {a : α} (b : α), a ∈ I → a * b ∈ I) → I.IsTwoSided | null | true |
RestrictedProduct.mapAlongMonoidHom._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι₁ : Type u_4} {ι₂ : Type u_1} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_2) {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂}
{S₁ : ι₁ → Type u_6} {S₂ : ι₂ → Type u_3} [inst : (i : ι₁) → SetLike (S₁ i) (R₁ i)]
[inst_1 : (j : ι₂) → SetLike (S₂ j) (R₂ j)] {B₁ : (i : ι₁) → S₁ i} {B₂ : (j : ι₂) → S₂ j} (f : ι₂ → ι₁)
(hf : Filter.T... | null | false |
Unitization.instRing._proof_7 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a : Unitization R A), -a + a = 0 | null | false |
AddUnits.neg_nsmul_eq_nsmul_neg | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) (n : ℕ), ↑(-(n • a)) = n • ↑(-a) | null | true |
OreLocalization.oreDivSMulChar'.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : MulAction R X] (r₁ : R) (r₂ : X) (s₁ s₂ : ↥S),
OreLocalization.oreDivSMulChar' r₁ r₂ s₁ s₂ = ⟨OreLocalization.oreNum r₁ s₂, ⟨OreLocalization.oreDenom r₁ s₂, ⋯⟩⟩ | null | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_X₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
CategoryTheory.Limits.MonoFactorisation.ext | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
{F F' : CategoryTheory.Limits.MonoFactorisation f} (hI : F.I = F'.I),
F.m = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom hI) F'.m → F = F' | The morphism `m` in a factorisation `f = e ≫ m` through a monomorphism is uniquely
determined. | true |
_private.Mathlib.Topology.MetricSpace.GromovHausdorffRealized.0.GromovHausdorff.candidates_le_maxVar | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ {X : Type u} {Y : Type v} [inst : MetricSpace X] [inst_1 : MetricSpace Y] {f : GromovHausdorff.ProdSpaceFun✝ X Y}
{x y : X ⊕ Y}, f ∈ GromovHausdorff.candidates X Y → f (x, y) ≤ ↑(GromovHausdorff.maxVar✝ X Y) | null | true |
Lean.Elab.Tactic.ElabSimpArgsResult | Lean.Elab.Tactic.Simp | Type | The result of elaborating a full array of simp arguments and applying them to the simp context.
| true |
AffineSubspace.wSameSide_vadd_right_iff | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y : P} {v : V}, v ∈ s.direction → (s.WSameSide x (v +ᵥ y) ↔ s.WSameSide x y) | null | true |
Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef.mk._flat_ctor | Lean.Meta.LazyDiscrTree | {α : Type} → IO.Ref (Lean.Meta.LazyDiscrTree α) → Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef α | null | false |
CategoryTheory.evaluationAdjunctionLeft | Mathlib.CategoryTheory.Adjunction.Evaluation | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] →
(c : C) → (CategoryTheory.evaluation C D).obj c ⊣ CategoryTheory.evaluationRightAdjoint... | The adjunction showing that evaluation is a left adjoint. | true |
MvPolynomial.zeroLocus_bot | Mathlib.RingTheory.Nullstellensatz | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Type u_3},
MvPolynomial.zeroLocus K ⊥ = ⊤ | null | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.GRewriteLemma.apply.match_1 | Mathlib.Tactic.GRewrite.Core | (motive : DoResultPR Lean.Expr Bool PUnit.{1} → Sort u_1) →
(r : DoResultPR Lean.Expr Bool PUnit.{1}) →
((a : Lean.Expr) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
((b : Bool) → (u : PUnit.{1}) → motive (DoResultPR.return b u)) → motive r | null | false |
CategoryTheory.Limits.CatCospanTransform.comp_whiskerLeft_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | true |
Nat.div_left_inj._simp_1 | Init.Data.Nat.Lemmas | ∀ {a b d : ℕ}, d ∣ a → d ∣ b → (a / d = b / d) = (a = b) | null | false |
RingCon.subsingleton_iff | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R], Subsingleton (RingCon R) ↔ Subsingleton R | null | true |
Filter.biInter_finset_mem | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} (is : Finset β), ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f | null | true |
Lean.findModuleOf? | Lean.MonadEnv | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [Lean.MonadError m] → Lean.Name → m (Option Lean.Name) | null | true |
CategoryTheory.ComposableArrows.natAddLEFunctor_obj'._proof_4 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n k l i : ℕ}, k + l ≤ n → autoParam (i ≤ l) CategoryTheory.ComposableArrows.natAddLEFunctor_obj'._auto_1 → k + i ≤ n | null | false |
CompleteBooleanAlgebra.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
[toCompleteLattice : CompleteLattice α] →
(∀ (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z) →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
(∀ (x : α), x ⊓ xᶜ ≤ ⊥) →
(∀ (x : α), ⊤ ≤ x ⊔ xᶜ) →
autoParam (∀ (x y : α), ... | null | true |
Graded.equiv | Mathlib.Data.FunLike.Graded | {E : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : EquivLike E A B] → [GradedEquivLike E 𝒜 ... | A graded isomorphism descends to an isomorphism on each component. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_signExtend_of_le._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {v : ℕ} (i k : ℕ), ¬(i < w ∨ w ≤ i ∧ i < w + k ∨ w + k ≤ i) → False | null | false |
RestrictedProduct.mapAlongAddMonoidHom | Mathlib.Topology.Algebra.RestrictedProduct.Basic | {ι₁ : Type u_3} →
{ι₂ : Type u_4} →
(R₁ : ι₁ → Type u_5) →
(R₂ : ι₂ → Type u_6) →
{𝓕₁ : Filter ι₁} →
{𝓕₂ : Filter ι₂} →
{S₁ : ι₁ → Type u_7} →
{S₂ : ι₂ → Type u_8} →
[inst : (i : ι₁) → SetLike (S₁ i) (R₁ i)] →
[inst_1 : (j : ι₂)... | Given two restricted products `Πʳ (i : ι₁), [R₁ i, B₁ i]_[𝓕₁]` and
`Πʳ (j : ι₂), [R₂ j, B₂ j]_[𝓕₂]` of additive monoids, `RestrictedProduct.mapAlongAddMonoidHom`
gives an additive monoid homomorphism between them. The data needed is a function `f : ι₂ → ι₁` such
that `𝓕₂` tends to `𝓕₁` along `f`, and additive monoi... | true |
OrderDual.instTrichotomousLt | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [inst : LT α] [T : Std.Trichotomous LT.lt], Std.Trichotomous LT.lt | null | true |
_private.Mathlib.Combinatorics.Additive.AP.Three.Behrend.0.Behrend.le_sqrt_log._simp_1_3 | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.