name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Array.Lemmas.0.List.filterMap_replicate.match_1.splitter | Init.Data.Array.Lemmas | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((b : β) → motive (some b)) → motive x | null | true |
IsSimpleRing.one_mem_of_ne_bot | Mathlib.RingTheory.SimpleRing.Basic | ∀ {A : Type u_2} [inst : NonAssocRing A] [IsSimpleRing A] (I : TwoSidedIdeal A), I ≠ ⊥ → 1 ∈ I | null | true |
Lean.version.major | Init.Meta.Defs | ℕ | null | true |
_private.Mathlib.AlgebraicGeometry.Sites.Etale.0.AlgebraicGeometry.Scheme.ofArrows_mem_smallEtaleTopology_iff._simp_1_3 | Mathlib.AlgebraicGeometry.Sites.Etale | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_left_injective._simp_1_1 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {x y : Fin (n + 1)}, (y ≠ x) = ∃ z, x.succAbove z = y | null | false |
CategoryTheory.Presheaf.IsLocallyInjective.mk._flat_ctor | Mathlib.CategoryTheory.Sites.LocallyInjective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{FD : D → D → Type u_1} {CD : D → Type w} [inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (CD Y)]
[inst_3 : CategoryTheory.ConcreteCategory D FD] {J : CategoryTheory.GrothendieckTopology C}
{F₁ F₂ : ... | null | false |
Subgroup.mem_lowerCentralSeries_succ_iff | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] (S : Subgroup G) (n : ℕ) (q : G),
q ∈ S.lowerCentralSeries (n + 1) ↔ q ∈ Subgroup.closure {x | ∃ p ∈ S.lowerCentralSeries n, ∃ q ∈ S, ⁅p, q⁆ = x} | null | true |
PointedCone.ofSubmodule_lineal | Mathlib.Geometry.Convex.Cone.Pointed | ∀ {R : Type u_1} {E : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedRing R]
[inst_3 : AddCommGroup E] [inst_4 : Module R E] (C : PointedCone R E), ↑C.lineal = C ⊓ -C | null | true |
_private.Mathlib.Data.W.Basic.0.WType.finv | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} →
[inst : (a : α) → Fintype (β a)] → (n : ℕ) → (a : α) × (β a → WType.WType'✝ β n) → WType.WType'✝ β (n + 1) | null | true |
CategoryTheory.Dial.instMonoidalCategoryStruct | Mathlib.CategoryTheory.Dialectica.Monoidal | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
[inst_2 : CategoryTheory.Limits.HasPullbacks C] → CategoryTheory.MonoidalCategoryStruct (CategoryTheory.Dial C) | null | true |
Module.Basis.smulTower._proof_2 | Mathlib.RingTheory.AlgebraTower | ∀ {R : Type u_4} {S : Type u_2} {A : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid A]
[inst_3 : Module R S] [inst_4 : Module S A] [inst_5 : Module R A] [IsScalarTower R S A] {ι' : Type u_3}
(c : Module.Basis ι' S A), LinearMap.CompatibleSMul A (ι' →₀ S) R S | null | false |
_private.Init.Data.List.Lemmas.0.List.ne_nil_iff_exists_cons.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (motive : (∃ b l', l = b :: l') → Prop) (x : ∃ b l', l = b :: l'),
(∀ (w : α) (w_1 : List α) (eq : l = w :: w_1), motive ⋯) → motive x | null | false |
Lean.Meta.LazyDiscrTree.PreDiscrTree | Lean.Meta.LazyDiscrTree | Type → Type | Structure for quickly initializing a lazy discrimination tree with a large number
of elements using concurrent functions for generating entries.
| true |
_private.Mathlib.Order.UpperLower.Prod.0.upperClosure_prod._simp_1_1 | Mathlib.Order.UpperLower.Prod | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, (x ≤ y) = (x.1 ≤ y.1 ∧ x.2 ≤ y.2) | null | false |
instAlgebraUniversalEnvelopingAlgebra._aux_3 | Mathlib.Algebra.Lie.UniversalEnveloping | (R : Type u_1) →
(L : Type u_2) →
[inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → R →+* UniversalEnvelopingAlgebra R L | null | false |
Std.ExtTreeSet.min_insert_of_isEmpty | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.isEmpty = true → (t.insert k).min ⋯ = k | null | true |
KaehlerDifferential.polynomialEquiv._proof_11 | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u_1) [inst : CommRing R], SMulCommClass (Polynomial R) R Ω[Polynomial R⁄R] | null | false |
Lean.DefinitionSafety.ctorElimType | Lean.Declaration | {motive : Lean.DefinitionSafety → Sort u} → ℕ → Sort (max 1 u) | null | false |
CompleteLattice.copy._proof_6 | Mathlib.Order.Copy | ∀ {α : Type u_1} (c : CompleteLattice α) (le : α → α → Prop) (eq_le : le = LE.le) (bot : α),
bot = ⊥ → ∀ (sup : α → α → α) (eq_sup : sup = max) (inf : α → α → α) (eq_inf : inf = min) (a : α), bot ≤ a | null | false |
FiniteIndexNormalAddSubgroup.ctorIdx | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | {G : Type u_1} → {inst : AddGroup G} → FiniteIndexNormalAddSubgroup G → ℕ | null | false |
Std.Internal.Parsec.Input.pos | Std.Internal.Parsec.Basic | {ι : Type} →
{elem idx : outParam Type} →
{inst : DecidableEq idx} → {inst_1 : DecidableEq elem} → [self : Std.Internal.Parsec.Input ι elem idx] → ι → idx | null | true |
MeasureTheory.Measure.everywherePosSubset_subset | Mathlib.MeasureTheory.Measure.EverywherePos | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] (μ : MeasureTheory.Measure α) (s : Set α),
μ.everywherePosSubset s ⊆ s | null | true |
UniformSpace.Completion.mapRingHom | Mathlib.Topology.Algebra.UniformRing | {α : Type u_1} →
[inst : Ring α] →
[inst_1 : UniformSpace α] →
[inst_2 : IsTopologicalRing α] →
[inst_3 : IsUniformAddGroup α] →
{β : Type u} →
[inst_4 : UniformSpace β] →
[inst_5 : Ring β] →
[inst_6 : IsUniformAddGroup β] →
[inst... | The completion map as a ring morphism. | true |
PowerBasis.liftEquiv'_apply_coe | Mathlib.RingTheory.PowerBasis | ∀ {S : Type u_2} [inst : Ring S] {A : Type u_3} {B : Type u_4} [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra A B] [inst_4 : Algebra A S] [inst_5 : IsDomain B] (pb : PowerBasis A S) (a : S →ₐ[A] B),
↑(pb.liftEquiv' a) = a pb.gen | null | true |
_private.Mathlib.Topology.LocallyFinite.0.locallyFinite_sum._simp_1_2 | Mathlib.Topology.LocallyFinite | ∀ {α : Sort u_1} {p q : α → Prop}, ((∀ (x : α), p x) ∧ ∀ (x : α), q x) = ∀ (x : α), p x ∧ q x | null | false |
IsLocallyConstant.iff_isOpen_fiber_apply | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {f : X → Y},
IsLocallyConstant f ↔ ∀ (x : X), IsOpen (f ⁻¹' {f x}) | null | true |
_private.Mathlib.CategoryTheory.Sites.Sieves.Basic.0.CategoryTheory.Sieve.pullback_comp._simp_1_1 | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
(R = S) = ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f | null | false |
sphere_one_div_singleton | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x : E), Metric.sphere 1 δ / {x} = Metric.sphere x⁻¹ δ | null | true |
WeierstrassCurve.Jacobian.eval_polynomialY_of_Z_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F},
P 2 ≠ 0 →
(MvPolynomial.eval P) W.polynomialY / P 2 ^ 3 =
Polynomial.evalEval (P 0 / P 2 ^ 2) (P 1 / P 2 ^ 3) W.toAffine.polynomialY | null | true |
InverseSystem.pEquivOnSucc._proof_1 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] ⦃i : ι⦄, i ≤ Order.succ i | null | false |
Asymptotics.isLittleO_const_left._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E'' : Type u_9} {F'' : Type u_10} [inst : NormedAddCommGroup E''] [inst_1 : NormedAddCommGroup F'']
{g'' : α → F''} {l : Filter α} {c : E''},
(fun _x => c) =o[l] g'' = (c = 0 ∨ Filter.Tendsto (norm ∘ g'') l Filter.atTop) | null | false |
BoxIntegral.BoxAdditiveMap.volume.eq_1 | Mathlib.Analysis.BoxIntegral.Partition.Measure | ∀ {ι : Type u_1} [inst : Fintype ι] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E],
BoxIntegral.BoxAdditiveMap.volume = MeasureTheory.volume.toBoxAdditive.toSMul | null | true |
NumberField.HeightOneSpectrum.adicAbv | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | (K : Type u_1) →
[inst : Field K] →
{R : Type u_3} →
[inst_1 : CommRing R] →
[inst_2 : Algebra R K] →
[IsDedekindDomain R] →
[IsFractionRing R K] →
IsDedekindDomain.HeightOneSpectrum R → [Ring.HasFiniteQuotients R] → [Infinite R] → AbsoluteValue K ℝ | The `v`-adic absolute value on `K` defined as the norm of `v` raised to negative `v`-adic
valuation | true |
DoubleCentralizer.one_snd | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A],
(DoubleCentralizer.toProd 1).2 = 1 | null | true |
CategoryTheory.Abelian.SpectralObject.liftCycles_i | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (n₀ n₁ : ℤ) (hn₁ : n₀ + 1 = n₁)
{A : C} (x : A ⟶ (X.H n₀).obj (Categ... | null | true |
Nat.ascFactorialBinary.eq_def | Mathlib.Data.Nat.Factorial.Basic | ∀ (n k : ℕ),
n.ascFactorialBinary k =
match k with
| 0 => 1
| 1 => n
| k@h:n_1.succ.succ => n.ascFactorialBinary (k / 2) * (n + k / 2).ascFactorialBinary ((k + 1) / 2) | null | true |
Ordering.isGE_iff_eq_gt_or_eq_eq | Init.Data.Ord.Basic | ∀ {o : Ordering}, o.isGE = true ↔ o = Ordering.gt ∨ o = Ordering.eq | null | true |
MulAction.isBlock_subtypeVal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {C : SubMulAction G X} {B : Set ↥C},
MulAction.IsBlock G (Subtype.val '' B) ↔ MulAction.IsBlock G B | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.leftUnitor.match_1.eq_2 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (motive : AugmentedSimplexCategory → Sort u_1)
(h_1 : (a : SimplexCategory) → motive (CategoryTheory.WithInitial.of a))
(h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of a => h_1 a
| CategoryTheory.WithInitial.star => h_2 (... | null | true |
Semiring.toOppositeModule | Mathlib.Algebra.Module.Opposite | {R : Type u_1} → [inst : Semiring R] → Module Rᵐᵒᵖ R | Like `Semiring.toModule`, but multiplies on the right. | true |
Field.finSepDegree_eq_of_equiv | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] (i : E ≃ₐ[F] K), Field.finSepDegree F E = Field.finSepDegree F K | If `E` and `K` are isomorphic as `F`-algebras, then they have the same `Field.finSepDegree`
over `F`. | true |
CategoryTheory.ComonObj.comul_assoc_flip | Mathlib.CategoryTheory.Monoidal.Comon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
[inst_2 : CategoryTheory.ComonObj X],
CategoryTheory.CategoryStruct.comp CategoryTheory.ComonObj.comul
(CategoryTheory.MonoidalCategoryStruct.whiskerRight CategoryTheory.ComonObj.comul X) =
Cat... | null | true |
Matrix.kroneckerMap_smul_right | Mathlib.LinearAlgebra.Matrix.Kronecker | ∀ {R : Type u_1} {α : 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} [inst : SMul R β] [inst_1 : SMul R γ] (f : α → β → γ) (r : R),
(∀ (a : α) (b : β), f a (r • b) = r • f a b) →
∀ (A : Matrix l m α) (B : Matrix n p β), Matrix.kroneckerMap f A (r • B) = r ... | null | true |
ValuationSubring.decompositionSubgroupMulSemiringAction._proof_1 | Mathlib.RingTheory.Valuation.RamificationGroup | ∀ (K : Type u_2) {L : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L],
SubmonoidClass (Subgroup Gal(L/K)) Gal(L/K) | null | false |
UpperHalfPlane.im_div_exp_dist_le | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | ∀ (z w : UpperHalfPlane), z.im / Real.exp (dist z w) ≤ w.im | null | true |
PrimeSpectrum.zeroLocus_span | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u} [inst : CommSemiring R] (s : Set R), PrimeSpectrum.zeroLocus ↑(Ideal.span s) = PrimeSpectrum.zeroLocus s | null | true |
MulChar.domRestrict_apply | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] {S : Type u_3}
[inst_2 : SetLike S R] [inst_3 : SubmonoidClass S R] (T : S) (χ : MulChar R R') (x : ↥T),
(MulChar.domRestrict T χ) x = if IsUnit x then χ ↑x else 0 | null | true |
Set.inter_insert_of_notMem | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, a ∉ s → s ∩ insert a t = s ∩ t | null | true |
SheafOfModules.Presentation.isColimit._proof_6 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R} (P : M.Presentation),
CategoryTheory.Categ... | null | false |
MonotoneOn.set_prod | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} [inst : Preorder α] {f : α → Set β} {g : α → Set γ},
MonotoneOn f s → MonotoneOn g s → MonotoneOn (fun x => f x ×ˢ g x) s | null | true |
neg_lt_sub_iff_lt_add._simp_1 | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddLeftStrictMono α] [AddRightStrictMono α] {a b c : α},
(-a < b - c) = (c < a + b) | null | false |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.card_mul_finset_lt_two._simp_1_16 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CliffordAlgebra.gradedAlgebra._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.Grading | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M),
(DirectSum.coeAlgHom (CliffordAlgebra.evenOdd Q)).comp
((CliffordAlgebra.lift Q) ⟨CliffordAlgebra.GradedAlgebra.ι Q, ⋯⟩) =
AlgHom.id R (CliffordAlgebra Q) | null | false |
Metric.Sigma.completeSpace | Mathlib.Topology.MetricSpace.Gluing | ∀ {ι : Type u_1} {E : ι → Type u_2} [inst : (i : ι) → MetricSpace (E i)] [∀ (i : ι), CompleteSpace (E i)],
CompleteSpace ((i : ι) × E i) | A disjoint union of complete metric spaces is complete. | true |
Lean.ParseImports.atomic | Lean.Elab.ParseImportsFast | Lean.ParseImports.Parser → Lean.ParseImports.Parser | null | true |
_private.Init.Data.Int.Cooper.0.Int.add_of_le._proof_1 | Init.Data.Int.Cooper | ∀ {a b : ℤ}, a ≤ b → b = a + ↑(b - a).toNat | null | false |
ConvexCone.Salient.anti | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {G : Type u_3} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup G]
[inst_3 : SMul R G] {C₁ C₂ : ConvexCone R G}, C₂ ≤ C₁ → C₁.Salient → C₂.Salient | null | true |
TensorProduct.instStarModule | Mathlib.Algebra.Star.TensorProduct | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [inst_5 : StarModule R A] [inst_6 : AddCommMonoid B]
[inst_7 : StarAddMonoid B] [inst_8 : Module R B] [inst_9 : StarModule R B], StarModule R (Tens... | null | true |
MeasurableEquiv.mulRight._proof_4 | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [MeasurableMul G] (g : G),
Measurable ⇑(Equiv.symm (Equiv.mulRight g)) | null | false |
_private.Init.Data.String.Basic.0.ByteArray.validateUTF8_eq_false_iff._simp_1_1 | Init.Data.String.Basic | ∀ (b : Bool), (b = false) = ¬b = true | null | false |
_private.Mathlib.Algebra.Order.CauSeq.Basic.0.IsCauSeq.add.match_1_1 | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : Ring β] {abv : β → α} {f g : ℕ → β} (w : α) (i : ℕ)
(motive : ((∀ k ≥ i, abv (f k - f i) < w) ∧ ∀ k ≥ i, abv (g k - g i) < w) → Prop)
(x : (∀ k ≥ i, abv (f k - f i) < w) ∧ ∀ k ≥ i, abv (g k - g i) < w),
(∀ (H₁ : ∀ k ≥ i, abv (f k - f i) < w) (H₂ : ∀... | null | false |
Aesop.PersistentHashSet.toArray | Aesop.Util.Basic | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.PersistentHashSet α → Array α | null | true |
String.Pos.ne_of_lt | Init.Data.String.Basic | ∀ {s : String} {p q : s.Pos}, p < q → p ≠ q | null | true |
MulAction.period_eq_one_iff | Mathlib.GroupTheory.GroupAction.Period | ∀ {α : Type v} {M : Type u} [inst : Monoid M] [inst_1 : MulAction M α] {m : M} {a : α},
MulAction.period m a = 1 ↔ m • a = a | null | true |
AlgebraicGeometry.Scheme.AffineZariskiSite.instLocallyDirectedIsOpenImmersionDirectedCover._proof_8 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} {i j : (AlgebraicGeometry.Scheme.AffineZariskiSite.directedCover X).I₀} (hij : i ⟶ j),
AlgebraicGeometry.IsOpenImmersion (X.homOfLE ⋯) | null | false |
CategoryTheory.Abelian.coimIsoIm._proof_2 | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{X Y : CategoryTheory.Arrow C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Abelian.coim.map f)
(CategoryTheory.Abelian.coimageIsoImage Y.hom).hom =
CategoryTheory.CategoryStruct.comp (Cat... | null | false |
BoxIntegral.TaggedPrepartition.isPartition_iff_iUnion_eq | Mathlib.Analysis.BoxIntegral.Partition.Tagged | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (π : BoxIntegral.TaggedPrepartition I), π.IsPartition ↔ π.iUnion = ↑I | null | true |
CategoryTheory.Limits.MonoFactorisation.recOn | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Limits.MonoFactorisation f → Sort u_1} →
(t : CategoryTheory.Limits.MonoFactorisation f) →
((I : C) →
(m : I ⟶ Y) →
[m_mono : Category... | null | false |
Aesop.InstMap.insertMatch | Aesop.Forward.State | Aesop.InstMap → Aesop.PremiseIndex → Aesop.Match → Aesop.BaseM (Aesop.InstMap × Bool) | Inserts a match. The match `m` is associated with the slot given by its
level (i.e., the maximal slot for which `m` contains a hypothesis) and the
instantiation of `var` given by the map's substitution. Returns `true` if the
match was not previously associated with this slot and instantiation. | true |
AnalyticAt.hasStrictDerivAt | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, AnalyticAt 𝕜 f x → HasStrictDerivAt f (deriv f x) x | null | true |
Aesop.EqualUpToIds.MVarValue.delayedAssignment.sizeOf_spec | Aesop.Util.EqualUpToIds | ∀ (da : Lean.DelayedMetavarAssignment), sizeOf (Aesop.EqualUpToIds.MVarValue.delayedAssignment da) = 1 + sizeOf da | null | true |
Std.TreeMap.getElem!_insertIfNew | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited β]
{k a : α} {v : β}, (t.insertIfNew k v)[a]! = if cmp k a = Ordering.eq ∧ k ∉ t then v else t[a]! | null | true |
UInt64.ofNat_mod_size | Init.Data.UInt.Lemmas | ∀ {x : ℕ}, UInt64.ofNat (x % 2 ^ 64) = UInt64.ofNat x | null | true |
_private.Mathlib.Order.Atoms.0.SetLike.isAtom_iff._simp_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a < b) = (a ≤ b ∧ ¬b ≤ a) | null | false |
CategoryTheory.CartesianMonoidalCategory | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max u v) | An instance of `CartesianMonoidalCategory C` bundles an explicit choice of a binary
product of two objects of `C`, and a terminal object in `C`.
Users should use the monoidal notation: `X ⊗ Y` for the product and `𝟙_ C` for
the terminal object.
| true |
Computation.parallel_congr_left | Mathlib.Data.Seq.Parallel | ∀ {α : Type u} {S T : Stream'.WSeq (Computation α)} {a : α},
(∀ s ∈ S, s.Promises a) →
Stream'.WSeq.LiftRel Computation.Equiv S T → (Computation.parallel S).Equiv (Computation.parallel T) | null | true |
_private.Mathlib.RingTheory.Localization.Basic.0.Localization.r_iff_of_le_nonZeroDivisors.match_1_4 | Mathlib.RingTheory.Localization.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Submonoid R} (a c : R) (b d : ↥M)
(motive : (∃ a_1 ∈ M, a_1 * (↑d * a) = a_1 * (↑b * c)) → Prop) (x : ∃ a_1 ∈ M, a_1 * (↑d * a) = a_1 * (↑b * c)),
(∀ (u : R) (hu : u ∈ M) (h : u * (↑d * a) = u * (↑b * c)), motive ⋯) → motive x | null | false |
Hamming.instSMulWithZero | Mathlib.InformationTheory.Hamming | {α : Type u_1} →
{ι : Type u_2} →
{β : ι → Type u_3} →
[inst : Zero α] → [inst_1 : (i : ι) → Zero (β i)] → [(i : ι) → SMulWithZero α (β i)] → SMulWithZero α (Hamming β) | null | true |
AlgebraicGeometry.ValuativeCommSq.mk | Mathlib.AlgebraicGeometry.ValuativeCriterion | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
(R : Type u) →
[commRing : CommRing R] →
[domain : IsDomain R] →
[valuationRing : ValuationRing R] →
(K : Type u) →
[field : Field K] →
[algebra : Algebra R K] →
[isFractionRing : I... | null | true |
IsLocalRing.instCommRingResidueField._proof_10 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsLocalRing R],
autoParam (∀ (x : IsLocalRing.ResidueField R), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
_private.Mathlib.Topology.FiberBundle.Constructions.0.wrapped._proof_1._@.Mathlib.Topology.FiberBundle.Constructions.1875155857._hygCtx._hyg.8 | Mathlib.Topology.FiberBundle.Constructions | @definition✝ = @definition✝ | null | false |
Cardinal.mk_compl_eq_mk_compl_finite_lift | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α : Type u} {β : Type v} [Finite α] {s : Set α} {t : Set β},
Cardinal.lift.{v, u} (Cardinal.mk α) = Cardinal.lift.{u, v} (Cardinal.mk β) →
Cardinal.lift.{v, u} (Cardinal.mk ↑s) = Cardinal.lift.{u, v} (Cardinal.mk ↑t) →
Cardinal.lift.{v, u} (Cardinal.mk ↑sᶜ) = Cardinal.lift.{u, v} (Cardinal.mk ↑tᶜ) | null | true |
_private.Mathlib.Probability.Martingale.OptionalStopping.0.MeasureTheory.smul_le_stoppedValue_hittingBtwn._simp_1_1 | Mathlib.Probability.Martingale.OptionalStopping | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
(a ≤ s.sup' H f) = ∃ b ∈ s, a ≤ f b | null | false |
essSup_dirac | Mathlib.MeasureTheory.Function.EssSup | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : ConditionallyCompleteLattice β] {f : α → β}
[MeasurableSingletonClass α] (a : α), essSup f (MeasureTheory.Measure.dirac a) = f a | null | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.exists_kerSquareLift_comp_eq_id._simp_1_7 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
IsNilpotent.pow_succ | Mathlib.Algebra.GroupWithZero.Basic | ∀ (n : ℕ) {S : Type u_5} [inst : MonoidWithZero S] {x : S}, IsNilpotent x → IsNilpotent (x ^ n.succ) | null | true |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.finiteSubproductsCone_π_app | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type w}
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] (f : α → C) [inst_2 : CategoryTheory.Limits.HasProduct f]
(S : (Finset (CategoryTheory.Discrete α))ᵒᵖ),
(CategoryTheory.Limits.ProductsFromFiniteCofiltered.finiteSubproductsCone f).π.app S =
... | null | true |
_private.Init.Data.Array.Lemmas.0.List.anyM.match_1.eq_2 | Init.Data.Array.Lemmas | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | null | true |
Real.rpow_rpow_inv | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x y : ℝ}, 0 ≤ x → y ≠ 0 → (x ^ y) ^ y⁻¹ = x | null | true |
FirstOrder.Language.orderRel.rec | Mathlib.ModelTheory.Order | {motive : (a : ℕ) → FirstOrder.Language.orderRel a → Sort u} →
motive 2 FirstOrder.Language.orderRel.le → {a : ℕ} → (t : FirstOrder.Language.orderRel a) → motive a t | null | false |
Monoid.PushoutI.NormalWord.empty_toList | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ}, Monoid.PushoutI.NormalWord.empty.toList = [] | null | true |
_private.Mathlib.Order.Ideal.0.Order.Ideal.mem_sInf._simp_1_1 | Mathlib.Order.Ideal | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ p) = (x ∈ ↑p) | null | false |
Mathlib.Tactic.ITauto.Proof.orInL.injEq | Mathlib.Tactic.ITauto | ∀ (p p_1 : Mathlib.Tactic.ITauto.Proof), (p.orInL = p_1.orInL) = (p = p_1) | null | true |
Plausible.instInhabitedGenError | Plausible.Gen | Inhabited Plausible.GenError | null | true |
TopologicalSpace.Compacts.map.congr_simp | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f f_1 : α → β)
(e_f : f = f_1) (hf : Continuous f) (K K_1 : TopologicalSpace.Compacts α),
K = K_1 → TopologicalSpace.Compacts.map f hf K = TopologicalSpace.Compacts.map f_1 ⋯ K_1 | null | true |
HomotopicalAlgebra.CofibrantObject | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[HomotopicalAlgebra.CategoryWithCofibrations C] → [CategoryTheory.Limits.HasInitial C] → Type u | The full subcategory of cofibrant objects. | true |
Finset.add_one_le_card_pow | Mathlib.Geometry.Group.Growth.LinearLowerBound | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {X : Finset G},
1 ∈ X → (↑(Subgroup.closure ↑X)).Infinite → ∀ (n : ℕ), n + 1 ≤ (X ^ n).card | The growth of a set generating an infinite group is at least linear. | true |
PartialOrder.OfStdArgs.mk | Mathlib.Order.Std | {α : Type u_1} →
(toPreorderArgs : Preorder.OfStdArgs α) →
autoParam
(let this := toPreorderArgs.le;
Std.IsPartialOrder α)
PartialOrder.OfStdArgs.isPartialOrder._autoParam →
PartialOrder.OfStdArgs α | null | true |
Lean.Lsp.SymbolKind.file.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SymbolKind.file = 1 | null | true |
Std.Http.URI.EncodedFragment.ofByteArray? | Std.Http.Data.URI.Encoding | ByteArray → Option Std.Http.URI.EncodedFragment | Attempts to create an encoded fragment component from raw bytes.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.