name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MonadReaderOf.read | Init.Prelude | {ρ : semiOutParam (Type u)} → {m : Type u → Type v} → [self : MonadReaderOf ρ m] → m ρ | Retrieves the local value. | true |
Ideal.Pure.eq_1 | Mathlib.RingTheory.Ideal.Pure | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), I.Pure = Module.Flat R (R ⧸ I) | null | true |
CategoryTheory.GrothendieckTopology.Point.toPresheafFiberOfIsCofiltered_naturality_assoc | Mathlib.CategoryTheory.Sites.Point.OfIsCofiltered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C]
{N : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} N] (p : CategoryTheory.Functor N C)
[inst_3 : CategoryTheory.InitiallySmall N] {J : CategoryTheory.GrothendieckTopology C}
[inst_4 : CategoryTheory.I... | null | true |
Asymptotics.transIsEquivalentIsLittleO | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | {α : Type u_1} →
{β : Type u_2} →
{β₂ : Type u_3} →
[inst : NormedAddCommGroup β] →
[inst_1 : Norm β₂] →
{l : Filter α} → Trans (Asymptotics.IsEquivalent l) (Asymptotics.IsLittleO l) (Asymptotics.IsLittleO l) | null | true |
CategoryTheory.PreOneHypercover.cylinder_X | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (i : E.I₀) × F.I₁ (f.s₀ i) (g.s₀ i)),
(CategoryTheory.PreOneHypercover.cylinder f g).X p = CategoryT... | null | true |
CategoryTheory.CostructuredArrow.ιCompGrothendieckPrecompFunctorToCommaCompFst_hom_app | Mathlib.CategoryTheory.Comma.StructuredArrow.Functor | ∀ {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] (L : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor E D) (X : E) (X_1 : ↑((R.comp (CategoryTheory.CostructuredArrow.functor L))... | null | true |
Multiset.mem_filterMap | Mathlib.Data.Multiset.Filter | ∀ {α : Type u_1} {β : Type v} (f : α → Option β) (s : Multiset α) {b : β},
b ∈ Multiset.filterMap f s ↔ ∃ a ∈ s, f a = some b | null | true |
Algebra.RingHom.adjoinAlgebraMapEquiv._proof_1 | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_2} {B : Type u_1} [inst : CommSemiring A] [inst_1 : CommSemiring B] [inst_2 : Algebra A B] (b : B)
(p : Polynomial A), (Polynomial.aeval b) p ∈ A[b] | null | false |
Lean.Lsp.instToJsonMessageType | Lean.Data.Lsp.Window | Lean.ToJson Lean.Lsp.MessageType | null | true |
Std.Async.IO.AsyncWrite.write | Std.Async.IO | {α β : Type} → [self : Std.Async.IO.AsyncWrite α β] → α → β → Std.Async.Async Unit | null | true |
Polynomial.coeff_ofFinsupp | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] (p : AddMonoidAlgebra R ℕ), { toFinsupp := p }.coeff = p.coeff | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct.0.SSet.PtSimplex.MulStruct.assocAux.α_castSucc_succ_succ._proof_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {n : ℕ} {i : Fin n}, ¬i.castSucc.succ.succ = i.castSucc.castSucc.castSucc | null | false |
Homeomorph.ext | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {h h' : X ≃ₜ Y},
(∀ (x : X), h x = h' x) → h = h' | null | true |
Std.DHashMap.Internal.Raw₀.Const.getKeyD_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k fallback : α} (h : (↑m).WF),
(Std.DHashMap.Internal.Raw₀.filter f m).getKeyD k fallback =
((m.getKey? k).pfilter fun x h' => f x ... | null | true |
AdjoinRoot.equiv'._proof_2 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (g : Polynomial R)
(pb : PowerBasis R S) (h₁ : (Polynomial.aeval (AdjoinRoot.root g)) (minpoly R pb.gen) = 0)
(h₂ : (Polynomial.aeval pb.gen) g = 0) (x : S),
(AdjoinRoot.liftAlgHom g (Algebra.ofId R S) pb.gen h₂) ((pb... | null | false |
Submodule.IsLattice.smul | Mathlib.Algebra.Module.Lattice | ∀ {R : Type u_1} [inst : CommRing R] (A : Type u_2) [inst_1 : CommRing A] [inst_2 : Algebra R A] {V : Type u_3}
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : Module A V] [inst_6 : IsScalarTower R A V]
(M : Submodule R V) [Submodule.IsLattice A M] (a : Aˣ), Submodule.IsLattice A (a • M) | The action of `Aˣ` on `R`-submodules of `V` preserves `IsLattice`. | true |
Algebra.Generators.localizationAway._proof_5 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[inst_3 : IsLocalization.Away r S],
algebraMap (MvPolynomial Unit R) S = ↑(MvPolynomial.aeval fun x => IsLocalization.Away.invSelf r) | null | false |
Localization.subalgebra.isFractionRing | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_1} (K : Type u_2) [inst : CommRing A] (S : Submonoid A) (hS : S ≤ nonZeroDivisors A) [inst_1 : CommRing K]
[inst_2 : Algebra A K] [inst_3 : IsFractionRing A K], IsFractionRing (↥(Localization.subalgebra K S hS)) K | null | true |
Int16.toInt64_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a.toInt64 < b.toInt64) = (a < b) | null | false |
TensorProduct.mapOfCompatibleSMul | Mathlib.LinearAlgebra.TensorProduct.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(A : Type u_13) →
(S : Type u_14) →
(M : Type u_15) →
(N : Type u_16) →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
... | If M and N are both R- and A-modules and their actions on them commute,
and if the A-action on `M ⊗[R] N` can switch between the two factors, then there is a
canonical S-linear map from `M ⊗[A] N` to `M ⊗[R] N`,
where `S` is any other ring acting on `M` and whose action commutes with the `A` and `R`-actions. | true |
Lean.Linter.LinterSetsState.mk.inj | Lean.Linter.Init | ∀ {merged : Lean.Linter.LinterSets} {localEntries : Array (Lean.Name × Lean.NameSet)}
{merged_1 : Lean.Linter.LinterSets} {localEntries_1 : Array (Lean.Name × Lean.NameSet)},
{ merged := merged, localEntries := localEntries } = { merged := merged_1, localEntries := localEntries_1 } →
merged = merged_1 ∧ localEn... | null | true |
_private.Mathlib.Algebra.Homology.SpectralSequence.ComplexShape.0.ComplexShape.spectralSequenceFin._proof_4 | Mathlib.Algebra.Homology.SpectralSequence.ComplexShape | ∀ (l : ℕ) (u : ℤ × ℤ) {i i' j : ℤ × Fin l},
i.1 + u.1 = j.1 ∧ ↑↑i.2 + u.2 = ↑↑j.2 → i'.1 + u.1 = j.1 ∧ ↑↑i'.2 + u.2 = ↑↑j.2 → i.1 = i'.1 | null | false |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor | Mathlib.RingTheory.Invariant.Profinite | {A : Type u_1} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
{G : Type u} →
[inst_3 : Group G] →
[inst_4 : MulSemiringAction G B] →
[SMulCommClass G A B] →
[inst_6 : TopologicalSpace G] ... | (Implementation)
The functor taking an open normal subgroup `N ≤ G` to the set of lifts of `σ` in `G ⧸ N`.
We will show that its inverse limit is nonempty to conclude that there exists a lift in `G`. | true |
SetLike.Homogeneous.smul | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_1} {S : Type u_3} {R : Type u_4} [inst : CommSemiring S] [inst_1 : Semiring R] [inst_2 : Algebra S R]
{A : ι → Submodule S R} {s : S} {r : R}, SetLike.IsHomogeneousElem A r → SetLike.IsHomogeneousElem A (s • r) | null | true |
WithBot.sumHomeomorph._proof_4 | Mathlib.Topology.Order.WithTop | ∀ (ι : Type u_1) [inst : LinearOrder ι] [inst_1 : OrderBot ι] (x : WithBot ι),
(fun x =>
match x with
| Sum.inl i => ↑i
| Sum.inr PUnit.unit => ⊥)
((fun x => if h : x = ⊥ then Sum.inr () else Sum.inl x.unbotA) x) =
x | null | false |
jacobiTheta₂'_term | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ℤ → ℂ → ℂ → ℂ | Summand in the series for the `z`-derivative of the Jacobi theta function. | true |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.pow_sub_le_descFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic.0.CStarAlgebra.nonneg_iff_eq_mul_star_self._proof_1_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | 1 ≠ 0 | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_eq_fallback_of_contains_eq_false._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.appAt.sizeOf_spec | Mathlib.Tactic.ClickSuggestions.TryPremises | ∀ (arr : Array Mathlib.Tactic.ClickSuggestions.ApplyAtLemma),
sizeOf (Mathlib.Tactic.ClickSuggestions.Candidates.appAt✝ arr) = 1 + sizeOf arr | null | true |
BitVec.toNat_shiftConcat_eq_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {b : Bool} {k : ℕ}, k < w → x.toNat < 2 ^ k → (x.shiftConcat b).toNat = x.toNat * 2 + b.toNat | `x.shiftConcat b` does not overflow if `x < 2^k` for `k < w`, and so
`x.shiftConcat b |>.toNat = x.toNat * 2 + b.toNat`. | true |
HomologicalComplex.homotopyCofiber.mapHomologicalComplexObjXIso | Mathlib.Algebra.Homology.HomotopyCofiber | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{ι : Type u_2} →
{c : ComplexShape ι} →
{F G : HomologicalComplex C c} →
(φ : F ⟶ G) →
[inst_2 : HomologicalComplex.HasHomotopyCofiber φ] →
[... | Auxiliary definition for `mapHomologicalComplexObjIso`. | true |
CategoryTheory.AB5StarOfSize.rec | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasCofilteredLimitsOfSize.{w, w', v, u} C] →
{motive : CategoryTheory.AB5StarOfSize.{w, w', v, u} C → Sort u_1} →
((ofShape :
∀ (J : Type w') [inst_2 : CategoryTheory.Category.{w, w'} J] [inst_3 ... | null | false |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : I.sections),
(fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right j =>
(CategoryTheory.ConcreteCateg... | null | false |
VectorBundleCore.trivializationAt_coordChange_eq | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι) {b₀ b₁ b : B},
b ∈ (trivializationAt F Z.Fiber b₀).baseSet ∩ (trivializationAt F Z.Fiber b₁).baseSe... | null | true |
MeasureTheory.ComplexMeasure.absolutelyContinuous_ennreal_iff | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (c : MeasureTheory.ComplexMeasure α)
(μ : MeasureTheory.VectorMeasure α ENNReal),
MeasureTheory.VectorMeasure.AbsolutelyContinuous c μ ↔
MeasureTheory.VectorMeasure.AbsolutelyContinuous (MeasureTheory.ComplexMeasure.re c) μ ∧
MeasureTheory.VectorMeasure.AbsolutelyC... | null | true |
Aesop.EqualUpToIds.MVarValue._sizeOf_inst | Aesop.Util.EqualUpToIds | SizeOf Aesop.EqualUpToIds.MVarValue | null | false |
_private.Mathlib.Tactic.Linter.DocString.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.DocString.3513071771._hygCtx._hyg.4 | Mathlib.Tactic.Linter.DocString | IO (Lean.Option Bool) | null | false |
Std.Net.InterfaceAddress.address | Std.Net.Addr | Std.Net.InterfaceAddress → Std.Net.IPAddr | The IP address assigned to the interface.
| true |
Lean.Doc.elabInline._unsafe_rec | Lean.Elab.DocString | Lean.TSyntax `inline → Lean.Doc.DocM (Lean.Doc.Inline Lean.ElabInline) | null | false |
AdjoinRoot.algEquivOfAssociated_symm | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S)
(hfg : Associated f g), (AdjoinRoot.algEquivOfAssociated R f g hfg).symm = AdjoinRoot.algEquivOfAssociated R g f ⋯ | null | true |
Polynomial.zero_of_eval_zero | Mathlib.Algebra.Polynomial.Roots | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] [Infinite R] (p : Polynomial R),
(∀ (x : R), Polynomial.eval x p = 0) → p = 0 | null | true |
RingQuot.definition._@.Mathlib.Algebra.RingQuot.3673095128._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | (S : Type uS) →
[inst : CommSemiring S] →
{A : Type uA} → [inst_1 : Semiring A] → [inst_2 : Algebra S A] → (s : A → A → Prop) → A →ₐ[S] RingQuot s | null | false |
Lean.MonadTrace.getTraceState | Lean.Util.Trace | {m : Type → Type} → [self : Lean.MonadTrace m] → m Lean.TraceState | null | true |
CFC.pow_eq_zero_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ (R : Type u_1) {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [ContinuousFunctionalCalculus R A p] (a : A) ... | null | true |
Set.NPow | Mathlib.Algebra.Group.Pointwise.Set.Basic | {α : Type u_2} → [One α] → [Mul α] → Pow (Set α) ℕ | Repeated pointwise multiplication (not the same as pointwise repeated multiplication!) of a
`Set`. See note [pointwise nat action]. | true |
Std.TreeSet.Raw.instSliceableRccSlice | Std.Data.TreeSet.Raw.Slice | {α : Type u} →
(cmp : autoParam (α → α → Ordering) Std.TreeSet.Raw.instSliceableRccSlice._auto_1) →
Std.Rcc.Sliceable (Std.TreeSet.Raw α cmp) α (Std.DTreeMap.Internal.Unit.RccSlice α) | null | true |
ConditionallyCompleteLinearOrder.toSuccOrder | Mathlib.Order.SuccPred.CompleteLinearOrder | {α : Type u_2} → [inst : ConditionallyCompleteLinearOrder α] → [WellFoundedLT α] → SuccOrder α | Every conditionally complete linear order with well-founded `<` is a successor order, by setting
the successor of an element to be the infimum of all larger elements. | true |
Std.TreeSet.Raw.min!_eq_default | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.WF → t.isEmpty = true → t.min! = default | null | true |
Finset.one_le_divConst_self | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G}, A.Nonempty → 1 ≤ A.divConst A | null | true |
Lean.Meta.StructProjDecl._sizeOf_inst | Lean.Meta.Structure | SizeOf Lean.Meta.StructProjDecl | null | false |
IO.FS.createDir | Init.System.IO | System.FilePath → IO Unit | Creates a directory at the specified path. The parent directory must already exist.
Throws an exception if the directory cannot be created.
| true |
OpenPartialHomeomorph.ofSet_symm | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (hs : IsOpen s),
(OpenPartialHomeomorph.ofSet s hs).symm = OpenPartialHomeomorph.ofSet s hs | null | true |
_private.Mathlib.MeasureTheory.OuterMeasure.Caratheodory.0.MeasureTheory.OuterMeasure.isCaratheodory_iUnion_lt.match_1_1 | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u_1} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α}
(motive : (x : ℕ) → (∀ i < x, m.IsCaratheodory (s i)) → Prop) (x : ℕ) (x_1 : ∀ i < x, m.IsCaratheodory (s i)),
(∀ (x : ∀ i < 0, m.IsCaratheodory (s i)), motive 0 x) →
(∀ (n : ℕ) (h : ∀ i < n + 1, m.IsCaratheodory (s i)), motive n.succ h) → moti... | null | false |
_private.Mathlib.MeasureTheory.Integral.SetToL1.Function.0.MeasureTheory.setToFun_mono_left'._simp_1_3 | Mathlib.MeasureTheory.Integral.SetToL1.Function | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, (a ≤ a) = True | null | false |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedHomogeneousComponent_finsupp._simp_1_2 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.closure_iUnion._simp_1_1 | Mathlib.Topology.LocallyFinite | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (x ∈ closure s) = (nhdsWithin x s).NeBot | null | false |
_private.Mathlib.Geometry.Euclidean.Congruence.0.EuclideanGeometry.angle_angle_side._proof_1_2 | Mathlib.Geometry.Euclidean.Congruence | ∀ {V₁ : Type u_3} {V₂ : Type u_1} {P₁ : Type u_4} {P₂ : Type u_2} [inst : NormedAddCommGroup V₁]
[inst_1 : NormedAddCommGroup V₂] [inst_2 : InnerProductSpace ℝ V₁] [inst_3 : InnerProductSpace ℝ V₂]
[inst_4 : MetricSpace P₁] [inst_5 : MetricSpace P₂] [inst_6 : NormedAddTorsor V₁ P₁] [inst_7 : NormedAddTorsor V₂ P₂]
... | null | false |
Multiset.decidableEq._proof_2 | Mathlib.Data.Multiset.Defs | ∀ {α : Type u_1} (x x_1 : List α), ⟦x⟧ = ⟦x_1⟧ ↔ x ≈ x_1 | null | false |
_private.Lean.Util.LeanOptions.0.Lean.LeanOptions.toOptions.match_1 | Lean.Util.LeanOptions | (motive : Lean.Name × Lean.LeanOptionValue → Sort u_1) →
(x : Lean.Name × Lean.LeanOptionValue) →
((name : Lean.Name) → (optionValue : Lean.LeanOptionValue) → motive (name, optionValue)) → motive x | null | false |
gcd_same | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a : α), gcd a a = normalize a | null | true |
String.toList_split_intercalate_beq | Init.Data.String.Lemmas.Pattern.Split.Char | ∀ {c : Char} {l : List String},
(∀ s ∈ l, c ∉ s.toList) →
((((String.singleton c).intercalate l).split c).toList ==
if l = [] then ["".toSlice] else List.map String.toSlice l) =
true | null | true |
Std.ExtDHashMap.Const.getKey!_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.ExtDHashMap.filterMap f m).getKey! k =
((m.getKey? k).pfilter fun x_2 h' => (f x_2 (Std.ExtDHashM... | null | true |
BoundedContinuousFunction.coeFn_toLp | Mathlib.MeasureTheory.Function.LpSpace.ContinuousFunctions | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : TopologicalSpace α] [inst_1 : BorelSpace α] [inst_2 : NormedAddCommGroup E]
[inst_3 : SecondCountableTopologyEither α E] [inst_4 : MeasureTheory.IsFiniteMeasure μ] (𝕜 : Type u_3)
[inst_5 : Fact (1 ≤ p)] [... | null | true |
Cauchy.eq_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] (f : Filter α), Cauchy f = (f.NeBot ∧ f ×ˢ f ≤ uniformity α) | null | true |
CategoryTheory.Over.postAdjunctionRight._proof_6 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} T] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {Y : D} {F : CategoryTheory.Functor T D}
{G : CategoryTheory.Functor D T} (a : F ⊣ G) (A : CategoryTheory.Over ((CategoryTheory.Functor.id D).obj Y)),
CategoryTheory.CategoryStruct.comp (a... | null | false |
Function.prod_inj._simp_1 | Mathlib.Logic.Function.Defs | ∀ {ι : Sort u_3} {α : ι → Type u_1} {β : ι → Type u_2} {f f' : (i : ι) → α i} {g g' : (i : ι) → β i},
(Function.prod f g = Function.prod f' g') = (f = f' ∧ g = g') | null | false |
Lean.Elab.InlayHintTextEdit.recOn | Lean.Elab.InfoTree.InlayHints | {motive : Lean.Elab.InlayHintTextEdit → Sort u} →
(t : Lean.Elab.InlayHintTextEdit) →
((range : Lean.Syntax.Range) → (newText : String) → motive { range := range, newText := newText }) → motive t | null | false |
RBTree.RBSet.find?_insert_of_eq | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {v' v : α} [Std.TransCmp cmp] (t : RBTree.RBSet α cmp),
cmp v' v = Ordering.eq → (t.insert v).find? v' = some v | null | true |
Vector.mapFinIdx_append._proof_4 | Init.Data.Vector.MapIdx | ∀ {n m : ℕ}, ∀ i < m, i + n < n + m | null | false |
NormedAddGroupHom.coeAddHom_apply | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(a : NormedAddGroupHom V₁ V₂) (a_1 : V₁), NormedAddGroupHom.coeAddHom a a_1 = a a_1 | null | true |
Matrix.kroneckerTMulStarAlgEquiv_symm_apply | Mathlib.RingTheory.MatrixAlgebra | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_5) (S : Type u_6) {A : Type u_7} {B : Type u_8} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Fintype n]
[inst_6 : DecidableEq n] [inst_7 : CommSemiring S] [inst_8 : Algebra R S] [inst_9 : Algeb... | null | true |
Tactic.ComputeAsymptotics.UnitMonomial.AllZero.eq_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | ∀ (m : Tactic.ComputeAsymptotics.UnitMonomial), m.AllZero = (m.sign = Tactic.ComputeAsymptotics.UnitMonomial.Sign.zero) | null | true |
FirstOrder.Language.PartialEquiv.toEmbeddingOfEqTop | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] → [inst_1 : L.Structure N] → {f : L.PartialEquiv M N} → f.dom = ⊤ → L.Embedding M N | Given a partial equivalence which has the whole structure as domain,
returns the corresponding embedding. | true |
CategoryTheory.ShortComplex.Exact.epi_f | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.g = 0 → CategoryTheory.Epi S.f | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto.0.Real.tendstoLocallyUniformlyOn_rpow_sub_one_log._proof_1_12 | Mathlib.Analysis.SpecialFunctions.Log.RpowTendsto | ∀ (p : ℝ), 0 < p → 0 ≤ p⁻¹ | null | false |
bddAbove_Ioc | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, BddAbove (Set.Ioc b a) | null | true |
Function.Periodic.eq_1 | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} [inst : Add α] (f : α → β) (c : α), Function.Periodic f c = ∀ (x : α), f (x + c) = f x | null | true |
AddMonoidHom.codRestrict | Mathlib.Algebra.Group.Submonoid.Operations | {M : Type u_1} →
{N : Type u_2} →
[inst : AddZeroClass M] →
[inst_1 : AddZeroClass N] →
{S : Type u_5} →
[inst_2 : SetLike S N] →
[inst_3 : AddSubmonoidClass S N] → (f : M →+ N) → (s : S) → (∀ (x : M), f x ∈ s) → M →+ ↥s | Restriction of an `AddMonoidHom` to an `AddSubmonoid` of the codomain. | true |
_private.Init.Data.Array.Extract.0.Array.extract_size_left._proof_1_1 | Init.Data.Array.Extract | ∀ {α : Type u_1} {j : ℕ} {as : Array α}, ¬min j as.size ≤ as.size → False | null | false |
CochainComplex.HomComplex.leftHomologyData'_π | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m p : ℤ) (hm : n + 1 = m) (hp : m + 1 = p),
(CochainComplex.HomComplex.leftHomologyData' K L n m p hm hp).π =
AddCommGrpCat.ofHom (CochainComplex.HomComplex.CohomologyClass.mkAddMonoidH... | null | true |
HomologicalComplex.shortComplexFunctor'._proof_5 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_3} (c : ComplexShape ι) (i j k : ι) (X : HomologicalComplex C c),
{ τ₁ := (CategoryTheory.CategoryStruct.id X).f i, τ₂ := (CategoryTheory.CategoryStruct.id X).f j,
τ₃ := (CategoryTheo... | null | false |
quotAdjoinEquivQuotMap._proof_2 | Mathlib.RingTheory.Conductor | ∀ {R : Type u_2} {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S], RingHomClass (R →+* S) R S | null | false |
Measurable.lmarginal | Mathlib.MeasureTheory.Integral.Marginal | ∀ {δ : Type u_1} {X : δ → Type u_3} [inst : (i : δ) → MeasurableSpace (X i)] (μ : (i : δ) → MeasureTheory.Measure (X i))
[inst_1 : DecidableEq δ] {s : Finset δ} {f : ((i : δ) → X i) → ENNReal} [∀ (i : δ), MeasureTheory.SigmaFinite (μ i)],
Measurable f → Measurable (∫⋯∫⁻_s, f ∂μ) | null | true |
CategoryTheory.functorProdFunctorEquivUnitIso | Mathlib.CategoryTheory.Products.Basic | (A : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
(B : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
(C : Type u₃) →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
CategoryTheory.Functor.id (CategoryTheory.Functor A B × CategoryTheory.Functor A C) ≅
... | The unit isomorphism for `functorProdFunctorEquiv` | true |
MeasureTheory.Measure.toSphere_apply_aux | Mathlib.MeasureTheory.Constructions.HaarToSphere | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E]
(μ : MeasureTheory.Measure E) (s : Set ↑(Metric.sphere 0 1)) (r : ↑(Set.Ioi 0)),
μ (Subtype.val '' ⇑(homeomorphUnitSphereProd E) ⁻¹' s ×ˢ Set.Iio r) = μ (Set.Ioo 0 ↑r • Subtype.val '' s) | null | true |
CoalgHom.End._proof_3 | Mathlib.RingTheory.Coalgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : CoalgebraStruct R A] (x x_1 x_2 : A →ₗc[R] A), x * x_1 * x_2 = x * x_1 * x_2 | null | false |
IsMulCommutative.instCommSemigroup._proof_1 | Mathlib.Algebra.Group.IsCommutative | ∀ {M : Type u_1} [inst : Semigroup M] [inst_1 : IsMulCommutative M] (a b : M), a * b = b * a | null | false |
InitialSeg.total | Mathlib.Order.InitialSeg | {α : Type u_1} →
{β : Type u_2} →
(r : α → α → Prop) → (s : β → β → Prop) → [IsWellOrder α r] → [IsWellOrder β s] → InitialSeg r s ⊕ InitialSeg s r | For any two well orders, one is an initial segment of the other. | true |
Set.unit._proof_4 | Mathlib.RingTheory.DedekindDomain.SInteger | ∀ {R : Type u_2} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (S : Set (IsDedekindDomain.HeightOneSpectrum R))
(K : Type u_1) [inst_2 : Field K] [inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (x : Kˣ),
x ∈ {x | ∀ v ∉ S, (IsDedekindDomain.HeightOneSpectrum.valuation K v) ↑x = 1} ↔
x ∈ ↑(⨅ v, ⨅ (_ : v ... | null | false |
_private.Mathlib.NumberTheory.Ostrowski.0.Rat.AbsoluteValue.equiv_padic_of_bounded._simp_1_6 | Mathlib.NumberTheory.Ostrowski | ∀ {x : ℝ}, 0 ≤ x → ∀ (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | null | false |
Polynomial.instIsJacobsonRing | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} [inst : CommRing R] [IsJacobsonRing R], IsJacobsonRing (Polynomial R) | null | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.prod_fin_Icc_eq_prod_nat_Icc._proof_1_5 | Mathlib.Algebra.BigOperators.Intervals | ∀ {α : Type u_1} [inst : CommMonoid α] {n : ℕ} (a b : Fin n) (f : Fin n → α),
∀ a_1 ∈ Finset.Icc ↑a ↑b, a_1 ∉ Finset.range n → (if h : a_1 < n then f ⟨a_1, h⟩ else 1) = 1 | null | false |
CategoryTheory.instDecidableEqPairwise.decEq._proof_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ {ι : Type u_1} (a a_1 : ι), CategoryTheory.Pairwise.pair a a_1 = CategoryTheory.Pairwise.pair a a_1 | null | false |
fintypeNodupList._simp_3 | Mathlib.Data.Fintype.List | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a | null | false |
LinearMap.ofIsComplProdEquiv._proof_2 | Mathlib.LinearAlgebra.Projection | ∀ {R₁ : Type u_1} [inst : CommRing R₁], RingHomInvPair (RingHom.id R₁) (RingHom.id R₁) | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0._regBuiltin.UInt64.reduceAdd.declare_251._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx._hyg.42 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
IsRelPrime.neg_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y : R}, IsRelPrime x y → IsRelPrime x (-y) | null | true |
Int.getD_toList_roo_eq_fallback | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n fallback : ℤ} {i : ℕ}, (n - (m + 1)).toNat ≤ i → (m<...n).toList.getD i fallback = fallback | null | true |
Nat.instMonoidWithZero | Mathlib.Algebra.GroupWithZero.Nat | MonoidWithZero ℕ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.