name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
selfAdjointPart_apply_coe | Mathlib.Algebra.Star.Module | ∀ (R : Type u_1) {A : Type u_2} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (x : A), ↑((selfAdjointPart R) x) = ⅟2 • (x + star x) | null | true |
_private.Batteries.Data.List.Lemmas.0.List.findIdxNth_countPBefore_of_lt_length_of_pos._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (head : α) (tail : List α) {i : ℕ} {h : i < (head :: tail).length}, i < (head :: tail).length | null | false |
Set.uIoo_subset_Ioo | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
a₁ ∈ Set.Icc a₂ b₂ → b₁ ∈ Set.Icc a₂ b₂ → Set.uIoo a₁ b₁ ⊆ Set.Ioo a₂ b₂ | null | true |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.elabMutual._regBuiltin.Lean.Elab.Command.elabMutual_1 | Lean.Elab.Declaration | IO Unit | null | false |
NonUnitalAlgHomClass | Mathlib.Algebra.Algebra.NonUnitalHom | (F : Type u_1) →
(R : outParam (Type u_2)) →
(A : outParam (Type u_3)) →
(B : outParam (Type u_4)) →
[inst : Monoid R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : NonUnitalNonAssocSemiring B] →
[DistribMulAction R A] → [DistribMulAction R B] → [FunLike F ... | `NonUnitalAlgHomClass F R A B` asserts `F` is a type of bundled algebra homomorphisms
from `A` to `B` which are `R`-linear.
This is an abbreviation to `NonUnitalAlgSemiHomClass F (MonoidHom.id R) A B` | true |
AddSubgroup.unop_injective | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_2} [inst : AddGroup G], Function.Injective AddSubgroup.unop | null | true |
instAssociativeUInt32HMul | Init.Data.UInt.Lemmas | Std.Associative fun x1 x2 => x1 * x2 | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.borrowed._regBuiltin.Lean.Parser.Term.borrowed.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
_private.Lean.Level.0.Lean.Level.geq.go._sparseCasesOn_2 | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) →
((a : Lean.Level) → motive a.succ) → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t | null | false |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.sle_iff_rotate_le_rotate._proof_1_11 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (n : ℕ) (x y : BitVec (n + 1)), ¬(x.toNat ≤ y.toNat ↔ x.toNat + 2 ^ n ≤ y.toNat + 2 ^ n) → False | null | false |
List.flatten_nil | Init.Data.List.Basic | ∀ {α : Type u}, [].flatten = [] | null | true |
List.Cursor.pos_le_length | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {c : l.Cursor}, c.pos ≤ l.length | null | true |
Lean.Meta.Grind.MethodsRef | Lean.Meta.Tactic.Grind.Types | Type | null | true |
CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf_obj_a | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (adj : F ⊣ G)
(V : CategoryTheory.Endofunctor.Coalgebra G),
((CategoryTheory.Endofunctor.Adjunction.Coalgebra.toAlgebraOf adj).obj V).a = V.V | null | true |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_3 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace γ]
(f : α × β → γ) {s : Set α} {t : Set β} (x : α) (y : β) (ε : ENNReal) (δ : NNReal) (x' a : α) (b : β)
(motive : (a, b) ∈ (s ∩ Metric.eball x ↑δ) ×ˢ (t ∩ {b | edist (f (x', b)) (f (x', y)) ≤ ε / 2}) → Prop)
... | null | false |
Submodule.mul_iSup | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : Semiring R] {A : Type v} [inst_1 : Semiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] {ι : Sort uι} (t : Submodule R A) (s : ι → Submodule R A), t * ⨆ i, s i = ⨆ i, t * s i | null | true |
Finset.univ_val_map_subtype_restrict | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] (f : α → β) (p : α → Prop) [inst_1 : DecidablePred p]
[inst_2 : Fintype { a // p a }],
Multiset.map (Subtype.restrict p f) Finset.univ.val = Multiset.map f (Finset.filter p Finset.univ).val | null | true |
Nat.orderEmbeddingOfSet_range | Mathlib.Order.OrderIsoNat | ∀ (s : Set ℕ) [inst : Infinite ↑s] [inst_1 : DecidablePred fun x => x ∈ s], Set.range ⇑(Nat.orderEmbeddingOfSet s) = s | null | true |
_private.Mathlib.Combinatorics.Enumerative.Schroder.0.Nat.smallSchroder.match_1.eq_2 | Mathlib.Combinatorics.Enumerative.Schroder | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ),
(match 1 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ => h_3 n) =
h_2 () | null | true |
Filter.HasBasis.forall_mem_mem | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {ι : Sort u_4} {l : Filter α} {p : ι → Prop} {s : ι → Set α},
l.HasBasis p s → ∀ {x : α}, (∀ t ∈ l, x ∈ t) ↔ ∀ (i : ι), p i → x ∈ s i | null | true |
HasCompactMulSupport.uniformContinuous_of_continuous | Mathlib.Topology.UniformSpace.HeineCantor | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β} [inst_2 : One β],
HasCompactMulSupport f → Continuous f → UniformContinuous f | null | true |
PresheafOfModules.sections.eval | Mathlib.Algebra.Category.ModuleCat.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} → {M : PresheafOfModules R} → M.sections → (X : Cᵒᵖ) → ↑(M.obj X) | Given a presheaf of modules `M`, `s : M.sections` and `X : Cᵒᵖ`, this is the induced
element in `M.obj X`. | true |
_private.Mathlib.Combinatorics.Graph.Subgraph.0.Graph.IsLink.anti_of_mem | Mathlib.Combinatorics.Graph.Subgraph | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G H : Graph α β},
G.IsLink e x y → H ≤ G → e ∈ H.edgeSet → H.IsLink e x y | null | true |
Lean.OptionDecl.mk.injEq | Lean.Data.Options | ∀ (name : Lean.Name) (declName : autoParam Lean.Name Lean.OptionDecl.declName._autoParam) (defValue : Lean.DataValue)
(descr : String) (deprecation? : Option Lean.OptionDeprecation) (name_1 : Lean.Name)
(declName_1 : autoParam Lean.Name Lean.OptionDecl.declName._autoParam) (defValue_1 : Lean.DataValue)
(descr_1 :... | null | true |
isGδ_induced | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Continuous f → IsGδ s → IsGδ (f ⁻¹' s) | **Alias** of `IsGδ.preimage`.
---
The preimage of a Gδ set under a continuous map is Gδ. | true |
Cardinal.zero_lt_lift_iff | Mathlib.SetTheory.Cardinal.Order | ∀ {a : Cardinal.{u}}, 0 < Cardinal.lift.{v, u} a ↔ 0 < a | null | true |
_private.Mathlib.Analysis.BoxIntegral.Basic.0.BoxIntegral.integrable_of_bounded_and_ae_continuousWithinAt._simp_1_5 | Mathlib.Analysis.BoxIntegral.Basic | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t | null | false |
add_dotProduct | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring α] (u v w : m → α),
(u + v) ⬝ᵥ w = u ⬝ᵥ w + v ⬝ᵥ w | null | true |
Lean.Lsp.SymbolKind.boolean | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolKind | null | true |
WittVector.eval | Mathlib.RingTheory.WittVector.Defs | {p : ℕ} →
{R : Type u_1} → [CommRing R] → {k : ℕ} → (ℕ → MvPolynomial (Fin k × ℕ) ℤ) → (Fin k → WittVector p R) → WittVector p R | Let `φ` be a family of polynomials, indexed by natural numbers, whose variables come from the
disjoint union of `k` copies of `ℕ`, and let `xᵢ` be a Witt vector for `0 ≤ i < k`.
`eval φ x` evaluates `φ` mapping the variable `X_(i, n)` to the `n`th coefficient of `xᵢ`.
Instantiating `φ` with certain polynomials define... | true |
SSet.Subcomplex.PairingCore.RankFunction._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} → {h : A.PairingCore} → {α : Type v} → {inst : PartialOrder α} → [SizeOf α] → h.RankFunction α → ℕ | null | false |
Lean.Level.PP.Context._sizeOf_inst | Lean.Level | SizeOf Lean.Level.PP.Context | null | false |
Std.TreeMap.getEntryGT? | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → Option (α × β) | Tries to retrieve the key-value pair with the smallest key that is greater than the given key,
returning `none` if no such pair exists.
| true |
UniformSpace.Completion.ring._proof_11 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : UniformSpace α] [IsTopologicalRing α] [inst_3 : IsUniformAddGroup α] (a : α),
↑a * 1 = ↑a | null | false |
CentroidHom.coe_sub._simp_1 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocRing α] (f g : CentroidHom α), ⇑f - ⇑g = ⇑(f - g) | null | false |
Cube.insertAt_boundary | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} [inst : DecidableEq N] (i : N) {t₀ : ↑unitInterval} {t : { j // j ≠ i } → ↑unitInterval},
(t₀ = 0 ∨ t₀ = 1) ∨ t ∈ Cube.boundary { j // j ≠ i } → (Cube.insertAt i) (t₀, t) ∈ Cube.boundary N | null | true |
CategoryTheory.Limits.Cofork.π.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y} (t : CategoryTheory.Limits.Cofork f g),
t.π = t.ι.app CategoryTheory.Limits.WalkingParallelPair.one | null | true |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._unary._proof_2 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin as.size), ↑lo < as.size | null | false |
_private.Mathlib.Data.NNReal.Defs.0.NNReal.iSup_eq_zero._simp_1_2 | Mathlib.Data.NNReal.Defs | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a = ⊥) = (a ≤ ⊥) | null | false |
Std.Iterators.Types.DropWhile.recOn | Std.Data.Iterators.Combinators.Monadic.DropWhile | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} →
{motive : Std.Iterators.Types.DropWhile α m β P → Sort u} →
(t : Std.Iterators.Types.DropWhile α m β P) →
((dropping : Bool) → (inner : Std.IterM m β) → motive ... | null | false |
Semiring.toGrindSemiring._proof_15 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (x : ℕ), OfNat.ofNat x = ↑x | null | false |
_private.Mathlib.Algebra.Order.Group.DenselyOrdered.0.exists_mul_left_lt | Mathlib.Algebra.Order.Group.DenselyOrdered | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LT α] [DenselyOrdered α] [MulRightStrictMono α] {a b c : α},
a * b < c → ∃ a' > a, a' * b < c | null | true |
Filter.Tendsto.div_const | Mathlib.Topology.Algebra.GroupWithZero | ∀ {α : Type u_1} {G₀ : Type u_3} [inst : DivInvMonoid G₀] [inst_1 : TopologicalSpace G₀] [SeparatelyContinuousMul G₀]
{f : α → G₀} {l : Filter α} {x : G₀},
Filter.Tendsto f l (nhds x) → ∀ (y : G₀), Filter.Tendsto (fun a => f a / y) l (nhds (x / y)) | null | true |
CategoryTheory.Limits.CategoricalPullback.comp_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {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 : CategoryTheory.Functor C B}
{X Y Z : CategoryTheory.Limits.CategoricalPullback F G} (f : X.Hom Y... | null | true |
_private.Lean.LibrarySuggestions.Basic.0.Lean.LibrarySuggestions.Selector.intersperse._proof_5 | Lean.LibrarySuggestions.Basic | ∀ (c : Lean.LibrarySuggestions.Config) (suggestions₁ : Array Lean.LibrarySuggestions.Suggestion)
(__s : Array Lean.LibrarySuggestions.Suggestion × ℕ),
__s.2 < suggestions₁.size ∧ __s.1.size < c.maxSuggestions → ¬__s.2 < suggestions₁.size → False | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.theorem.parenthesizer_267 | Lean.Parser.Command | IO Unit | null | false |
CategoryTheory.MorphismProperty.IsStableUnderBaseChangeAgainst.isStableUnderBaseChangeAlong | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P P' : CategoryTheory.MorphismProperty C}
[self : P.IsStableUnderBaseChangeAgainst P'] ⦃X Y : C⦄ (f : X ⟶ Y), P' f → P.IsStableUnderBaseChangeAlong f | null | true |
TensorProduct.Algebra.module._proof_7 | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type u_4} {A : Type u_2} {B : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | null | false |
Lean.Compiler.LCNF.instInhabitedFunDecl.default_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.FunDecl pu | null | true |
CategoryTheory.Bicategory.InducedBicategory.forget._proof_9 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b c : CategoryTheory.Bicategory.InducedBicategory C F} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c),
(CategoryTheory.Bicategory.whiskerRight η g).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯)
(CategoryTheo... | null | false |
ModuleCat.smul._proof_10 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] (M : ModuleCat R) (r s : R),
AddCommGrpCat.ofHom { toFun := fun m => (r * s) • m, map_zero' := ⋯, map_add' := ⋯ } =
AddCommGrpCat.ofHom { toFun := fun m => r • m, map_zero' := ⋯, map_add' := ⋯ } *
AddCommGrpCat.ofHom { toFun := fun m => s • m, map_zero' := ⋯, map_add' := ⋯ } | null | false |
Lean.Doc.Inline.concat.sizeOf_spec | Lean.DocString.Types | ∀ {i : Type u} [inst : SizeOf i] (content : Array (Lean.Doc.Inline i)),
sizeOf (Lean.Doc.Inline.concat content) = 1 + sizeOf content | null | true |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.exists_eq | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u} [inst : CategoryTheory.Category.{u, u} I] {S X : AlgebraicGeometry.Scheme}
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} {t : D ⟶ (CategoryTheory.Functor.const I).obj S} {f : X ⟶ S}
[inst_1 : ∀ (i : I), CompactSpace ↥(D.obj i)] [AlgebraicGeometry.LocallyOfFiniteType f]
[inst_3 : CategoryT... | null | true |
SemiRingCat.forget₂AddCommMonPreservesLimitsAux | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J SemiRingCat) →
[inst_1 : Small.{u, max u v} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] →
CategoryTheory.Limits.IsLimit
((CategoryTheory.forget₂ SemiRingCat AddCommMonCat).mapCone (SemiRing... | Auxiliary lemma to prove the cone induced by `limitCone` is a limit cone.
| true |
QuadraticForm.toMatrix._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N],
SMulCommClass R R (N →ₗ[R] R) | null | false |
_private.Std.Data.String.ToInt.0.String.Slice.toInt?_eq_some_iff._simp_1_4 | Std.Data.String.ToInt | ∀ {α : Type u_1} {b : α} {α_1 : Type u_2} {x : Option α_1} {f : α_1 → α},
(Option.map f x = some b) = ∃ a, x = some a ∧ f a = b | null | false |
Finset.mulAction._proof_1 | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] [inst_1 : Monoid α] [inst_2 : MulAction α β] (s : Finset β),
Finset.image (fun b => 1 • b) s = s | null | false |
Function.surjective_iff_hasRightInverse | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {f : α → β}, Function.Surjective f ↔ Function.HasRightInverse f | null | true |
ContinuousWithinAt.congr_of_eventuallyEq | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f g : α → β} {s : Set α}
{x : α}, ContinuousWithinAt f s x → g =ᶠ[nhdsWithin x s] f → g x = f x → ContinuousWithinAt g s x | null | true |
Std.TreeMap.Raw.le_maxKeyD_of_contains | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, t.contains k = true → ∀ {fallback : α}, (cmp k (t.maxKeyD fallback)).isLE = true | null | true |
Mathlib.Tactic.AtomM.RecurseM | Mathlib.Util.AtomM.Recurse | Type → Type | The monad for `AtomM.Recurse` contains, in addition to the `AtomM` state,
a simp context for the main traversal and a cleanup function to simplify evaluation results. | true |
SemidirectProduct.mulEquivSubgroup_symm_apply | Mathlib.GroupTheory.SemidirectProduct | ∀ {G : Type u_2} [inst : Group G] {H K : Subgroup G} [inst_1 : H.Normal] (h : H.IsComplement' K) (b : G),
(SemidirectProduct.mulEquivSubgroup h).symm b = Function.surjInv ⋯ b | null | true |
CategoryTheory.SpectralSequence.Hom.noConfusion | Mathlib.Algebra.Homology.SpectralSequence.Basic | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Abelian C} →
{κ : Type u_2} →
{c : ℤ → ComplexShape κ} →
{r₀ : ℤ} →
{E E' : CategoryTheory.SpectralSequence C c r₀} →
{t : E.Hom E'} →
... | null | false |
_private.Mathlib.RingTheory.Ideal.KrullsHeightTheorem.0.Ideal.mem_minimalPrimes_span_of_mem_minimalPrimes_span_insert.match_1_2 | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] (x : R) (t : Set R) (f : R →+* R ⧸ Ideal.span t) (r : Ideal (R ⧸ Ideal.span t))
(motive : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r → Prop) (x_1 : r.IsPrime ∧ Ideal.map f (Ideal.span {x}) ≤ r),
(∀ (hr : r.IsPrime) (hxr : Ideal.map f (Ideal.span {x}) ≤ r), motive ⋯) → motive x... | null | false |
PadicInt.mahlerSeries._proof_1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {E : Type u_1} [inst : NormedAddCommGroup E], ContinuousAdd E | null | false |
SheafOfModules.LocalGeneratorsData.quasiCoherentData._proof_6 | Mathlib.Algebra.Category.ModuleCat.Sheaf.LocallyFree | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat}
[inst_1 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)]
[inst_2 : ∀ (X : C), CategoryTheory.HasSheafify (J.over X) AddCommGrpCat]
... | null | false |
Std.Http.Protocol.H1.Reader.BodyState._sizeOf_1 | Std.Http.Protocol.H1.Reader | Std.Http.Protocol.H1.Reader.BodyState → ℕ | null | false |
AddOreLocalization.instAddMonoid | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} →
[inst : AddMonoid R] →
{S : AddSubmonoid R} → [inst_1 : AddOreLocalization.AddOreSet S] → AddMonoid (AddOreLocalization S R) | null | true |
Std.DTreeMap.Raw.getKey_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} (h' : k ∈ t), t.getKey k h' = k | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.range_glueDataObjι_ι | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (U : ↑X.affineOpens),
Set.range ⇑(CategoryTheory.CategoryStruct.comp (I.glueDataObjι U) (↑U).ι) = X.zeroLocus ↑(I.ideal U) ∩ ↑↑U | null | true |
Lean.Widget.instAppendInteractiveGoals | Lean.Widget.InteractiveGoal | Append Lean.Widget.InteractiveGoals | null | true |
Std.Internal.List.contains_insertList_iff | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) = true ↔
Std.Internal.List.containsKey k l = true ∨ Std.Internal.List.containsKey k toInsert = true | null | true |
instInhabitedTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(M : Type u_2) → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Inhabited (TensorAlgebra R M) | null | true |
m_Birkhoff_inequalities | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b c : α),
|(a ⊔ c) / (b ⊔ c)|ₘ ⊔ |(a ⊓ c) / (b ⊓ c)|ₘ ≤ |a / b|ₘ | null | true |
_private.Lean.Meta.Sym.Arith.Reify.0.Lean.Meta.Sym.Arith.reifyRing?.go._sparseCasesOn_7 | Lean.Meta.Sym.Arith.Reify | {motive : Lean.Literal → Sort u} →
(t : Lean.Literal) →
((val : ℕ) → motive (Lean.Literal.natVal val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.TypeVec.0.TypeVec.toSubtype'.match_1.eq_1 | Mathlib.Data.TypeVec | ∀
(motive :
(n : ℕ) →
(α : TypeVec.{u_1} n) →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
(x : Fin2 n) → { x_1 // TypeVec.ofRepeat (p x (TypeVec.prod.mk x x_1.1 x_1.2)) } → Sort u_2)
(n : ℕ) (α : TypeVec.{u_1} (n + 1)) (p : (α.prod α).Arrow (TypeVec.repeat (n + 1) Prop)) (i : Fin2 n... | null | true |
List.eraseIdx_eq_take_drop_succ | Init.Data.List.Erase | ∀ {α : Type u_1} (l : List α) (i : ℕ), l.eraseIdx i = List.take i l ++ List.drop (i + 1) l | null | true |
AntitoneOn._to_dual_cast_1 | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] (f : α → β) (s : Set α),
AntitoneOn f s = ∀ ⦃a : α⦄, a ∈ s → ∀ ⦃b : α⦄, b ∈ s → a ≤ b → f b ≤ f a | null | false |
Inv.mk | Init.Prelude | {α : Type u} → (α → α) → Inv α | null | true |
UniformContinuousConstSMul.mk | Mathlib.Topology.Algebra.UniformMulAction | ∀ {M : Type v} {X : Type x} [inst : UniformSpace X] [inst_1 : SMul M X],
(∀ (c : M), UniformContinuous fun x => c • x) → UniformContinuousConstSMul M X | null | true |
AddSubgroup.relIindex_dvd_two_iff' | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, H.relIndex K ∣ 2 ↔ ∃ a ∈ K, ∀ b ∈ K, a + b ∈ H ∨ b ∈ H | Relative version of `AddSubgroup.index_dvd_two_iff'`. | true |
_private.Lean.Elab.Tactic.SolveByElim.0.Lean.Elab.Tactic.SolveByElim.elabConfig.evalConfigItem | Lean.Elab.Tactic.SolveByElim | Lean.Elab.ConfigEval.EvalConfigItem Lean.Meta.SolveByElim.SolveByElimConfig | null | true |
Int.fdiv.eq_5 | Init.Data.Int.DivMod.Basic | ∀ (m n : ℕ), (Int.negSucc m).fdiv (Int.ofNat n.succ) = Int.negSucc (m / n.succ) | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.unsat_of_encounteredBoth._proof_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {n : ℕ} (assignment : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
(if l.2 = true then Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToUnit l
else Std.Tactic.BVDecide.LRAT.Internal.ReduceResult.reducedToEmpty) =
Std.Tac... | null | false |
Char.ofUInt8.eq_1 | Std.Http.Data.URI.Encoding | ∀ (n : UInt8), Char.ofUInt8 n = { val := n.toUInt32, valid := ⋯ } | null | true |
LinearIsometryEquiv.toSpanUnitSingleton._proof_4 | Mathlib.Analysis.Normed.Module.Span | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜], IsDomain 𝕜 | null | false |
_private.Lean.Meta.Tactic.Grind.Order.Internalize.0.Lean.Meta.Grind.Order.adaptNat.adaptCnstr.match_1 | Lean.Meta.Tactic.Grind.Order.Internalize | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((rhs' h₂ : Lean.Expr) → motive (rhs', h₂)) → motive x | null | false |
Geometry.SimplicialComplex.ofAffineIndependent._proof_2 | Mathlib.Analysis.Convex.SimplicialComplex.AffineIndependentUnion | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : Field 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
(abstract : PreAbstractSimplicialComplex E),
AffineIndependent 𝕜 Subtype.val → ∀ {s : Finset E}, s ∈ abstract.faces → AffineIndependent 𝕜 fun x => ↑x | null | false |
String.Slice.instDecidableEqPos.decEq | Init.Data.String.Defs | {s : String.Slice} → (x x_1 : s.Pos) → Decidable (x = x_1) | null | true |
CategoryTheory.MonoidalOpposite.tensorIso | Mathlib.CategoryTheory.Monoidal.Opposite | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.MonoidalCategory.tensor Cᴹᵒᵖ ≅
((CategoryTheory.unmopFunctor C).prod (CategoryTheory.unmopFunctor C)).comp
((CategoryTheory.Prod.swap C C).comp
((Category... | The identification `mop X ⊗ mop Y = mop (Y ⊗ X)` as a natural isomorphism. | true |
Lean.mkBRecOn | Lean.Meta.Constructions.BRecOn | Lean.Name → Lean.MetaM Unit | null | true |
lp.holderₗ._proof_1 | Mathlib.Analysis.Normed.Lp.lpHolder | ∀ {ι : Type u_3} {𝕜 : Type u_1} {E : ι → Type u_2} [inst : RCLike 𝕜] [inst_1 : (i : ι) → NormedAddCommGroup (E i)]
[inst_2 : (i : ι) → NormedSpace 𝕜 (E i)] (i : ι), IsBoundedSMul 𝕜 (E i) | null | false |
tsum_geometric_of_lt_one | Mathlib.Analysis.SpecificLimits.Basic | ∀ {r : ℝ}, 0 ≤ r → r < 1 → ∑' (n : ℕ), r ^ n = (1 - r)⁻¹ | null | true |
Lean.Grind.instCommRingUSize._proof_3 | Init.GrindInstances.Ring.UInt | ∀ (i : ℤ) (a : USize), -i • a = -(i • a) | null | false |
IsSimpleRing.exists_algEquiv_matrix_of_isAlgClosed | Mathlib.RingTheory.SimpleModule.IsAlgClosed | ∀ (F : Type u_1) (R : Type u_2) [inst : Field F] [IsAlgClosed F] [inst_2 : Ring R] [inst_3 : Algebra F R]
[IsSimpleRing R] [FiniteDimensional F R], ∃ n, ∃ (_ : NeZero n), Nonempty (R ≃ₐ[F] Matrix (Fin n) (Fin n) F) | The **Wedderburn–Artin Theorem** over algebraically closed fields: a finite-dimensional
simple algebra over an algebraically closed field is isomorphic to a matrix algebra over the field.
| true |
Lean.Parser.Command.docs_to_verso.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
ProbabilityTheory.condExp_prod_ae_eq_integral_condDistrib₀ | Mathlib.Probability.Kernel.CondDistrib | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {F : Type u_4} [inst : MeasurableSpace Ω] [inst_1 : StandardBorelSpace Ω]
[inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F] {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_4 : MeasureTheory.IsFiniteMeasure μ] {X : α → β} {Y : α → Ω} {mβ : MeasurableSpa... | The conditional expectation of a function `f` of the product `(X, Y)` is almost everywhere equal
to the integral of `y ↦ f(X, y)` against the `condDistrib` kernel. | true |
Submodule.ker_subtype | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), p.subtype.ker = ⊥ | null | true |
OrderEmbedding.locallyFiniteOrder | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} →
{β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [LocallyFiniteOrder β] → α ↪o β → LocallyFiniteOrder α | Given an order embedding `α ↪o β`, pulls back the `LocallyFiniteOrder` on `β` to `α`. | true |
AddSubsemigroup.mem_inf._simp_1 | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {p p' : AddSubsemigroup M} {x : M}, (x ∈ p ⊓ p') = (x ∈ p ∧ x ∈ p') | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.