name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
KStar | Mathlib.Algebra.Order.Kleene | Type u_5 → Type u_5 | Notation typeclass for the Kleene star `∗`. | true |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.natCast_image_Iio._proof_1_1 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (n : ℕ) (o : Ordinal.{u_1}), (∀ {b : ℕ}, o ≤ ↑b → ∃ c, o = ↑c) → (o ∈ NatCast.natCast '' Set.Iio n ↔ o ∈ Set.Iio ↑n) | null | false |
HahnSeries.support_embDomain_subset | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
{f : Γ ↪o Γ'} {x : HahnSeries Γ R}, (HahnSeries.embDomain f x).support ⊆ ⇑f '' x.support | null | true |
Matrix.twoBlockTriangular_det | Mathlib.LinearAlgebra.Matrix.Block | ∀ {m : Type u_2} {R : Type v} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m] (M : Matrix m m R)
(p : m → Prop) [inst_3 : DecidablePred p],
(∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0) →
M.det = (M.toSquareBlockProp p).det * (M.toSquareBlockProp fun i => ¬p i).det | null | true |
SimpleGraph.turanNumber_eq._unary | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {r : ℕ} (n : ℕ), SimpleGraph.turanNumber n r = (n ^ 2 - (n % r) ^ 2) * (r - 1) / (2 * r) + (n % r).choose 2 | The exact formula for the number of edges in `turanGraph n r`. | false |
Finset.intervalGapsWithin.snd.congr_simp | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} [inst : LinearOrder α] (F F_1 : Finset (α × α)) (e_F : F = F_1) {k : ℕ} (h : F.card = k) (b b_1 : α),
b = b_1 →
∀ (i i_1 : Fin (k + 1)),
i = i_1 → Finset.intervalGapsWithin.snd F h b i = Finset.intervalGapsWithin.snd F_1 ⋯ b_1 i_1 | null | true |
StarAlgEquiv.toNonUnitalStarAlgHom._proof_4 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A₁ : Type u_2} {A₂ : Type u_1} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A₁]
[inst_2 : DistribMulAction R A₁] [inst_3 : Star A₁] [inst_4 : NonUnitalNonAssocSemiring A₂]
[inst_5 : DistribMulAction R A₂] [inst_6 : Star A₂] (e : A₁ ≃⋆ₐ[R] A₂) (x y : A₁),
e.toFun (x * y) = e.toFun x * e.... | null | false |
ClosedSubgroup.instSetLike | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [inst : Group G] → [inst_1 : TopologicalSpace G] → SetLike (ClosedSubgroup G) G | null | true |
CategoryTheory.Limits.HasTerminal.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Terminal | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.Limits.HasTerminal C = CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete PEmpty.{1}) C | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_artanh._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ x ∈ Set.Ioo (-1) 1, 0 ≤ 1 - x | null | false |
CategoryTheory.Localization.Construction.natTransExtension | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
{W : CategoryTheory.MorphismProperty C} →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{uD', uD} D] →
{F₁ F₂ : CategoryTheory.Functor W.Localization D} → (W.Q.comp F₁ ⟶ W.Q.comp F₂) → (F₁ ⟶ F₂) | If `F₁` and `F₂` are functors `W.Localization ⥤ D`, a natural transformation `F₁ ⟶ F₂`
can be obtained from a natural transformation `W.Q ⋙ F₁ ⟶ W.Q ⋙ F₂`. | true |
Filter.mem_sdiv | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} {β : Type u_3} [inst : SDiv α β] {f g : Filter β} {s : Set α},
s ∈ f /ₛ g ↔ ∃ t₁ ∈ f, ∃ t₂ ∈ g, t₁ /ₛ t₂ ⊆ s | null | true |
repeatM.Internal.eq_of_monadTail | Init.Internal.Order.While | ∀ {α : Type u} {m : Type u → Type v} [inst : Monad m] {β : Type u} [Lean.Order.MonadTail m] [inst_2 : Nonempty β]
{f : α → m (α ⊕ β)} (a : α), repeatM f a = repeatM.body f (repeatM f) a | One-step unfolding of `repeatM` for any `MonadTail m`. | true |
Computability.instDecidableEqΓ'.decEq._proof_6 | Mathlib.Computability.Encoding | ¬Computability.Γ'.blank = Computability.Γ'.comma | null | false |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.finitenessRelation._proof_2 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) [inst : String.Slice.Pattern.BackwardPattern pat]
[String.Slice.Pattern.StrictBackwardPattern pat] {it it' : Std.IterM Id (String.Slice.Pattern.SearchStep s)},
it'.IsPlausibleSuccessorOf it → InvImage WellFoundedRelation.rel (fun it => it.internalState.currPos.down) it' it | null | false |
Subgroup.normalClosure_union | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_4} [inst : Group G] (s t : Set G),
Subgroup.normalClosure (s ∪ t) = Subgroup.normalClosure s ⊔ Subgroup.normalClosure t | The normal closure of the union of sets is the join of the normal closures of each set. | true |
ModuleFilterBasis.smul_right' | Mathlib.Topology.Algebra.FilterBasis | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : TopologicalSpace R] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] (self : ModuleFilterBasis R M) (m₀ : M) {U : Set M},
U ∈ self.sets → ∀ᶠ (x : R) in nhds 0, x • m₀ ∈ U | null | true |
Homeomorph.isCompact_image | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} (h : X ≃ₜ Y),
IsCompact (⇑h '' s) ↔ IsCompact s | If `h : X → Y` is a homeomorphism, `h(s)` is compact iff `s` is. | true |
topologicalNilradical._proof_1 | Mathlib.Topology.Algebra.TopologicallyNilpotent | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommRing R], IsTopologicallyNilpotent 0 | null | false |
Std.Rio.length_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α] [Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.Rxo.HasSize α] [Std.Rxo.LawfulHasSize α] {r : Std.R... | null | true |
Std.Iter.filterMapWithPostcondition_eq_toIter_filterMapWithPostcondition_toIterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β γ : Type w} [inst : Std.Iterator α Id β] {it : Std.Iter β} {m : Type w → Type w'} [inst_1 : Monad m]
{f : β → Std.Iterators.PostconditionT m (Option γ)},
Std.Iter.filterMapWithPostcondition f it = Std.IterM.filterMapWithPostcondition f it.toIterM | null | true |
MulArchimedeanClass.instLinearOrder._proof_19 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] (b : MulArchimedeanClass M)
(a b_1 : MulArchimedeanOrder M),
(AntisymmRel.setoid (MulArchimedeanOrder M) fun x1 x2 => x1 ≤ x2) a b_1 →
Quot.indep (fun a => Quot.recOnSubsingleton b fun a_2 => Classical.propDecidable (a <... | null | false |
nontrivial_iff_exists_ne | Mathlib.Basic.Nontrivial.Defs | ∀ {α : Type u_1} (x : α), Nontrivial α ↔ ∃ y, y ≠ x | null | true |
instDecidableEqNum.decEq._proof_4 | Mathlib.Data.Num.Basic | ∀ (a : PosNum), ¬Num.pos a = Num.zero | null | false |
Lean.Meta.MVarRenaming | Lean.Meta.Match.MVarRenaming | Type | A mapping from MVarId to MVarId | true |
AddMonoidHom.tendsto_coe_cofinite_of_isDiscrete | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T1Space G] {H : Type u_2}
[inst_4 : AddGroup H] {f : H →+ G},
Function.Injective ⇑f → IsDiscrete ↑f.range → Filter.Tendsto (⇑f) Filter.cofinite (Filter.cocompact G) | null | true |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.typeHasRecFun.match_4 | Lean.Elab.MutualDef | (motive : Option Lean.Expr → Sort u_1) →
(occ? : Option Lean.Expr) →
((fvarId : Lean.FVarId) → motive (some (Lean.Expr.fvar fvarId))) → ((x : Option Lean.Expr) → motive x) → motive occ? | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape_L | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X), data.multicospanShape.L = data.I₀ | null | true |
_private.Lean.Data.NameTrie.0.Lean.toKey.loop._f | Lean.Data.NameTrie | (x : Lean.Name) →
Lean.Name.below (motive := fun x => List Lean.NamePart → List Lean.NamePart) x →
List Lean.NamePart → List Lean.NamePart | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.parseFromSymbols | Std.Time.Format.Basic | {α : Type} → Array (String × α) → Std.Internal.Parsec.String.Parser α | null | true |
List.zipWith_map_left | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {α' : Type u_3} {γ : Type u_4} {l₁ : List α} {l₂ : List β} {f : α → α'}
{g : α' → β → γ}, List.zipWith g (List.map f l₁) l₂ = List.zipWith (fun a b => g (f a) b) l₁ l₂ | null | true |
Lean.Lsp.CompletionItemKind.value.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemKind.value = 1 | null | true |
Lean.PrefixTreeNode.brecOn_3.eq | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1}
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_4 : (Std.DTreeMap.Internal.Impl α fun x... | null | true |
isClopen_connectedComponent | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {x : α}, IsClopen (connectedComponent x) | null | true |
SimpleGraph.lapMatrix_ker_basis | Mathlib.Combinatorics.SimpleGraph.LapMatrix | {V : Type u_1} →
[inst : Fintype V] →
(G : SimpleGraph V) →
[inst_1 : DecidableRel G.Adj] →
[inst_2 : DecidableEq V] →
[DecidableEq G.ConnectedComponent] →
Module.Basis G.ConnectedComponent ℝ ↥(Matrix.toLin' (SimpleGraph.lapMatrix ℝ G)).ker | `lapMatrix_ker_basis G` is a basis of the nullspace indexed by its connected components,
the basis is made up of the functions `V → ℝ` which are `1` on the vertices of the given
connected component and `0` elsewhere. | true |
NONote.ofNat | Mathlib.SetTheory.Ordinal.Notation | ℕ → NONote | Convert a natural number to an ordinal notation | true |
ContinuousOpenMapClass.casesOn | Mathlib.Topology.Hom.Open | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : FunLike F α β] →
{motive : ContinuousOpenMapClass F α β → Sort u} →
(t : ContinuousOpenMapClass F α β) →
([toContinuousMapCla... | null | false |
Matrix.IsHermitian.charpoly_cfc_eq | Mathlib.Analysis.Matrix.HermitianFunctionalCalculus | ∀ {n : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {A : Matrix n n 𝕜}
(hA : A.IsHermitian) (f : ℝ → ℝ), (cfc f A).charpoly = ∏ i, (Polynomial.X - Polynomial.C ↑(f (hA.eigenvalues i))) | null | true |
compl_bihimp_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), bihimp aᶜ a = ⊥ | null | true |
_private.Std.Sync.Notify.0.Std.Notify.notify.match_1 | Std.Sync.Notify | (motive : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit)) → Sort u_1) →
(x : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit))) →
((consumer : Std.Notify.Consumer Unit) →
(rest : Std.Queue (Std.Notify.Consumer Unit)) → motive (some (consumer, rest))) →
... | null | false |
instGradedAlgebraRestrictScalars._proof_3 | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_2} {R : Type u_3} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : CommSemiring R]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (𝒜 : ι → Submodule R A) [i : GradedAlgebra 𝒜],
Function.RightInverse (⇑(DirectSum.coeAddMonoidHom 𝒜)) DirectSum.Decomposition.decompose' | null | false |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.elabLetIDecl._regBuiltin.Lean.Elab.Term.elabLetIDecl_1 | Lean.Elab.Binders | IO Unit | null | false |
Aesop.UnsafeRuleInfo.successProbability | Aesop.Rule | Aesop.UnsafeRuleInfo → Aesop.Percent | null | true |
Lean.Parser.ppAllowUngrouped.parenthesizer | Lean.Parser.Extra | Lean.PrettyPrinter.Parenthesizer | null | true |
Stream'.WSeq.mem_think | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (s : Stream'.WSeq α) (a : α), a ∈ s.think ↔ a ∈ s | null | true |
Bitraversable.id_tsnd | Mathlib.Control.Bitraversable.Lemmas | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [LawfulBitraversable t] {α β : Type u} (x : t α β),
Bitraversable.tsnd pure x = pure x | null | true |
_private.Lean.Meta.Offset.0.Lean.Meta.getOffset | Lean.Meta.Offset | Lean.Expr → Lean.MetaM (Lean.Expr × ℕ) | Quick function for converting `e` into `s + k` s.t. `e` is definitionally equal to `Nat.add s k`.
This function always succeeds in finding such `s` and `k`
(as a last resort it returns `e` and `0`).
| true |
Lean.Meta.Grind.PendingSolverPropagations._sizeOf_inst | Lean.Meta.Tactic.Grind.Types | SizeOf Lean.Meta.Grind.PendingSolverPropagations | null | false |
MvPFunctor.wRec_eq | Mathlib.Data.PFunctor.Multivariate.W | ∀ {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {C : Sort u_1}
(g : (a : P.A) → (P.drop.B a).Arrow α → (P.last.B a → P.W α) → (P.last.B a → C) → C) (a : P.A)
(f' : (P.drop.B a).Arrow α) (f : P.last.B a → P.W α), P.wRec g (P.wMk a f' f) = g a f' f fun i => P.wRec g (f i) | Defining equation for the recursor of `W` | true |
Lean.Meta.Grind.Arith.isNatAdd? | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Option (Lean.Expr × Lean.Expr) | Returns `some (a, b)` if `e` is of the form
```
@HAdd.hAdd Nat Nat Nat (instHAdd Nat instAddNat) a b
```
| true |
Lean.SMap.mk.injEq | Lean.Data.SMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (stage₁ : Bool) (map₁ : Std.HashMap α β)
(map₂ : Lean.PHashMap α β) (stage₁_1 : Bool) (map₁_1 : Std.HashMap α β) (map₂_1 : Lean.PHashMap α β),
({ stage₁ := stage₁, map₁ := map₁, map₂ := map₂ } = { stage₁ := stage₁_1, map₁ := map₁_1, map₂ := map₂_1 }) ... | null | true |
Finset.mk_mem_sigmaLift | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
(f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (i : ι) (a : α i) (b : β i) (x : γ i),
⟨i, x⟩ ∈ Finset.sigmaLift f ⟨i, a⟩ ⟨i, b⟩ ↔ x ∈ f a b | null | true |
DMatrix.map_zero | Mathlib.Data.Matrix.DMatrix | ∀ {m : Type u_1} {n : Type u_2} {α : m → n → Type v} [inst : (i : m) → (j : n) → Zero (α i j)] {β : m → n → Type w}
[inst_1 : (i : m) → (j : n) → Zero (β i j)] {f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j},
(∀ (i : m) (j : n), f 0 = 0) → DMatrix.map 0 f = 0 | null | true |
List.continuous_prod | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MulOneClass α] [ContinuousMul α], Continuous List.prod | null | true |
WeierstrassCurve.preΨ₄._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | (4 + 1).AtLeastTwo | null | false |
MDifferentiableAt.prodMap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
AddChar.starComp_apply | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {R : Type u_1} [inst : CommRing R], 0 < ringChar R → ∀ {φ : AddChar R ℂ} (a : R), (starRingEnd ℂ) (φ a) = φ⁻¹ a | null | true |
Lean.Compiler.LCNF.UnreachableBranches.Value.bot.elim | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} →
(t : Lean.Compiler.LCNF.UnreachableBranches.Value) →
t.ctorIdx = 0 → motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.bot → motive_1 t | null | false |
CategoryTheory.SimplicialObject.Splitting.IndexSet.epiComp_fst | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {Δ₁ Δ₂ : SimplexCategoryᵒᵖ} (A : CategoryTheory.SimplicialObject.Splitting.IndexSet Δ₁) (p : Δ₁ ⟶ Δ₂)
[inst : CategoryTheory.Epi p.unop], (A.epiComp p).fst = A.fst | null | true |
_private.Mathlib.Computability.PartrecCode.0.Nat.Partrec.Code.evaln_sound._simp_1_30 | Mathlib.Computability.PartrecCode | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Set.mem_vadd_set_iff_neg_vadd_mem | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {A : Set β} {a : α} {x : β},
x ∈ a +ᵥ A ↔ -a +ᵥ x ∈ A | null | true |
Lean.SyntaxNodeKinds | Init.Prelude | Type | `SyntaxNodeKinds` is a set of `SyntaxNodeKind`, implemented as a list.
Singleton `SyntaxNodeKinds` are extremely common. They are written as name literals, rather than as
lists; list syntax is required only for empty or non-singleton sets of kinds.
| true |
WeierstrassCurve.Projective.polynomial.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Projective R),
W'.polynomial =
MvPolynomial.X 1 ^ 2 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₁ * MvPolynomial.X 0 * MvPolynomial.X 1 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₃ * MvPolynomial.X 1 * MvPolynomial.X 2 ^ 2 -
(MvPolynomial.... | null | true |
ULift.instLinearOrder._proof_3 | Mathlib.Order.Lattice | ∀ {α : Type u_2} [inst : LinearOrder α] (a b : ULift.{u_1, u_2} α), (min a b).down = min a.down b.down | null | false |
Std.DTreeMap.Internal.Impl.Equiv.constModify | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF →
t₁.Equiv t₂ →
∀ {k : α} {f : β → β},
(Std.DTreeMap.Internal.Impl.Const.modify k f t₁).Equiv (Std.DTreeMap.Internal.Impl.Const.modify k f t₂) | null | true |
MonTypeEquivalenceMon.inverse._proof_12 | Mathlib.CategoryTheory.Monoidal.Internal.Types.Basic | ∀ {X Y Z : MonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Mon.Hom.mk'
(TypeCat.ofHom ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.comp f g))) ⋯ ⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Mon.Hom.mk' (TypeCat.ofHom ⇑(CategoryTheory.ConcreteCategory.hom f)) ⋯ ⋯)
... | null | false |
nnnorm_eq_zero' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : NormedGroup E] {a : E}, ‖a‖₊ = 0 ↔ a = 1 | null | true |
UInt16.toNat_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a ^^^ b).toNat = a.toNat ^^^ b.toNat | null | true |
List.countP_lt_length_iff._simp_1 | Mathlib.Data.List.Count | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, (List.countP p l < l.length) = ∃ a ∈ l, p a = false | null | false |
ZeroAtInftyContinuousMap.instAddZeroClass._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddZeroClass β]
[inst_3 : ContinuousAdd β] (a : ZeroAtInftyContinuousMap α β), a + 0 = a | null | false |
CompleteLatticeHomClass.toFrameHomClass | Mathlib.Order.Hom.CompleteLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
[inst_2 : CompleteLattice β] [CompleteLatticeHomClass F α β], FrameHomClass F α β | null | true |
zpow_right_strictAnti | Mathlib.Algebra.Order.Group.Basic | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] {a : α},
a < 1 → StrictAnti fun n => a ^ n | null | true |
ProperlyDiscontinuousVAdd.rec | Mathlib.Topology.Algebra.ConstMulAction | {Γ : Type u_4} →
{T : Type u_5} →
[inst : TopologicalSpace T] →
[inst_1 : VAdd Γ T] →
{motive : ProperlyDiscontinuousVAdd Γ T → Sort u} →
((finite_disjoint_inter_image :
∀ {K L : Set T}, IsCompact K → IsCompact L → {γ | ((fun x => γ +ᵥ x) '' K ∩ L).Nonempty}.Finite) →
... | null | false |
instDecidableEqQuadraticAlgebra.decEq.match_1 | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} →
{a b : R} →
(motive : QuadraticAlgebra R a b → QuadraticAlgebra R a b → Sort u_2) →
(x x_1 : QuadraticAlgebra R a b) →
((a_1 a_2 b_1 b_2 : R) → motive { re := a_1, im := a_2 } { re := b_1, im := b_2 }) → motive x x_1 | null | false |
CategoryTheory.Functor.relativelyRepresentable.w | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X Y : D} {f : X ⟶ Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a ⟶ Y),
CategoryTheory.CategoryStruct.comp (hf.fst g) f = CategoryTheory.CategoryStruct... | null | true |
Set.zero_smul_set_subset | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] (s : Set β), 0 • s ⊆ 0 | null | true |
Algebra.FormallyUnramified.of_surjective | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.FormallyUnramified R A] (f : A →ₐ[R] B),
Function.Surjective ⇑f → Algebra.FormallyUnramified R B | This holds in general for epimorphisms. | true |
Int.bmod_eq_self_sub_bdiv_mul | Init.Data.Int.DivMod.Lemmas | ∀ (x : ℤ) (m : ℕ), x.bmod m = x - x.bdiv m * ↑m | null | true |
LieAdmissibleAlgebra.toModule | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | {R : Type u_1} →
{L : Type u_2} → {inst : CommRing R} → {inst_1 : LieAdmissibleRing L} → [self : LieAdmissibleAlgebra R L] → Module R L | null | true |
_private.Mathlib.AlgebraicGeometry.Birational.Composition.0.AlgebraicGeometry.Scheme.PartialMap.comp._simp_1 | Mathlib.AlgebraicGeometry.Birational.Composition | ∀ {α : Type u_1} {β : Type u_2} {s : Set β} {f : α → β}, (s ∩ Set.range f).Nonempty = (f ⁻¹' s).Nonempty | null | false |
BesselPotentialSpace.instAddCommGroup._proof_1 | Mathlib.Analysis.FunctionalSpaces.BesselPotentialSpace | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : FiniteDimensional ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E]
[inst_6 : CompleteSpace F] [inst_7 : NormedSpace ℂ F] {s : ℝ} {p : ENNReal} [hp : Fact (1 ≤ p)]
(a b ... | null | false |
CategoryTheory.Abelian.SpectralObject.kernelSequenceE._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₃ : k ⟶ l) (n₁ n₂ : ℤ),
CategoryTheory.Limits.HasBinaryBiproduct ((X.H n₁).... | null | false |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_1 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} (motive : Turing.TM0to1.Λ' Γ Λ → Sort u_3) (q : Λ)
(h_1 : (q : Λ) → motive (Turing.TM0to1.Λ'.normal q))
(h_2 : (d : Turing.Dir) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.move d) q))
(h_3 : (a : Γ) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.write a) q)... | null | true |
Bundle.Trivialization.piecewise._proof_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_2} {F : Type u_3} {Z : Type u_1} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e e' : Bundle.Trivialization F proj) (s : Set B),
e.baseSet ∩ frontier s = e'.baseSet ∩ frontier s →
e.source ∩ frontier (proj ⁻¹' s) = e'.source ∩ frontier (pro... | null | false |
Std.TreeSet.Raw.max?_le_max?_insert | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k km kmi : α},
t.max? = some km → (t.insert k).max?.get ⋯ = kmi → (cmp km kmi).isLE = true | null | true |
ContinuousOn.cpow | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f g : α → ℂ} {s : Set α},
ContinuousOn f s → ContinuousOn g s → (∀ a ∈ s, f a ∈ Complex.slitPlane) → ContinuousOn (fun x => f x ^ g x) s | null | true |
Std.Async.IO.AsyncRead.rec | Std.Async.IO | {α β : Type} →
{motive : Std.Async.IO.AsyncRead α β → Sort u} →
((read : α → Std.Async.Async β) → motive { read := read }) → (t : Std.Async.IO.AsyncRead α β) → motive t | null | false |
AddCircle.equivIco | Mathlib.Topology.Instances.AddCircle.Defs | {𝕜 : Type u_1} →
[inst : AddCommGroup 𝕜] →
(p : 𝕜) →
[inst_1 : LinearOrder 𝕜] →
[IsOrderedAddMonoid 𝕜] → [hp : Fact (0 < p)] → (a : 𝕜) → [Archimedean 𝕜] → AddCircle p ≃ ↑(Set.Ico a (a + p)) | The equivalence between `AddCircle p` and the half-open interval `[a, a + p)`, whose inverse
is the natural quotient map. | true |
_private.Std.Time.Date.ValidDate.0.PSigma.casesOn._arg_pusher | Std.Time.Date.ValidDate | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
Mathlib.Util.«_aux_Mathlib_Util_CompileInductive___elabRules_Mathlib_Util_commandCompile_def%__1» | Mathlib.Util.CompileInductive | Lean.Elab.Command.CommandElab | `compile_def% Foo.foo` adds compiled code for the definition `Foo.foo`.
This can be used for type class projections or definitions like `List._sizeOf_1`,
for which Lean does not generate compiled code by default
(since it is not used 99% of the time).
| false |
Int32.toInt_not | Init.Data.SInt.Bitwise | ∀ (a : Int32), (~~~a).toInt = (-a.toInt - 1).bmod (2 ^ 32) | null | true |
PointedCone.lineal._proof_4 | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] [IsOrderedRing R], PosMulMono R | null | false |
SubMulAction.subtype_eq_val | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] (p : SubMulAction R M), ⇑p.subtype = Subtype.val | null | true |
Lean.Elab.Term.State.mk.injEq | Lean.Elab.Term.TermElabM | ∀ (levelNames : List Lean.Name) (syntheticMVars : Lean.MVarIdMap Lean.Elab.Term.SyntheticMVarDecl)
(pendingMVars : List Lean.MVarId) (mvarErrorInfos : List Lean.Elab.Term.MVarErrorInfo)
(levelMVarErrorInfos : List Lean.Elab.Term.LevelMVarErrorInfo) (mvarArgNames : Lean.MVarIdMap Lean.Name)
(letRecsToLift : List L... | null | true |
Polynomial.Monic.degree_le_zero_iff_eq_one | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → (p.degree ≤ 0 ↔ p = 1) | null | true |
_private.Mathlib.Algebra.Lie.Basis.Prod.0.LieAlgebra.Basis.prodH | Mathlib.Algebra.Lie.Basis.Prod | {ι₁ : Type u_1} →
{ι₂ : Type u_2} →
{L₁ : Type u_3} →
{L₂ : Type u_4} →
[inst : Finite ι₁] →
[inst_1 : Finite ι₂] →
(eι : ι₁ ≃ ι₂) →
[inst_2 : LieRing L₁] →
[inst_3 : LieRing L₂] →
{R : Type u_5} →
[inst_4 : Co... | null | true |
Ordinal.nfp_mul_eq_opow_omega0 | Mathlib.SetTheory.Ordinal.FixedPoint | ∀ {a b : Ordinal.{u_1}}, 0 < b → b ≤ a ^ Ordinal.omega0 → Ordinal.nfp (fun x => a * x) b = a ^ Ordinal.omega0 | null | true |
instFullWitness | Mathlib.CategoryTheory.UnivLE | ∀ [inst : UnivLE.{max u v, v}], UnivLE.witness.Full | null | true |
_private.Mathlib.Topology.ContinuousMap.CompactlySupported.0.CompactlySupportedContinuousMap.nnrealPart_smul_neg._simp_1_2 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {R : Type u} [inst : Semiring R] [inst_1 : Preorder R] {a b : R} [ExistsAddOfLE R] [MulPosMono R] [AddRightMono R]
[AddRightReflectLE R], a ≤ 0 → b ≤ 0 → (0 ≤ a * b) = True | null | false |
Lean.Parser.ParserExtension.Entry.category.sizeOf_spec | Lean.Parser.Extension | ∀ (catName declName : Lean.Name) (behavior : Lean.Parser.LeadingIdentBehavior),
sizeOf (Lean.Parser.ParserExtension.Entry.category catName declName behavior) =
1 + sizeOf catName + sizeOf declName + sizeOf behavior | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.