name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
EMetric.cauchy_iff | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {f : Filter α},
Cauchy f ↔ f ≠ ⊥ ∧ ∀ ε > 0, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, edist x y < ε | ε-δ characterization of Cauchy sequences on pseudoemetric spaces | true |
Lean.Lsp.FileEvent.noConfusion | Lean.Data.Lsp.Workspace | {P : Sort u} → {t t' : Lean.Lsp.FileEvent} → t = t' → Lean.Lsp.FileEvent.noConfusionType P t t' | null | false |
Nat.ascFactorial._sunfold | Mathlib.Data.Nat.Factorial.Basic | ℕ → ℕ → ℕ | null | false |
CategoryTheory.GrothendieckTopology.rec | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.GrothendieckTopology C → Sort u_1} →
((sieves : (X : C) → Set (CategoryTheory.Sieve X)) →
(top_mem' : ∀ (X : C), ⊤ ∈ sieves X) →
(pullback_stable' :
∀ ⦃X Y : C⦄ ⦃S : CategoryTheory.Sieve... | null | false |
TensorAlgebra.ι_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.TensorAlgebra.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (x : M),
((TensorAlgebra.ι R) x = 0) = (x = 0) | null | false |
_private.Mathlib.Algebra.Group.Subsemigroup.Operations.0.Subsemigroup.prod_top._simp_1_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {s : Subsemigroup M} {t : Subsemigroup N} {p : M × N},
(p ∈ s.prod t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
Lean.Parser.ParserState.ctorIdx | Lean.Parser.Types | Lean.Parser.ParserState → ℕ | null | false |
Asymptotics.isBigOWith_const_one | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_3} (F : Type u_4) [inst : Norm E] [inst_1 : Norm F] [inst_2 : One F] [NormOneClass F]
(c : E) (l : Filter α), Asymptotics.IsBigOWith ‖c‖ l (fun _x => c) fun _x => 1 | null | true |
WithBot.noMaxOrder | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] [NoMaxOrder α] [Nonempty α], NoMaxOrder (WithBot α) | null | true |
UpperSet.completeLattice._proof_8 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ = (⇑OrderDual.toDual ∘ SetLike.coe) ⊥ | null | false |
riemannZeta_neg_nat_eq_bernoulli' | Mathlib.NumberTheory.LSeries.HurwitzZetaValues | ∀ (k : ℕ), riemannZeta (-↑k) = -↑(bernoulli' (k + 1)) / (↑k + 1) | Value of Riemann zeta at `-ℕ` in terms of `bernoulli'`. | true |
Lean.Grind.Nat.le_lo | Init.Grind.Offset | ∀ (u w v k : ℕ), u ≤ w → w + k ≤ v → u + k ≤ v | null | true |
FixedPoints.minpoly.eval₂' | Mathlib.FieldTheory.Fixed | ∀ (G : Type u) [inst : Group G] (F : Type v) [inst_1 : Field F] [inst_2 : MulSemiringAction G F] [inst_3 : Fintype G]
(x : F), Polynomial.eval₂ (FixedPoints.subfield G F).subtype x (FixedPoints.minpoly G F x) = 0 | null | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.VisitStep | Mathlib.Tactic.DefEqAbuse | Type u_1 → Type u_1 | A return value for functions called by traversals of `MessageData`. May either descend into
children or ascend immediately (skipping children), optionally including a value accumulated by the
traversal in both cases. | true |
Std.Sat.CNF.sat_relabel | Std.Sat.CNF.Relabel | ∀ {α : Type u_1} {β : Type u_2} {r1 : β → Bool} {r2 : α → β} {f : Std.Sat.CNF α},
Std.Sat.CNF.Sat (r1 ∘ r2) f → Std.Sat.CNF.Sat r1 (Std.Sat.CNF.relabel r2 f) | null | true |
CategoryTheory.CardinalFilteredPoset.instIsCardinalFilteredCarrierObjPartOrdEmbIsCardinalFiltered | Mathlib.CategoryTheory.Presentable.CardinalDirectedPoset | ∀ {κ : Cardinal.{u}} [inst : Fact κ.IsRegular] (J : CategoryTheory.CardinalFilteredPoset κ),
CategoryTheory.IsCardinalFiltered (↑J.obj) κ | null | true |
Fin.castLE._proof_1 | Init.Data.Fin.Basic | ∀ {n m : ℕ}, n ≤ m → ∀ (i : Fin n), ↑i < m | null | false |
CoheytingHom.instFunLike._proof_1 | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (f g : CoheytingHom α β),
(fun f => f.toFun) f = (fun f => f.toFun) g → f = g | null | false |
ENNReal.truncateToReal.eq_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ (t x : ENNReal), t.truncateToReal x = (min t x).toReal | null | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.instReprCongrArgKind.repr.match_1 | Lean.Meta.CongrTheorems | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(x : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.fixedNoParam) →
(Unit → motive Lean.Meta.CongrArgKind.eq) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → m... | null | false |
CategoryTheory.groupoidOfElements._proof_4 | Mathlib.CategoryTheory.Elements | ∀ {G : Type u_2} [inst : CategoryTheory.Groupoid G] (F : CategoryTheory.Functor G (Type u_3)) {X Y : F.Elements}
(x : X ⟶ Y),
CategoryTheory.CategoryStruct.comp x ⟨CategoryTheory.Groupoid.inv ↑x, ⋯⟩ = CategoryTheory.CategoryStruct.id X | null | false |
AddSubgroup.iInf_normalizer_le_normalizer_iInf | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {ι : Sort u_6} (H : ι → AddSubgroup G),
⨅ i, AddSubgroup.normalizer ↑(H i) ≤ AddSubgroup.normalizer ↑(⨅ i, H i) | null | true |
Set.Countable.setOf_finite | Mathlib.Data.Set.Countable | ∀ {α : Type u} [Countable α], {s | s.Finite}.Countable | The set of finite sets in a countable type is countable. | true |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_1 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | null | false |
Lean.Exception.isInterrupt | Lean.Exception | Lean.Exception → Bool | Returns `true` if the exception is an interrupt generated by `checkInterrupted`. | true |
Lean.Grind.isLE | Init.Grind.Offset | ℕ → ℕ → Bool | null | true |
ValuationSubring.principalUnitGroupEquiv._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (x : ↥A.principalUnitGroup),
(fun x => ⟨↑(A.unitGroupMulEquiv.symm ↑x), ⋯⟩) ((fun x => ⟨A.unitGroupMulEquiv ⟨↑x, ⋯⟩, ⋯⟩) x) = x | null | false |
FinBddDistLat.Hom | Mathlib.Order.Category.FinBddDistLat | FinBddDistLat → FinBddDistLat → Type u | The type of morphisms in `FinBddDistLat R`. | true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.depForallDepth | Mathlib.Tactic.Translate.Reorder | Lean.Expr → ℕ | Determine how many forall binders should be introduced to get a non-dependent conclusion. | true |
CategoryTheory.Functor.leftKanExtensionUnit_leftKanExtension_map_leftKanExtensionObjIsoColimit_hom | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : Ca... | null | true |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.isInitialIso'_hom_right | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPushouts 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.IsIni... | null | true |
Std.DTreeMap.Internal.Impl.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.LawfulEqOrd α] →
(k : α) →
(Option (β k) → Option (β k)) →
(t : Std.DTreeMap.Internal.Impl α β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α β (t.size - 1) (t.size + 1) | null | false |
Aesop.Frontend.RuleExpr | Aesop.Frontend.RuleExpr | Type | null | true |
Std.Http.Protocol.H1.Writer.messageHead | Std.Http.Protocol.H1.Writer | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Writer dir → Std.Http.Protocol.H1.Message.Head dir.swap | The outgoing message that will be written to the output.
| true |
Fin.encodeOrdering_decodeOrdering | Batteries.Data.Fin.Coding | ∀ (x : Fin 3), Fin.encodeOrdering (Fin.decodeOrdering x) = x | null | true |
CategoryTheory.rightDistrib | Mathlib.CategoryTheory.Distributive.Monoidal | {C : Type u_1} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] →
[CategoryTheory.IsMonoidalRightDistrib C] →
(X Y Z : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj Y X ⨿... | The canonical right distributivity isomorphism | true |
GroupTopology.instTop | Mathlib.Topology.Algebra.Group.GroupTopology | {α : Type u} → [inst : Group α] → Top (GroupTopology α) | null | true |
Set.list_sum_subset_list_sum | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} [inst : AddCommMonoid α] (t : List ι) (f₁ f₂ : ι → Set α),
(∀ i ∈ t, f₁ i ⊆ f₂ i) → (List.map f₁ t).sum ⊆ (List.map f₂ t).sum | An n-ary version of `Set.add_subset_add`. | true |
PartitionOfUnity.le_one | Mathlib.Topology.PartitionOfUnity | ∀ {ι : Type u} {X : Type v} [inst : TopologicalSpace X] {s : Set X} (f : PartitionOfUnity ι X s) (i : ι) (x : X),
(f i) x ≤ 1 | null | true |
ContDiffMapSupportedIn.toBoundedContinuousFunctionLM._proof_5 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
Continuous ⇑f | null | false |
UInt64.add_comm | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a + b = b + a | null | true |
Rep.hom_ext | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Semiring k] [inst_1 : Monoid G] {A B : Rep.{w, u, v} k G} {f g : A ⟶ B},
Rep.Hom.hom f = Rep.Hom.hom g → f = g | null | true |
MeasureTheory.MemLp.norm_rpow_div | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] {f : α → E},
MeasureTheory.MemLp f p μ → ∀ (q : ENNReal), MeasureTheory.MemLp (fun x => ‖f x‖ ^ q.toReal) (p / q) μ | null | true |
_private.Mathlib.LinearAlgebra.QuadraticForm.Basic.0.QuadraticMap.map_sum._simp_1_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | (¬True) = False | null | false |
Ordinal.veblen_gamma_zero | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Ordinal.veblen o.gamma 0 = o.gamma | null | true |
_private.Mathlib.Order.Concept.0.mem_lowerPolar_singleton._simp_1_2 | Mathlib.Order.Concept | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | null | false |
CategoryTheory.Subgroupoid.hom | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} →
[inst : CategoryTheory.Groupoid C] → (S : CategoryTheory.Subgroupoid C) → CategoryTheory.Functor (↑S.objs) C | The embedding of the coerced subgroupoid to its parent | true |
Std.Iter.toList_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toList = List.drop n it.toList | null | true |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_3 | Init.Data.String.FindPos | ∀ (s : String.Slice) (offset : String.Pos.Raw) (h : offset ≤ s.rawEndPos) (this : offset < s.rawEndPos),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun offset h => s.utf8ByteSize - offset.byteIdx)
⟨offset.inc, ⋯⟩ ⟨offset, h⟩ | null | false |
ContDiffMapSupportedInClass.instContinuousMapClass | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (B : Type u_5) (E : outParam (Type u_6)) (F : outParam (Type u_7)) [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ E] [inst_3 : NormedSpace ℝ F] (n : outParam ℕ∞)
(K : outParam (TopologicalSpace.Compacts E)) [inst_4 : ContDiffMapSupportedInClass B E F n K],
ContinuousMapCla... | null | true |
Std.Http.URI.noConfusion | Std.Http.Data.URI.Basic | {P : Sort u} → {t t' : Std.Http.URI} → t = t' → Std.Http.URI.noConfusionType P t t' | null | false |
Lean.Meta.mkSub | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Returns `a - b` using a heterogeneous `-`. This method assumes `a` and `b` have the same type. | true |
tsum_setProd_singleton_left | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α] (b : β)
(t : Set γ) (f : β × γ → α), ∑' (x : ↑({b} ×ˢ t)), f ↑x = ∑' (c : ↑t), f (b, ↑c) | null | true |
Set.centralizer_centralizer_centralizer | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M] (S : Set M), S.centralizer.centralizer.centralizer = S.centralizer | null | true |
Algebra.RingHom.adjoinAlgebraMap | Mathlib.RingTheory.Adjoin.Singleton | {A : Type u_1} →
{B : Type u_2} →
{C : Type u_3} →
[inst : CommSemiring A] →
[inst_1 : CommSemiring B] →
[inst_2 : CommSemiring C] →
[inst_3 : Algebra A B] →
[inst_4 : Algebra B C] →
[inst_5 : Algebra A C] → [IsScalarTower A B C] → (b : B) → ↥A[b] ... | Ring homomorphism between `A[b]` and `A[↑b]`. | true |
Real.fromBinary._proof_2 | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | ∀ (x : ℕ → Bool),
0 ≤ (Real.ofDigits ∘ ⇑(Homeomorph.piCongrRight fun x => finTwoEquiv.toHomeomorphOfDiscrete.symm)) x ∧
(Real.ofDigits ∘ ⇑(Homeomorph.piCongrRight fun x => finTwoEquiv.toHomeomorphOfDiscrete.symm)) x ≤ 1 | null | false |
instIsBoundedSMulSeparationQuotient | Mathlib.Topology.MetricSpace.Algebra | ∀ {α : Type u_4} {β : Type u_5} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [inst_2 : Zero α]
[inst_3 : Zero β] [inst_4 : SMul α β] [inst_5 : IsBoundedSMul α β], IsBoundedSMul α (SeparationQuotient β) | null | true |
CategoryTheory.Monad.algebraFunctorOfMonadHomId._proof_5 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T₁ : CategoryTheory.Monad C} {X Y : T₁.Algebra}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Monad.algebraFunctorOfMonadHom (CategoryTheory.CategoryStruct.id T₁)).map f)
(CategoryTheory.Monad.Algebra.isoMk
(Cat... | null | false |
Lean.LocalContext.foldr | Lean.LocalContext | {β : Type u_1} → Lean.LocalContext → (Lean.LocalDecl → β → β) → β → β | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionHom_comp | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {C : Type u_1} {D : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} D} {inst_2 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {c c' c'' : C} {d d' d'' : D} (f₁ : c ⟶ c')
(f₂ : c' ⟶ c'') (g₁ : d ⟶ d') (g₂ :... | null | true |
Std.TreeSet.Raw.get?_eq_some_getD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {a fallback : α}, a ∈ t → t.get? a = some (t.getD a fallback) | null | true |
Affine.Simplex.orthogonalProjection_eq_circumcenter_of_exists_dist_eq | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) {p : P},
(∃ r, ∀ (i : Fin (n + 1)), dist (s.points i) p = r) → ↑(s.orthogonalProjectionSpan p) = s.circumcenter | If there exists a distance that a point has from all vertices of a
simplex, the orthogonal projection of that point onto the subspace
spanned by that simplex is its circumcenter. | true |
Commute.sub_dvd_pow_sub_pow | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : Ring R] {x y : R}, Commute x y → ∀ (n : ℕ), x - y ∣ x ^ n - y ^ n | null | true |
Lean.Meta.Sym.Canon.State.cache | Lean.Meta.Sym.SymM | Lean.Meta.Sym.Canon.State → Std.HashMap Lean.Expr Lean.Expr | Cache for value-level canonicalization (no type reductions applied). | true |
Erased.join | Mathlib.Data.Erased | {α : Sort u_1} → Erased (Erased α) → Erased α | Collapses two levels of erasure.
| true |
CategoryTheory.ObjectProperty.SerreClassLocalization.map_eq_zero_iff | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] [L.IsLocalization P.isoModSerre] [inst_5 : CategoryTheory.Preaddit... | null | true |
CategoryTheory.AsSmall.abelian | Mathlib.CategoryTheory.Abelian.Transfer | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Abelian (CategoryTheory.AsSmall C) | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.size_eq_if_roo._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxo.HasSize α]
[Std.Rxo.LawfulHasSize α] {lo hi : α}, (Std.Rxo.HasSize.size lo hi = 0) = ¬lo < hi | null | false |
Finset.truncatedInf_union | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeInf α] {s t : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : BoundedOrder α]
[inst_3 : DecidableEq α],
a ∈ upperClosure ↑s → a ∈ upperClosure ↑t → (s ∪ t).truncatedInf a = s.truncatedInf a ⊓ t.truncatedInf a | null | true |
GenContFract.succ_succ_nth_conv'Aux_eq_succ_nth_conv'Aux_squashSeq | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} {n : ℕ} {s : Stream'.Seq (GenContFract.Pair K)} [inst : DivisionRing K],
GenContFract.convs'Aux s (n + 2) = GenContFract.convs'Aux (GenContFract.squashSeq s n) (n + 1) | The auxiliary function `convs'Aux` returns the same value for a sequence and the
corresponding squashed sequence at the squashed position. | true |
_private.Mathlib.RingTheory.DividedPowerAlgebra.Init.0.DividedPowerAlgebra.dp_sum_smul._simp_1_1 | Mathlib.RingTheory.DividedPowerAlgebra.Init | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : CommMonoid M] {f g : ι → M},
(∏ x ∈ s, f x) * ∏ x ∈ s, g x = ∏ x ∈ s, f x * g x | null | false |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.matchAtomic | Lean.Server.Completion.CompletionCollectors | Lean.Name → Lean.Name → Bool → Bool | null | true |
CategoryTheory.SmallCategoryCardinalLT.exists_equivalence | Mathlib.CategoryTheory.SmallRepresentatives | ∀ (κ : Cardinal.{w}) (C : Type u) [inst : CategoryTheory.Category.{v, u} C],
HasCardinalLT (CategoryTheory.Arrow C) κ →
∃ S, Nonempty (CategoryTheory.SmallCategoryCardinalLT.categoryFamily κ S ≌ C) | null | true |
_private.Mathlib.RingTheory.Ideal.Height.0.Ideal.primeHeight.congr_simp | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] (I I_1 : Ideal R) (e_I : I = I_1) [hI : I.IsPrime],
Ideal.primeHeight✝ I = Ideal.primeHeight✝ I_1 | null | true |
UniformSpace.Completion.instNormedRing._proof_15 | Mathlib.Analysis.Normed.Module.Completion | ∀ (A : Type u_1) [inst : SeminormedRing A] (a : UniformSpace.Completion A), -a + a = 0 | null | false |
ByteArray.extract_eq_extract_iff_getElem | Init.Data.ByteArray.Lemmas | ∀ {as bs : ByteArray} {i j len : ℕ} (hi : i + len ≤ as.size) (hj : j + len ≤ bs.size),
as.extract i (i + len) = bs.extract j (j + len) ↔ ∀ (k : ℕ) (hk : k < len), as[i + k] = bs[j + k] | null | true |
ClosureOperator.le_closure | Mathlib.Order.Closure | ∀ {α : Type u_1} [inst : Preorder α] (c : ClosureOperator α) (x : α), x ≤ c x | Every element is less than its closure. This property is sometimes referred to as extensivity or
inflationarity. | true |
Std.Tactic.BVDecide.BVBinPred.eval | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {w : ℕ} → Std.Tactic.BVDecide.BVBinPred → BitVec w → BitVec w → Bool | The semantics for `BVBinPred`.
| true |
IsCoveringMap.liftHomotopyRel._proof_1 | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_3} {A : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X]
[inst_2 : TopologicalSpace A] {p : E → X} (cov : IsCoveringMap p) {f₀ f₁ : C(A, X)} {S : Set A}
(F : f₀.HomotopyRel f₁ S) {f₀' : C(A, E)} (F_0 : ∀ (a : A), F (0, a) = p (f₀' a)) (t : ↑unitInterval),
∀ a ∈ S, (... | null | false |
expandLemma | Mathlib.Tactic.Lemma | Lean.Macro | Implementation of the `lemma` command, by macro expansion to `theorem`. | true |
ByteArray.toList.loop._unary.eq_def | Init.Data.ByteArray.Basic | ∀ (bs : ByteArray) (_x : (_ : ℕ) ×' List UInt8),
ByteArray.toList.loop._unary bs _x =
PSigma.casesOn _x fun i r =>
if i < bs.size then ByteArray.toList.loop._unary bs ⟨i + 1, bs.get! i :: r⟩ else r.reverse | null | false |
TwoUniqueSums.instForall | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {ι : Type u_2} (G : ι → Type u_1) [inst : (i : ι) → Add (G i)] [∀ (i : ι), TwoUniqueSums (G i)],
TwoUniqueSums ((i : ι) → G i) | null | true |
_private.Mathlib.Topology.Separation.Basic.0.t1Space_TFAE._simp_1_7 | Mathlib.Topology.Separation.Basic | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ⊆ {a}ᶜ) = (a ∉ s) | null | false |
EuclideanGeometry.Sphere.IsExtTangentAt.mem_left | Mathlib.Geometry.Euclidean.Sphere.Tangent | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s₁ s₂ : EuclideanGeometry.Sphere P} {p : P}, s₁.IsExtTangentAt s₂ p → p ∈ s₁ | null | true |
Qq.Impl.isIrrefutablePattern | Qq.Match | Lean.Term → Bool | null | true |
commutator_def | Mathlib.GroupTheory.Commutator.Basic | ∀ (G : Type u_1) [inst : Group G], commutator G = ⁅⊤, ⊤⁆ | null | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated.0.MeasurableSpace.CountablySeparated.mono._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α],
MeasurableSpace.CountablySeparated α = HasCountableSeparatingOn α MeasurableSet Set.univ | null | false |
Pi.mulZeroClass._proof_2 | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] (a : (i : ι) → α i), a * 0 = 0 | null | false |
Int.getElem!_toArray_roo | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, (m<...n).toArray[i]! = if i < (n - (m + 1)).toNat then m + 1 + ↑i else 0 | null | true |
contDiff_one_iff_fderiv | 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] {f : E → F},
ContDiff 𝕜 1 f ↔ Differentiable 𝕜 f ∧ Continuous (fderiv 𝕜 f) | null | true |
FiberBundleCore.mk_mem_localTrivAt_source | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (b : B) (a : F), ⟨b, a⟩ ∈ (Z.localTrivAt b).source | null | true |
_private.Init.Data.String.FindPos.0.String.Slice.posGE._unary._proof_1 | Init.Data.String.FindPos | ∀ (s : String.Slice), ∀ offset ≤ s.rawEndPos, ¬String.Pos.Raw.IsValidForSlice s offset → offset < s.rawEndPos | null | false |
Subrepresentation.mk._flat_ctor | Mathlib.RepresentationTheory.Subrepresentation | {A : Type u_1} →
{G : Type u_2} →
{W : Type u_3} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid W] →
[inst_3 : Module A W] →
{ρ : Representation A G W} →
(toSubmodule : Submodule A W) →
(∀ (g : G) ⦃v : W⦄, v... | null | false |
CategoryTheory.SingleObj | Mathlib.CategoryTheory.SingleObj | Type u_1 → Type | Abbreviation that allows writing `CategoryTheory.SingleObj` rather than `Quiver.SingleObj`.
| true |
Lean.VersoModuleDocs.Snippet.mk.injEq | Lean.DocString.Extension | ∀ (text : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections : Array (ℕ × Lean.DeclarationRange × Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty))
(declarationRange : Lean.DeclarationRange) (text_1 : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(sections_1 : Array (ℕ × Lean.Declaration... | null | true |
Std.Tactic.BVDecide.LRAT.instBEqAction.beq._sparseCasesOn_2 | Std.Tactic.BVDecide.LRAT.Actions | {β : Type u} →
{α : Type v} →
{motive : Std.Tactic.BVDecide.LRAT.Action β α → Sort u_1} →
(t : Std.Tactic.BVDecide.LRAT.Action β α) →
((id : ℕ) → (c : β) → (rupHints : Array ℕ) → motive (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motiv... | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals_mono | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme}, Monotone AlgebraicGeometry.Scheme.IdealSheafData.ofIdeals | null | true |
_private.Lean.Level.0.Lean.Level.normLtAux._unary.eq_def | Lean.Level | ∀ (_x : (_ : Lean.Level) ×' (_ : ℕ) ×' (_ : Lean.Level) ×' ℕ),
Lean.Level.normLtAux._unary _x =
PSigma.casesOn _x fun a a_1 =>
PSigma.casesOn a_1 fun a_2 a_3 =>
PSigma.casesOn a_3 fun a_4 a_5 =>
match a, a_2, a_4, a_5 with
| l₁.succ, k₁, l₂, k₂ => Lean.Level.normLtAux._unary ⟨l₁,... | null | false |
Aesop.ScriptGenerated.perfect | Aesop.Stats.Basic | Aesop.ScriptGenerated → Bool | null | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix.noConfusionType | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | Sort u →
{n m : ℕ} →
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n m →
{n' m' : ℕ} → Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n' m' → Sort u | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.