name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Filter.addCommMonoid | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [AddCommMonoid α] → AddCommMonoid (Filter α) | `Filter α` is an `AddCommMonoid` under pointwise operations if `α` is. | true |
Cycle.prev | Mathlib.Data.List.Cycle | {α : Type u_1} → [DecidableEq α] → (s : Cycle α) → s.Nodup → (x : α) → x ∈ s → α | Given a `s : Cycle α` such that `Nodup s`, retrieve the previous element before `x ∈ s`. | true |
Lean.Parser.ParserCacheEntry.mk.inj | Lean.Parser.Types | ∀ {stx : Lean.Syntax} {lhsPrec : ℕ} {newPos : String.Pos.Raw} {errorMsg : Option Lean.Parser.Error}
{stx_1 : Lean.Syntax} {lhsPrec_1 : ℕ} {newPos_1 : String.Pos.Raw} {errorMsg_1 : Option Lean.Parser.Error},
{ stx := stx, lhsPrec := lhsPrec, newPos := newPos, errorMsg := errorMsg } =
{ stx := stx_1, lhsPrec :=... | null | true |
Matrix.kroneckerMap_transpose | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {α : Type u_3} {β : Type u_5} {γ : Type u_7} {l : Type u_9} {m : Type u_10} {n : Type u_11} {p : Type u_12}
(f : α → β → γ) (A : Matrix l m α) (B : Matrix n p β),
Matrix.kroneckerMap f A.transpose B.transpose = (Matrix.kroneckerMap f A B).transpose | null | true |
contDiffWithinAt_inter | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s t : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞}, t ∈ nhds x → (ContDiffWithinAt 𝕜 n f (s ∩ t) x ↔ ContDiffWithin... | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.Defs.0.RootPairing.isFixedPt_reflectionPerm_iff._simp_1_2 | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {i j : ι},
((P.reflectionPerm i) j = j) = (P.pairing j i • P.root i = 0) | null | false |
Lean.Elab.Tactic.linter.tactic.unusedName | Lean.Elab.Tactic.Lets | Lean.Option Bool | null | true |
Finmap.toFinmap_nil | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α], [].toFinmap = ∅ | null | true |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.instCompleteLatticeSubfunctor._simp_7 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
BoxIntegral.Integrable.convergenceR | Mathlib.Analysis.BoxIntegral.Basic | {ι : Type u} →
{E : Type v} →
{F : Type w} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
{I : BoxIntegral.Box ι} →
[inst_4 : Fintype ι] →
{l : BoxInte... | If `ε > 0`, then `BoxIntegral.Integrable.convergenceR` is a function `r : ℝ≥0 → ℝⁿ → (0, ∞)`
such that for every `c : ℝ≥0`, for every tagged partition `π` subordinate to `r` (and satisfying
additional distortion estimates if `BoxIntegral.IntegrationParams.bDistortion l = true`), the
corresponding integral sum is `ε`-cl... | true |
CategoryTheory.Monoidal.rightUnitor_hom_app | Mathlib.CategoryTheory.Monoidal.FunctorCategory | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] {F : CategoryTheory.Functor C D} {X : C},
(CategoryTheory.MonoidalCategoryStruct.rightUnitor F).hom.app X =
(CategoryTheory.MonoidalCategoryStruct.... | null | true |
Array.getElem?_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {as : Array α} {bs : Array β} {f : α → β → γ} {i : ℕ},
(Array.zipWith f as bs)[i]? =
match as[i]?, bs[i]? with
| some a, some b => some (f a b)
| x, x_1 => none | See also `getElem?_zipWith'` for a variant
using `Option.map` and `Option.bind` rather than a `match`.
| true |
ModuleCat.localizedModuleMap._proof_2 | Mathlib.Algebra.Category.ModuleCat.Localization | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Small.{u_2, u_1} R] {N : ModuleCat R} (S : Submonoid R),
SMulCommClass (Localization S) R ↑(N.localizedModule S) | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic.0.InnerProductGeometry.sin_angle_mul_norm_mul_norm._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
SkewMonoidAlgebra.instNonAssocRing._proof_9 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_2} {G : Type u_1} [inst : Ring k] [inst_1 : Monoid G] [inst_2 : MulSemiringAction G k], ↑0 = 0 | null | false |
Std.ExtDHashMap.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (Std.ExtDHashMap.Const.insertManyIf... | null | true |
AlgebraicGeometry.Scheme.empty._proof_1 | Mathlib.AlgebraicGeometry.Scheme | CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology ↑(TopCat.of PEmpty.{u_1 + 1}))
((CategoryTheory.Functor.const (TopologicalSpace.Opens ↑(TopCat.of PEmpty.{u_1 + 1}))ᵒᵖ).obj
(CommRingCat.of PUnit.{u_1 + 1})) | null | false |
Lean.instValueLeanOptionValue | Lean.Util.LeanOptions | Lean.KVMap.Value Lean.LeanOptionValue | null | true |
Set.iUnion_Icc_left | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : Preorder α] (a : α), ⋃ b, Set.Icc b a = Set.Iic a | null | true |
MvPFunctor.castLastB | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → {a a' : P.A} → a = a' → P.last.B a → P.last.B a' | Proof of type equality as a function | true |
mul_le_mul_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : LE α] [i : MulRightMono α] {b c : α}, b ≤ c → ∀ (a : α), b * a ≤ c * a | null | true |
IsChain.image_relEmbedding_iff | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {r' : β → β → Prop} {s : Set α} {φ : r ↪r r'},
IsChain r' (⇑φ '' s) ↔ IsChain r s | null | true |
Finsupp.support_smul_eq | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_3} {R : Type u_6} [inst : Semiring R] [IsDomain R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [Module.IsTorsionFree R M] {b : R}, b ≠ 0 → ∀ {g : α →₀ M}, (b • g).support = g.support | null | true |
AddSubgroup.addOrderOf_mk | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddGroup G] {H : AddSubgroup G} (a : G) (ha : a ∈ H), addOrderOf ⟨a, ha⟩ = addOrderOf a | null | true |
Int.neg_inj | Init.Data.Int.Lemmas | ∀ {a b : ℤ}, -a = -b ↔ a = b | null | true |
Pi.eq_top_iff_refl_of_subsingleton | Mathlib.Order.PropInstances | ∀ {α : Type u_2} [Subsingleton α] {r : α → α → Prop}, r = ⊤ ↔ Std.Refl r | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach.0.Std.IterM.toArray_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3) (it' : Std.IterM m β)
(out : β) (h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
... | null | true |
CategoryTheory.ObjectProperty.prop_of_isColimit_cofan | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderFiniteCoproducts] {J : Type u_2} [Finite J] {f : J → C} {F : CategoryTheory.Limits.Cofan f}
(hF : CategoryTheory.Limits.IsColimit F), (∀ (j : J), P (f j)) → P F.pt | null | true |
FirstOrder.Language.DefinableSet.instSetLike._proof_1 | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type u_2} [inst : L.Structure M] {A : Set M} {α : Type u_1},
Function.Injective Subtype.val | null | false |
Std.TreeMap.Raw.WF.emptyc | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, ∅.WF | null | true |
_private.Mathlib.Computability.Primrec.Basic.0.Primrec.eq._simp_1_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.exists_mem_support_mem_erase_mem_support_takeUntil_eq_empty._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, ∀ x ∈ p.support, x ∈ p.support | null | false |
Lean.Lsp.instInhabitedCallHierarchyIncomingCall.default | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CallHierarchyIncomingCall | null | true |
CategoryTheory.Limits.hasLimitsOfShape_thinSkeleton | Mathlib.CategoryTheory.Limits.Skeleton | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} C]
[Quiver.IsThin C] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.ThinSkeleton C) | null | true |
FormalMultilinearSeries.unshift._proof_3 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_3} {E : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F], ContinuousAdd (E →L[𝕜] F) | null | false |
Finset.noncommSum_lemma | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid β] (s : Finset α) (f : α → β),
(↑s).Pairwise (Function.onFun AddCommute f) → {x | x ∈ Multiset.map f s.val}.Pairwise AddCommute | null | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (k : ℤ) (y? : Option Int.Linear.Var) (c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod k y? c) = 1 + sizeOf k + sizeOf y? + sizeOf c | null | true |
CategoryTheory.functorCategoryPreadditive._proof_18 | Mathlib.CategoryTheory.Preadditive.FunctorCategory | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.Preadditive D]
(F G : CategoryTheory.Functor C D) (x : ℕ) (x_1 : F ⟶ G),
{ app := Int.negSucc x • x_1.app, naturality := ⋯ } = -{ app := ↑x.succ • x_1.app, natural... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.isPath_iff_isSubwalk_imp_nil._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, ∀ j ≤ p.length, j < p.support.length | null | false |
AlgebraicGeometry.IsClosedImmersion.lift_fac_assoc | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Z) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsClosedImmersion f]
(H : AlgebraicGeometry.Scheme.Hom.ker f ≤ AlgebraicGeometry.Scheme.Hom.ker g) {Z_1 : AlgebraicGeometry.Scheme}
(h : Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.IsClosedImmersion.lift f g... | null | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution.congr_simp | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, ... | null | true |
CategoryTheory.MonoidalCategory.Arrow.PullbackHom.isInitialIso_hom_left | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
[inst_4 : CategoryTheory.BraidedCategory C] (X : CategoryTheory.Arrow C) {I : C}
(i : CategoryTheory.Limits.IsIn... | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.saveBVar | Lean.Meta.Tactic.Grind.EMatchTheorem | ℕ → Lean.Meta.Grind.NormalizePattern.M✝ Unit | null | true |
Filter.Germ.LiftRel | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → {l : Filter α} → (β → γ → Prop) → l.Germ β → l.Germ γ → Prop | Lift a relation `r : β → γ → Prop` to `Germ l β → Germ l γ → Prop`. | true |
DivisorChain.eq_pow_second_of_chain_of_has_chain | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [UniqueFactorizationMonoid M] {q : Associates M} {n : ℕ},
n ≠ 0 →
∀ {c : Fin (n + 1) → Associates M},
StrictMono c → (∀ {r : Associates M}, r ≤ q ↔ ∃ i, r = c i) → q ≠ 0 → q = c 1 ^ n | null | true |
Polynomial.separable_cyclotomic | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_2) [inst : Field K] [NeZero ↑n], (Polynomial.cyclotomic n K).Separable | null | true |
Nat.bit_mod_two | Mathlib.Data.Nat.BinaryRec | ∀ (b : Bool) (n : ℕ), Nat.bit b n % 2 = b.toNat | null | true |
CategoryTheory.ComposableArrows.IsComplex.opcyclesToCycles_fac._auto_1 | Mathlib.Algebra.Homology.ExactSequenceFour | Lean.Syntax | null | false |
Squash.mk | Init.Core | {α : Sort u} → α → Squash α | Places a value into its squash type, in which it cannot be distinguished from any other.
| true |
NNRat.cast_inj._simp_1 | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionSemiring α] [CharZero α] {p q : ℚ≥0}, (↑p = ↑q) = (p = q) | null | false |
SimplexCategory.δ₀Iter_δ'._auto_1 | Mathlib.AlgebraicTopology.SimplexCategory.DeltaZeroIter | Lean.Syntax | null | false |
continuous_finsum | 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},
(∀ (i : ι), Continuous (f i)) →
(LocallyFinite fun i => Function.support (f i)) → Continuous fun x => ∑ᶠ (i : ι), f i x | null | true |
Mathlib.Tactic.ITauto.Context.format | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.Context → Std.Format | Debug printer for the context. | true |
Erased.instToString | Mathlib.Data.Erased | (α : Type u) → ToString (Erased α) | null | true |
_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.maxPowDvdDiv.match_1.eq_1 | Mathlib.Data.Nat.MaxPowDiv | ∀ (motive : ℕ × ℕ → Sort u_1) (e q : ℕ) (h_1 : (e q : ℕ) → motive (e, q)),
(match (e, q) with
| (e, q) => h_1 e q) =
h_1 e q | null | true |
FiniteDimensional.nonempty_continuousLinearEquiv_of_finrank_eq | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E] {F : Type w} [inst_5 : AddCommGroup F]
[inst_6 : Module 𝕜 F] [inst_7 : TopologicalSpace F] [IsTopologicalAddGroup F] [Contin... | Two finite-dimensional topological vector spaces over a complete normed field are continuously
linearly equivalent if they have the same (finite) dimension. | true |
UpperHalfPlane.atImInfty.eq_1 | Mathlib.Analysis.Complex.UpperHalfPlane.FunctionsBoundedAtInfty | UpperHalfPlane.atImInfty = Filter.comap UpperHalfPlane.im Filter.atTop | null | true |
Matrix.transposeᵣ.eq_2 | Mathlib.Data.Matrix.Reflection | ∀ {α : Type u_1} (x n : ℕ) (A : Matrix (Fin x) (Fin (n + 1)) α),
A.transposeᵣ = Matrix.of (Matrix.vecCons (FinVec.map (fun v => v 0) A) (A.submatrix id Fin.succ).transposeᵣ) | null | true |
_private.Init.Data.SInt.Lemmas.0.Int32.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int32}, (x < y) = (x.toInt < y.toInt) | null | false |
Cardinal.mk_sum | Mathlib.SetTheory.Cardinal.Defs | ∀ (α : Type u) (β : Type v),
Cardinal.mk (α ⊕ β) = Cardinal.lift.{v, u} (Cardinal.mk α) + Cardinal.lift.{u, v} (Cardinal.mk β) | null | true |
MeasureTheory.Measure.instRegularOfIsHaarMeasureOfCompactSpace | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G] [inst_3 : MeasurableSpace G]
[BorelSpace G] [CompactSpace G] (μ : MeasureTheory.Measure G) [μ.IsMulLeftInvariant]
[MeasureTheory.IsFiniteMeasureOnCompacts μ], μ.Regular | null | true |
Lean.instInhabitedScopedEnvExtension.default | Lean.ScopedEnvExtension | {α β σ : Type} → [Inhabited α] → Lean.ScopedEnvExtension α β σ | null | true |
LinearIsometryEquiv.piLpCongrRight._proof_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {𝕜 : Type u_4} {ι : Type u_1} {α : ι → Type u_3} {β : ι → Type u_2} [hp : Fact (1 ≤ p)]
[inst : Fintype ι] [inst_1 : Semiring 𝕜] [inst_2 : (i : ι) → SeminormedAddCommGroup (α i)]
[inst_3 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_4 : (i : ι) → Module 𝕜 (α i)]
[inst_5 : (i : ι) → Module 𝕜 ... | null | false |
Lean.Widget.instFromJsonRpcEncodablePacket.fromJson._@.Lean.Widget.Types.3328362917._hygCtx._hyg.14 | Lean.Widget.Types | Lean.Json → Except String Lean.Widget.RpcEncodablePacket✝ | null | false |
preordToCat._proof_1 | Mathlib.Order.Category.Preord | ∀ (X : Preord), ⋯.functor.toCatHom = CategoryTheory.CategoryStruct.id (CategoryTheory.Cat.of ↑X) | null | false |
_private.Lean.Elab.Tactic.Monotonicity.0.Lean.Meta.Monotonicity.solveMonoCall._sparseCasesOn_1 | Lean.Elab.Tactic.Monotonicity | {α : 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.String.Iterate.0.String.Slice.revBytes._proof_1 | Init.Data.String.Iterate | ∀ (s : String.Slice), s.endPos.offset ≤ s.rawEndPos | null | false |
CategoryTheory.IsSplitEpi.exists_splitEpi | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.IsSplitEpi f],
Nonempty (CategoryTheory.SplitEpi f) | There is a splitting | true |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.mkIterator.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String), String.Legacy.mkIterator s = { s := s, i := 0 } | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_280 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Lean.Environment.AddConstAsyncResult.mainEnv | Lean.Environment | Lean.Environment.AddConstAsyncResult → Lean.Environment | Resulting "main branch" environment which contains the declaration name as an asynchronous
constant. Accessing the constant or kernel environment will block until the corresponding
`AddConstAsyncResult.commit*` function has been called.
| true |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.isIso_functor_map_hom_h_f._proof_1_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (k : ℕ) {q₁ : ℕ}, q₁ ≤ q₁ + k | null | false |
Lean.Meta.Grind.TopSort.State.permMark._default | Lean.Meta.Tactic.Grind.EqResolution | Std.HashSet Lean.Expr | null | false |
linearIndepOn_finset_iff | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} {s : Finset ι}, LinearIndepOn R v ↑s ↔ ∀ (f : ι → R), ∑ i ∈ s, f i • v i = 0 → ∀ i ∈ s, f i = 0 | null | true |
Lean.Server.TransientWorkerILean.hasRefs | Lean.Server.References | Lean.Server.TransientWorkerILean → Bool | Determines whether this transient worker ILean includes actual references. | true |
MonadFinally | Init.Control.Except | (Type u → Type v) → Type (max (u + 1) v) | Monads that provide the ability to ensure an action happens, regardless of exceptions or other
failures.
`MonadFinally.tryFinally'` is used to desugar `try ... finally ...` syntax.
| true |
Polynomial.derivRootWeight.eq_1 | Mathlib.Analysis.Complex.Polynomial.GaussLucas | ∀ (P : Polynomial ℂ) (z w : ℂ),
P.derivRootWeight z w =
if Polynomial.eval z P = 0 then Pi.single z 1 w else ↑(Polynomial.rootMultiplicity w P) / ‖z - w‖ ^ 2 | null | true |
LinearAlgebra.FreeProduct.ι' | Mathlib.LinearAlgebra.FreeProduct.Basic | {I : Type u} →
[inst : DecidableEq I] →
(R : Type v) →
[inst_1 : CommSemiring R] →
(A : I → Type w) →
[inst_2 : (i : I) → Semiring (A i)] →
[inst_3 : (i : I) → Algebra R (A i)] → (DirectSum I fun i => A i) →ₗ[R] LinearAlgebra.FreeProduct R A | The canonical linear map from the direct sum of the `A i` to the free product | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._simp_1_4 | Mathlib.Topology.Sets.VietorisTopology | ∀ {β : Type u_2} {ι : Sort u_5} (s : Set β) (t : ι → Set β), ⋃ i, s ∩ t i = s ∩ ⋃ i, t i | null | false |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork_φQ | 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₂) (hf₁ : S₁.f = 0) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(hc₁ : CategoryTheory.Limits.IsLimit c₁) (hf₂ : S₂.f = 0) (c₂ : CategoryTheory.Limits... | null | true |
Tactic.ComputeAsymptotics.Seq.dist_nil_cons | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} (x : α) (s : Stream'.Seq α), dist Stream'.Seq.nil (Stream'.Seq.cons x s) = 1 | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_diff_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false → (m₁.diff m₂ ⋯).getKeyD k fallback = m₁.getKeyD k fallback | null | true |
UniformFun.lipschitzWith_ofFun_iff | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace γ] [inst_1 : PseudoEMetricSpace β]
{f : γ → α → β} {K : NNReal},
(LipschitzWith K fun x => UniformFun.ofFun (f x)) ↔ ∀ (c : α), LipschitzWith K fun x => f x c | null | true |
Std.DTreeMap.Internal.Cell.ofEq.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {k : α → Ordering} (k' : α) (v' : β k')
(hcmp : ∀ [Std.OrientedOrd α], k k' = Ordering.eq),
Std.DTreeMap.Internal.Cell.ofEq k' v' hcmp = { inner := some ⟨k', v'⟩, property := ⋯ } | null | true |
Std.ExtDTreeMap.Const.size_le_size_insertMany_list | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{l : List (α × β)}, t.size ≤ (Std.ExtDTreeMap.Const.insertMany t l).size | null | true |
_private.Mathlib.RingTheory.IsPrimary.0.Submodule.isPrimary_iff_zero_divisor_quotient_imp_nilpotent_smul._simp_1_3 | Mathlib.RingTheory.IsPrimary | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a = ⊥) = (a ≤ ⊥) | null | false |
Module.Grassmannian._sizeOf_1 | Mathlib.RingTheory.Grassmannian | {R : Type u} →
{inst : CommRing R} →
{M : Type v} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → {k : ℕ} → [SizeOf R] → [SizeOf M] → Module.Grassmannian R M k → ℕ | null | false |
Subsemiring.distribMulAction | Mathlib.Algebra.Ring.Subsemiring.Basic | {R' : Type u_1} →
{α : Type u_2} →
[inst : Semiring R'] →
[inst_1 : AddMonoid α] → [DistribMulAction R' α] → (S : Subsemiring R') → DistribMulAction (↥S) α | The action by a subsemiring is the action by the underlying semiring. | true |
Partition.instIsTransRel | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {u : Set α} (P : Partition u), IsTrans α P.Rel | null | true |
LocallyFiniteOrder.toLocallyFiniteOrderTop._proof_1 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : OrderTop α] (a x : α),
x ∈ Finset.Icc a ⊤ ↔ a ≤ x | null | false |
UniformSpace.ofCoreEq._proof_1 | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type u_1} (u : UniformSpace.Core α) (t : TopologicalSpace α),
t = u.toTopologicalSpace → ∀ (x : α), nhds x = Filter.comap (Prod.mk x) u.uniformity | null | false |
CategoryTheory.faithful_linearYoneda | Mathlib.CategoryTheory.Linear.Yoneda | ∀ (R : Type w) [inst : Ring R] (C : Type u) [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C],
(CategoryTheory.linearYoneda R C).Faithful | null | true |
Prod.continuousNeg | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {H : Type x} [inst : TopologicalSpace G] [inst_1 : Neg G] [ContinuousNeg G] [inst_3 : TopologicalSpace H]
[inst_4 : Neg H] [ContinuousNeg H], ContinuousNeg (G × H) | null | true |
_private.Init.System.IO.0.System.FilePath.isDir.match_1 | Init.System.IO | (motive : Except IO.Error IO.FS.Metadata → Sort u_1) →
(__do_lift : Except IO.Error IO.FS.Metadata) →
((m : IO.FS.Metadata) → motive (Except.ok m)) → ((a : IO.Error) → motive (Except.error a)) → motive __do_lift | null | false |
CategoryTheory.SimplicialObject.Augmented.σ₀Iter_hom_app_assoc | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (Y : CategoryTheory.SimplicialObject.Augmented C)
{n m : ℕ} (i : ℕ) (hi : autoParam (n + i = m) CategoryTheory.SimplicialObject.Augmented.σ₀Iter_hom_app._auto_1)
{Z : C} (h : Y.right ⟶ Z),
CategoryTheory.CategoryStruct.comp (Y.left.σ₀Iter i hi)
... | null | true |
Lean.Meta.Grind.Action.andAlso | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Action → Lean.Meta.Grind.Action → Lean.Meta.Grind.Action | Sequential conjunction: executes both `x` and `y`.
- Runs `x` and always runs `y` afterward, regardless of whether `x` made progress.
- It is not applicable only if both `x` and `y` are not applicable.
| true |
Prod.finite_iff | Mathlib.Data.Finite.Prod | ∀ {α : Type u_1} {β : Type u_2} [Nonempty α] [Nonempty β], Finite (α × β) ↔ Finite α ∧ Finite β | null | true |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.iff_exists_tensorProduct._simp_1_4 | Mathlib.RingTheory.Unramified.Finite | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
KaehlerDifferential.ideal R S = Ideal.span (Set.range fun s => 1 ⊗ₜ[R] s - s ⊗ₜ[R] 1) | null | false |
Std.DTreeMap.Internal.Impl.erase._proof_15 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (sz : ℕ) (k' : α) (v' : β k') (l r : Std.DTreeMap.Internal.Impl α β)
(h : (Std.DTreeMap.Internal.Impl.inner sz k' v' l r).Balanced) (l' : Std.DTreeMap.Internal.Impl α β)
(hl'₁ : l'.Balanced) (hl'₂ : l.size - 1 ≤ l'.size) (hl'₃ : l'.size ≤ l.size),
(Std.DTreeMap.Internal.Impl.ba... | null | false |
_private.Lean.Elab.Tactic.Do.ProofMode.RenameI.0.Lean.Elab.Tactic.Do.ProofMode.elabMRenameI | Lean.Elab.Tactic.Do.ProofMode.RenameI | Lean.Elab.Tactic.Tactic | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.