name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Internal.IndexMultiMap.entries | Std.Http.Internal.IndexMultiMap | {α : Type u} → {β : Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Std.Internal.IndexMultiMap α β → Array (α × β) | Flat array of all key-value entries in insertion order.
| true |
Lean.Parser.getSyntaxKindOfParserAlias? | Lean.Parser.Extension | Lean.Name → IO (Option Lean.SyntaxNodeKind) | null | true |
CauSeq.inf_le_right | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {a b : CauSeq α abs},
a ⊓ b ≤ b | null | true |
_private.Mathlib.Basic.Real.ConjExponents.0.ENNReal.HolderTriple.toReal_iff._simp_1_1 | Mathlib.Basic.Real.ConjExponents | ∀ {a : ENNReal}, a ≠ 0 → (a⁻¹ = ⊤) = False | null | false |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceE._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₂ : j ⟶ k) (f₃ : k ⟶ l) (f₁₂ : i ⟶ k)
(h₁₂ : CategoryTheory.CategoryStruct.... | null | false |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (X : CategoryTheory.Pretriangulated.Triangle C),
((CategoryTheory.Pretriangulated.Triangle.shiftFunctorZero C).inv.app X).hom₁ =
(CategoryTheory.shiftFunctorZero C ℤ).inv.app X... | null | true |
Polynomial.comp_eq_aeval | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u} [inst : CommSemiring R] {p q : Polynomial R}, p.comp q = (Polynomial.aeval q) p | null | true |
Std.Time.Year.Offset.Valid | Std.Time.Date.Unit.Year | Std.Time.Year.Offset → Std.Time.Month.Ordinal → Std.Time.Day.Ordinal → Prop | Checks if the given date is valid for the specified year, month, and day.
| true |
Polynomial.coeff_natDegree_eq_zero_of_degree_lt | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, p.degree < q.degree → p.coeff q.natDegree = 0 | null | true |
AddTorsor.nonempty | Mathlib.Algebra.Torsor.Defs | ∀ {G : outParam (Type u_1)} {P : Type u_2} {inst : AddGroup G} [self : AddTorsor G P], Nonempty P | null | true |
ModuleCat.exteriorPower.functor_obj | Mathlib.Algebra.Category.ModuleCat.ExteriorPower | ∀ (R : Type u) [inst : CommRing R] (n : ℕ) (M : ModuleCat R),
(ModuleCat.exteriorPower.functor R n).obj M = M.exteriorPower n | null | true |
Ideal.symm_apply_mem_of_equiv_iff._simp_1 | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {I : Ideal R} {f : R ≃+* S} {y : S},
(f.symm y ∈ I) = (y ∈ Ideal.map f I) | null | false |
_private.Mathlib.Tactic.NormNum.NatLog.0.Mathlib.Meta.NormNum.evalNatLog.match_1 | Mathlib.Tactic.NormNum.NatLog | (eb en : Q(ℕ)) →
(motive : (ek : Q(ℕ)) × Q(Nat.log «$eb» «$en» = «$ek») → Sort u_1) →
(x : (ek : Q(ℕ)) × Q(Nat.log «$eb» «$en» = «$ek»)) →
((ek : Q(ℕ)) → (pf : Q(Nat.log «$eb» «$en» = «$ek»)) → motive ⟨ek, pf⟩) → motive x | null | false |
FirstOrder.Language.BoundedFormula.freeVarFinset.eq_1 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} [inst : DecidableEq α] (x : ℕ),
FirstOrder.Language.BoundedFormula.falsum.freeVarFinset = ∅ | null | true |
Profinite.NobelingProof.GoodProducts.SumEval | Mathlib.Topology.Category.Profinite.Nobeling.Successor | {I : Type u} →
(C : Set (I → Bool)) →
[inst : LinearOrder I] →
[inst_1 : WellFoundedLT I] →
{o : Ordinal.{u}} →
(ho : o < Ordinal.type fun x1 x2 => x1 < x2) →
↑(Profinite.NobelingProof.GoodProducts
(Profinite.NobelingProof.π C fun x => Profinite.NobelingProo... | Let
`N := LocallyConstant (π C (ord I · < o)) ℤ`
`M := LocallyConstant C ℤ`
`P := LocallyConstant (C' C ho) ℤ`
`ι := GoodProducts (π C (ord I · < o))`
`ι' := GoodProducts (C' C ho')`
`v : ι → N := GoodProducts.eval (π C (ord I · < o))`
Then `SumEval C ho` is the map `u` in the diagram below. It is linearly indep... | true |
_private.Mathlib.Probability.Moments.SubGaussian.0.ProbabilityTheory.Kernel.HasSubgaussianMGF.const_mul._simp_1_1 | Mathlib.Probability.Moments.SubGaussian | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
_private.Mathlib.Algebra.Module.StablyFree.FreeOfInvertible.0.exteriorPower.cofactorLinear.eq_1 | Mathlib.Algebra.Module.StablyFree.FreeOfInvertible | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} {N : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {n : ℕ} (bN : Module.Basis (Fin n) R N),
exteriorPower.cofactorLinear✝ bN =
{ toFun := fun x => (bN.det.compLinearMap (LinearMap.snd R M N)).smulRigh... | null | true |
Lean.OpaqueVal._sizeOf_1 | Lean.Declaration | Lean.OpaqueVal → ℕ | null | false |
RootPairing.corootForm_apply_apply | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) [inst_5 : Fintype ι]
(x y : N), (P.CorootForm x) y = ∑ i, (P.root' i) x * (P.root' i) y | null | true |
Std.TreeMap.toList_roo | Std.Data.TreeMap.Slice | ∀ {α : Type u} {β : Type v} (cmp : autoParam (α → α → Ordering) Std.TreeMap.toList_roo._auto_1) [Std.TransCmp cmp]
{t : Std.TreeMap α β cmp} {lowerBound upperBound : α},
Std.Slice.toList (Std.Roo.Sliceable.mkSlice t (lowerBound<...upperBound)) =
List.filter (fun e => decide ((cmp e.1 lowerBound).isGT = true ∧ (... | null | true |
localCohomology.SelfLERadical.inhabited | Mathlib.Algebra.Homology.LocalCohomology | {R : Type u} → [inst : CommRing R] → (J : Ideal R) → Inhabited (localCohomology.SelfLERadical J) | null | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_left._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {a b : Prop}, (¬(a ∧ b)) = (b → ¬a) | null | false |
Homeomorph.Quot.congrLeft._proof_1 | Mathlib.Topology.Homeomorph.Quotient | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {r : X → X → Prop}
(e : X ≃ₜ Y) (x x_1 : X), r x x_1 ↔ r (e.symm (e x)) (e.symm (e x_1)) | null | false |
_private.Init.Data.Int.Order.0.Int.sign.match_1.eq_3 | Init.Data.Int.Order | ∀ (motive : ℤ → Sort u_1) (a : ℕ) (h_1 : (n : ℕ) → motive (Int.ofNat n.succ)) (h_2 : Unit → motive (Int.ofNat 0))
(h_3 : (a : ℕ) → motive (Int.negSucc a)),
(match Int.negSucc a with
| Int.ofNat n.succ => h_1 n
| Int.ofNat 0 => h_2 ()
| Int.negSucc a => h_3 a) =
h_3 a | null | true |
_private.Lean.Meta.Match.Basic.0.Lean.Meta.Match.Alt.toMessageData.match_1 | Lean.Meta.Match.Basic | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((lhs rhs : Lean.Expr) → motive (lhs, rhs)) → motive x | null | false |
AddAction.ofEndHom | Mathlib.Algebra.Group.Action.End | {M : Type u_2} → {α : Type u_4} → [inst : AddMonoid M] → (M →+ Additive (Function.End α)) → AddAction M α | The additive action induced by a hom to `Additive (Function.End α)`
See note [reducible non-instances]. | true |
Real.Angle.abs_toReal_neg_coe_eq_self_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : ℝ}, |(-↑θ).toReal| = θ ↔ 0 ≤ θ ∧ θ ≤ Real.pi | null | true |
_private.Mathlib.MeasureTheory.Measure.Haar.NormedSpace.0.MonoidHom.exists_nhds_isBounded._simp_1_4 | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {β : Type u_2} {ι : Sort u_4} (s : Set β) (t : ι → Set β), ⋃ i, s ∩ t i = s ∩ ⋃ i, t i | null | false |
Ordnode.toBinaryTree._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → BinaryTree α | null | false |
CategoryTheory.Idempotents.toKaroubi_comp_karoubiFunctorCategoryEmbedding | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ (J : Type u_1) (C : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C],
(CategoryTheory.Idempotents.toKaroubi (CategoryTheory.Functor J C)).comp
(CategoryTheory.Idempotents.karoubiFunctorCategoryEmbedding J C) =
(CategoryTheory.Functor.whiskeringRight... | The composition of `(J ⥤ C) ⥤ Karoubi (J ⥤ C)` and `Karoubi (J ⥤ C) ⥤ (J ⥤ Karoubi C)`
equals the functor `(J ⥤ C) ⥤ (J ⥤ Karoubi C)` given by the composition with
`toKaroubi C : C ⥤ Karoubi C`. | true |
Std.Do.Spec.forIn_iter._proof_4 | Std.Do.Triple.SpecLemmas | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {it : Std.Iter β}, it.toList ++ [] = it.toList | null | false |
dist_inf_sup | Mathlib.Analysis.Normed.Order.UpperLower | ∀ {α : Type u_1} [inst : NormedAddCommGroup α] [inst_1 : Lattice α] [IsOrderedAddMonoid α] [HasSolidNorm α] (x y : α),
dist (x ⊓ y) (x ⊔ y) = dist x y | null | true |
SSet.Subcomplex.Pairing.RankFunction.Cell._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} →
{ι : Type v} → {inst : LinearOrder ι} → {f : P.RankFunction ι} → {i : ι} → [SizeOf ι] → f.Cell i → ℕ | null | false |
Uniformity.term𝓤 | Mathlib.Topology.UniformSpace.Defs | Lean.ParserDescr | The uniformity is a filter on α × α (inferred from an ambient uniform space
structure on α). | true |
Quot.mk | Init.Prelude | {α : Sort u} → (r : α → α → Prop) → α → Quot r | Places an element of a type into the quotient that equates terms according to the provided relation.
Given `v : α` and relation `r : α → α → Prop`, `Quot.mk r v : Quot r` is like `v`, except all
observations of `v`'s value must respect `r`.
`Quot.mk` is a built-in primitive:
* `Quot` is the built-in quotient type.
... | true |
TemperedDistribution.delta._proof_3 | Mathlib.Analysis.Distribution.TemperedDistribution | RingHomCompTriple (RingHom.id ℂ) (RingHom.id ℂ) (RingHom.id ℂ) | null | false |
Submodule.instModuleQuotientIdealSpanSingletonSetSubtypeMemTorsionBy._proof_5 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (a : R)
(r s : R ⧸ R ∙ a) (x : ↥(Submodule.torsionBy R M a)), (r + s) • x = r • x + s • x | null | false |
ContinuousMap.HomotopyWith.prop | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
{P : C(X, Y) → Prop} (F : f₀.HomotopyWith f₁ P) (t : ↑unitInterval), P (F.curry t) | null | true |
AddCon.coe_finsuppSum._simp_1 | Mathlib.GroupTheory.Congruence.BigOperators | ∀ {ι : Type u_1} {β : Type u_2} {M : Type u_3} [inst : AddCommMonoid M] [inst_1 : Zero β] (c : AddCon M) (h : ι → β → M)
(f : ι →₀ β), (f.sum fun i b => ↑(h i b)) = ↑(f.sum h) | null | false |
arrowAddAction._proof_2 | Mathlib.Algebra.Group.Action.Basic | ∀ {G : Type u_3} {A : Type u_1} {B : Type u_2} [inst : SubtractionMonoid G] [inst_1 : AddAction G A] (f : A → B),
0 +ᵥ f = f | null | false |
locallyConnectedSpace_iff_isTopologicalBasis_isOpen_isPreconnected | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α],
LocallyConnectedSpace α ↔ TopologicalSpace.IsTopologicalBasis {s | IsOpen s ∧ IsPreconnected s} | null | true |
_private.Mathlib.NumberTheory.DirichletCharacter.Basic.0.DirichletCharacter.factorsThrough_one_iff.match_1_1 | Mathlib.NumberTheory.DirichletCharacter.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {n : ℕ} (χ : DirichletCharacter R n) (motive : χ.FactorsThrough 1 → Prop)
(x : χ.FactorsThrough 1),
(∀ (w : 1 ∣ n) (χ₀ : DirichletCharacter R 1) (hχ₀ : χ = (DirichletCharacter.changeLevel w) χ₀), motive ⋯) → motive x | null | false |
CategoryTheory.Limits.CoproductDisjoint | Mathlib.CategoryTheory.Limits.Shapes.DisjointCoproduct | {C : Type u} → [CategoryTheory.Category.{v, u} C] → {ι : Type u_1} → (ι → C) → Prop | We say the coproduct of the family `Xᵢ` is disjoint, if whenever we have a pullback diagram of the
form
```
Z ⟶ X₁
↓ ↓
X₂ ⟶ ∐ X
```
`Z` is initial.
| true |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.truncatedSup_union_left._simp_1_2 | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | null | false |
QuotientAddGroup.quotientInfEquivSumNormalizerQuotient._proof_4 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H N : AddSubgroup G) (hLE : H ≤ AddSubgroup.normalizer ↑N),
((QuotientAddGroup.mk' (N.addSubgroupOf (H ⊔ N))).comp (AddSubgroup.inclusion ⋯)).ker.Normal | null | false |
_private.Mathlib.Tactic.Translate.GuessName.0.Mathlib.Tactic.GuessName.fixAbbreviationAux._unary.eq_def | Mathlib.Tactic.Translate.GuessName | ∀ (g : Mathlib.Tactic.GuessName.GuessNameData) (_x : (_ : List String) ×' List String),
Mathlib.Tactic.GuessName.fixAbbreviationAux._unary g _x =
PSigma.casesOn _x fun a a_1 =>
match a, a_1 with
| [], [] => ""
| [], x :: s => x ++ Mathlib.Tactic.GuessName.fixAbbreviationAux._unary g ⟨s, []⟩
... | null | false |
Lake.MixTrace.mixTrace | Lake.Build.Trace | {α : Type u} → [self : Lake.MixTrace α] → α → α → α | Combine two traces. The result should be dirty if either of the inputs is dirty. | true |
FreeAddMonoid.mem_of_self | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {m : α}, m ∈ FreeAddMonoid.of m | null | true |
AlgebraicGeometry.Scheme.image_preimage_eq_of_isPullback | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {P X Y Z : AlgebraicGeometry.Scheme} {fst : P ⟶ X} {snd : P ⟶ Y} {f : X ⟶ Z} {g : Y ⟶ Z},
CategoryTheory.IsPullback fst snd f g → ∀ (s : Set ↥X), ⇑snd '' ⇑fst ⁻¹' s = ⇑g ⁻¹' ⇑f '' s | null | true |
GradedTensorProduct.instRing._proof_14 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
ClassGroup.mulEquiv._proof_7 | Mathlib.RingTheory.ClassGroup.ExtendedHom | ∀ {A : Type u_2} {B : Type u_1} [inst : CommRing A] [inst_1 : CommRing B] (g : A ≃+* B), Function.Injective ⇑g.symm | null | false |
Prod.noConfusion | Init.Prelude | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{t : α × β} →
{α' : Type u} → {β' : Type v} → {t' : α' × β'} → α = α' → β = β' → t ≍ t' → Prod.noConfusionType P t t' | null | false |
LE.le.absolutelyContinuous | Mathlib.MeasureTheory.Measure.AbsolutelyContinuous | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α}, μ ≤ ν → μ.AbsolutelyContinuous ν | **Alias** of `MeasureTheory.Measure.absolutelyContinuous_of_le`. | true |
_private.Init.Data.String.Lemmas.Splits.0.String.Pos.ofEqAppend.eq_1 | Init.Data.String.Lemmas.Splits | ∀ {s t₁ t₂ : String} (h : s = t₁ ++ t₂), String.Pos.ofEqAppend h = ((t₁ ++ t₂).pos t₁.rawEndPos ⋯).cast ⋯ | null | true |
Mathlib.Tactic.MkIff.mkOrList | Mathlib.Tactic.MkIffOfInductiveProp | List Lean.Expr → Lean.Expr | `mkOrList [x1, x2, ...]` is defined as `x1 ∨ (x2 ∨ ...)`, or `False` if the list is empty. | true |
Algebra.TensorProduct.map_comp_includeLeft | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} {C : Type uC} {D : Type uD} [inst : CommSemiring R]
[inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A]
[inst_6 : IsScalarTower R S A] [inst_7 : Semiring B] [inst_8 : Algebra R B] [inst_9 : Sem... | null | true |
AddSubgroup.quotientiInfEmbedding.eq_1 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {ι : Type u_2} (f : ι → AddSubgroup α),
AddSubgroup.quotientiInfEmbedding f = { toFun := fun q i => AddSubgroup.quotientMapOfLE ⋯ q, inj' := ⋯ } | null | true |
CommRingCat.forget_preservesLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1} (CategoryTheory.forget CommRingCat) | The forgetful functor from commutative rings to types preserves all limits.
(That is, the underlying types could have been computed instead as limits in the category of types.)
| true |
LocallyFiniteOrder.ofFiniteIcc | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → (∀ (a b : α), (Set.Icc a b).Finite) → LocallyFiniteOrder α | A noncomputable constructor from the finiteness of all closed intervals. | true |
Lean.Elab.FieldInfo.lctx | Lean.Elab.InfoTree.Types | Lean.Elab.FieldInfo → Lean.LocalContext | null | true |
Int.Internal.Linear.Poly.isUnsatEq.eq_1 | Init.Data.Int.Linear | ∀ (k : ℤ), (Int.Internal.Linear.Poly.num k).isUnsatEq = (k != 0) | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.3406008996._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
CategoryTheory.Limits.MulticospanIndex.toPiForkFunctor_obj | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) {c : CategoryTheory.Limits.Fan I.left}
(hc : CategoryTheory.Limits.IsLimit c) {d : CategoryTheory.Limits.Fan I.right} (hd : CategoryTheory.Limits.IsLimit d)
(K : C... | null | true |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalFirst._regBuiltin.Lean.Elab.Tactic.Conv.evalFirst.declRange_3 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
QuadraticAlgebra.smul_mk | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {S : Type u_2} {a b : R} [inst : SMul S R] (s : S) (x y : R),
s • { re := x, im := y } = { re := s • x, im := s • y } | null | true |
BoundedVariationOn.of_subsingleton | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : TopologicalSpace E] [inst_2 : WeakPseudoEMetricSpace E]
{f : α → E} {s : Set α}, s.Subsingleton → BoundedVariationOn f s | null | true |
MeasureTheory.Measure.ofMeasurable.congr_simp | Mathlib.MeasureTheory.VectorMeasure.Operations | ∀ {α : Type u_1} [inst : MeasurableSpace α] (m m_1 : (s : Set α) → MeasurableSet s → ENNReal) (e_m : m = m_1)
(m0 : m ∅ ⋯ = 0)
(mU :
∀ ⦃f : ℕ → Set α⦄ (h : ∀ (i : ℕ), MeasurableSet (f i)),
Pairwise (Function.onFun Disjoint f) → m (⋃ i, f i) ⋯ = ∑' (i : ℕ), m (f i) ⋯),
MeasureTheory.Measure.ofMeasurable ... | null | true |
Prod.normedCommRing._proof_21 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedCommRing α] [inst_1 : NormedCommRing β] (a b : α × β), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
_private.Init.Data.Array.InsertionSort.0.Array.insertionSort.swapLoop | Init.Data.Array.InsertionSort | {α : Type u_1} → (α → α → Bool) → (xs : Array α) → (j : ℕ) → j < xs.size → Array α | null | true |
_private.Mathlib.NumberTheory.Height.NumberField.0.NumberField.relIndex_span_span_nat_mul | Mathlib.NumberTheory.Height.NumberField | ∀ {K : Type u_1} [inst : Field K] [NumberField K] (m : ℕ) {n : ℕ},
n ≠ 0 →
∀ (a : NumberField.RingOfIntegers K),
(Submodule.toAddSubgroup (Ideal.span {↑m})).relIndex (Submodule.toAddSubgroup (Ideal.span {↑m, a})) =
(Submodule.toAddSubgroup (Ideal.span {↑n * ↑m})).relIndex
(Submodule.toAddS... | null | true |
ContinuousLinearMap.toBilinForm | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | {𝕜 : Type u_2} →
{E : Type u_5} →
[inst : NormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] → [inst_3 : TopologicalSpace E] → (E →L[𝕜] E →L[𝕜] 𝕜) → LinearMap.BilinForm 𝕜 E | Send a continuous bilinear form to an abstract bilinear form (forgetting continuity). | true |
Finsupp.lattice._proof_2 | Mathlib.Order.Preorder.Finsupp | ∀ {ι : Type u_1} {M : Type u_2} [inst : Zero M] [inst_1 : Lattice M] (a b : ι →₀ M), b ≤ SemilatticeSup.sup a b | null | false |
KaehlerDifferential.kerToTensor.eq_1 | Mathlib.RingTheory.Smooth.Quotient | ∀ (R : Type u) [inst : CommRing R] (A : Type u_2) (B : Type u_3) [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra A B],
KaehlerDifferential.kerToTensor R A B =
{ toFun := fun x => 1 ⊗ₜ[A] (KaehlerDifferential.D R A) ↑x, map_add' := ⋯, map_smul' := ⋯ } | null | true |
ContinuousLinearMap.nnnorm_holder_apply_apply_le | Mathlib.MeasureTheory.Function.Holder | ∀ {α : Type u_1} {𝕜 : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {p q r : ENNReal} [hpqr : p.HolderTriple q r] [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedAddCommGroup G]
[ins... | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjPullback._proof_1 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (U V : ↑X.affineOpens), ↑U ⊓ ↑V ≤ ↑U | null | false |
IsAddUnit.preimage_vadd_set | Mathlib.GroupTheory.GroupAction.Pointwise | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} {F : Type u_4} [inst : AddMonoid M] [inst_1 : AddAction M α]
[inst_2 : AddAction M β] [inst_3 : FunLike F α β] [AddActionHomClass F M α β] (f : F) {c : M},
IsAddUnit c → ∀ (t : Set β), ⇑f ⁻¹' (c +ᵥ t) = c +ᵥ ⇑f ⁻¹' t | null | true |
CochainComplex.HomComplex.Cocycle.precomp._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {n : ℤ}, n + 1 = n + 1 | null | false |
Finsupp.support_mul | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u₁} {β : Type u₂} [inst : MulZeroClass β] [inst_1 : DecidableEq α] {g₁ g₂ : α →₀ β},
(g₁ * g₂).support ⊆ g₁.support ∩ g₂.support | null | true |
instCommRingPadicInt._proof_5 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (a b c : ℤ_[p]), a + b + c = a + (b + c) | null | false |
TopologicalSpace.countable_countableBasis | Mathlib.Topology.Bases | ∀ (α : Type u) [t : TopologicalSpace α] [inst : SecondCountableTopology α],
(TopologicalSpace.countableBasis α).Countable | null | true |
deriv_id | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] (x : 𝕜), deriv id x = 1 | null | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.cooper_dvd_left_core._simp_1_3 | Init.Data.Int.Linear | ∀ {a b : ℤ}, (-a ∣ b) = (a ∣ b) | null | false |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.isUnaryEntries.match_3 | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(motive : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_3) →
(x : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) →
(Unit → motive Lean.PersistentHashMap.Entry.null) →
((node : Lean.PersistentHashMap.Node α... | null | false |
CategoryTheory.Iso.coreWhiskerLeft | Mathlib.CategoryTheory.Core | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (F : CategoryTheory.Functor C D)
{G H : CategoryTheory.Functor D E} (η : G ≅ H),
(F.isoWhiskerLeft η).core = F.coreComp G ≪≫ F.core.is... | null | true |
Valued.toNormedField.one_le_norm_iff._simp_1 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : Field L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [val : Valued L Γ₀]
[hv : Valued.v.RankOne] {x : L}, (1 ≤ ‖x‖) = (1 ≤ Valued.v x) | null | false |
CategoryTheory.Sieve.instCompleteLattice.match_1 | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x : Set (CategoryTheory.Sieve X)) (x_1 : C)
(x_2 : x_1 ⟶ X) (motive : (CategoryTheory.Sieve.sup x).arrows x_2 → Prop)
(x_3 : (CategoryTheory.Sieve.sup x).arrows x_2),
(∀ (b : CategoryTheory.Sieve X) (hb : b ∈ x) (hf : b.arrows x_2), motive ⋯)... | null | false |
isMin_grade_iff._simp_1 | Mathlib.Order.Grade | ∀ {𝕆 : Type u_1} {α : Type u_3} [inst : Preorder 𝕆] [inst_1 : Preorder α] [inst_2 : GradeMinOrder 𝕆 α] {a : α},
IsMin (grade 𝕆 a) = IsMin a | null | false |
Lean.Lsp.instFromJsonCodeActionDisabled.fromJson | Lean.Data.Lsp.CodeActions | Lean.Json → Except String Lean.Lsp.CodeActionDisabled | null | true |
rpow_one_add_lt_one_add_mul_self | Mathlib.Analysis.Convex.SpecificFunctions.Basic | ∀ {s : ℝ}, -1 ≤ s → s ≠ 0 → ∀ {p : ℝ}, 0 < p → p < 1 → (1 + s) ^ p < 1 + p * s | **Bernoulli's inequality** for real exponents, strict version: for `0 < p < 1` and `-1 ≤ s`,
with `s ≠ 0`, we have `(1 + s) ^ p < 1 + p * s`. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput.mk._flat_ctor | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} →
(aig : Std.Sat.AIG α) →
aig.Ref → aig.Ref → old.decls.size ≤ aig.decls.size → Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput old | null | false |
BooleanRing.toBooleanAlgebra._proof_3 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanRing α] (a : α), 1 ≤ a ⊔ (1 + a) | null | false |
AkraBazziRecurrence.isEquivalent_deriv_rpow_p_mul_one_sub_smoothingFn | Mathlib.Computability.AkraBazzi.AkraBazzi | ∀ {p : ℝ},
p ≠ 0 →
Asymptotics.IsEquivalent Filter.atTop (deriv fun z => z ^ p * (1 - AkraBazziRecurrence.smoothingFn z)) fun z =>
p * z ^ (p - 1) | null | true |
_private.Init.Data.List.Monadic.0.List.zipWithM'.match_1.splitter | Init.Data.List.Monadic | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → List β → Sort u_3) →
(x : List α) →
(x_1 : List β) →
((x : α) → (xs : List α) → (y : β) → (ys : List β) → motive (x :: xs) (y :: ys)) →
((x : List α) →
(x_2 : List β) →
(∀ (x_3 : α) (xs : Lis... | null | true |
Std.DTreeMap.Internal.Impl.Tree.mk.injEq | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} {size : ℕ} (impl : Std.DTreeMap.Internal.Impl α β) (balanced_impl : impl.Balanced)
(size_impl : impl.size = size) (impl_1 : Std.DTreeMap.Internal.Impl α β) (balanced_impl_1 : impl_1.Balanced)
(size_impl_1 : impl_1.size = size),
({ impl := impl, balanced_impl := balanced_impl, size_... | null | true |
Std.IsPreorder.rec | Init.Data.Order.Classes | {α : Type u} →
[inst : LE α] →
{motive : Std.IsPreorder α → Sort u_1} →
((le_refl : ∀ (a : α), a ≤ a) → (le_trans : ∀ (a b c : α), a ≤ b → b ≤ c → a ≤ c) → motive ⋯) →
(t : Std.IsPreorder α) → motive t | null | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.fixBinderInfos._sparseCasesOn_1 | Mathlib.Tactic.Translate.Reorder | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
OreLocalization.instSemiring | Mathlib.RingTheory.OreLocalization.Ring | {R : Type u_1} →
[inst : Semiring R] → {S : Submonoid R} → [inst_1 : OreLocalization.OreSet S] → Semiring (OreLocalization S R) | null | true |
_private.Mathlib.Topology.EMetricSpace.Defs.0.EMetric.tendsto_atTop._simp_1_1 | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ici b) = (b ≤ x) | null | false |
IsTopologicalTorsor.mk._flat_ctor | Mathlib.Topology.Algebra.Group.Torsor | ∀ {V : Type u_1} [inst : Group V] [inst_1 : TopologicalSpace V] {P : Type u_2} [inst_2 : Torsor V P]
[inst_3 : TopologicalSpace P],
(Continuous fun p => p.1 • p.2) → (Continuous fun x => x.1 /ₛ x.2) → IsTopologicalTorsor P | null | false |
_private.Mathlib.Data.Num.Lemmas.0.Num.bit1_of_bit1.match_1_1 | Mathlib.Data.Num.Lemmas | ∀ (motive : Num → Prop) (x : Num), (∀ (_ : Unit), motive Num.zero) → (∀ (p : PosNum), motive (Num.pos p)) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.