name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.offset_lt_rawEndPos_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
Equiv.Perm.Basis.ofPermHom._proof_7 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis),
{ toFun := a.ofPermHomFun 1, invFun := a.ofPermHomFun 1⁻¹, left_inv := ⋯, right_inv := ⋯ } = 1 | null | false |
TopCat.Presheaf.algebra_section_stalk | Mathlib.Topology.Sheaves.CommRingCat | {X : TopCat} →
(F : TopCat.Presheaf CommRingCat X) →
{U : TopologicalSpace.Opens ↑X} → (x : ↥U) → Algebra ↑(F.obj (Opposite.op U)) ↑(F.stalk ↑x) | null | true |
Representation.IntertwiningMap.instAddCommMonoid | Mathlib.RepresentationTheory.Intertwining | {A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid W] →
[inst_4 : Module A V] →
[inst_5 : Module A W] →
... | null | true |
Nat.eq_iff_prime_padicValNat_eq | Mathlib.Data.Nat.Factorization.Basic | ∀ (a b : ℕ), a ≠ 0 → b ≠ 0 → (a = b ↔ ∀ (p : ℕ), Nat.Prime p → padicValNat p a = padicValNat p b) | Two positive naturals are equal if their prime padic valuations are equal | true |
AlgebraicGeometry.Scheme.Hom.QuasiFiniteAt.quasiFiniteAt | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} {x : ↥X},
AlgebraicGeometry.Scheme.Hom.QuasiFiniteAt f x →
∀ {V : X.Opens} (hV : AlgebraicGeometry.IsAffineOpen V) {U : Y.Opens},
AlgebraicGeometry.IsAffineOpen U →
∀ (hVU : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (hxV : x ∈ V.carrier),
... | null | true |
Continuous.stronglyMeasurable | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [OpensMeasurableSpace α]
[inst_3 : TopologicalSpace β] [TopologicalSpace.PseudoMetrizableSpace β] [h : SecondCountableTopologyEither α β]
{f : α → β}, Continuous f → MeasureTheory.StronglyMeasurable f | A continuous function is strongly measurable when either the source space or the target space
is second-countable. | true |
Std.ExtDHashMap.mem_filter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool} {k : α}, k ∈ Std.ExtDHashMap.filter f m ↔ ∃ (h : k ∈ m), f k (m.get k h) = true | null | true |
isMulCommutative_iff_isLieAbelian | Mathlib.Algebra.Lie.Abelian | ∀ {A : Type v} [inst : Ring A], IsMulCommutative A ↔ IsLieAbelian A | null | true |
Rat.mul_def | Init.Data.Rat.Lemmas | ∀ (a b : ℚ), a * b = Rat.normalize (a.num * b.num) (a.den * b.den) ⋯ | null | true |
Subtype.orderBot.eq_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : LE α] [inst_1 : OrderBot α] (hbot : p ⊥),
Subtype.orderBot hbot = { bot := ⟨⊥, hbot⟩, bot_le := ⋯ } | null | true |
_private.Mathlib.Topology.NhdsWithin.0.eventually_mem_of_tendsto_nhdsWithin._simp_1_3 | Mathlib.Topology.NhdsWithin | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | null | false |
MvPFunctor.liftP_iff | Mathlib.Data.PFunctor.Multivariate.Basic | ∀ {n : ℕ} {P : MvPFunctor.{u} n} {α : TypeVec.{u} n} (p : ⦃i : Fin2 n⦄ → α i → Prop) (x : ↑P α),
MvFunctor.LiftP p x ↔ ∃ a f, x = ⟨a, f⟩ ∧ ∀ (i : Fin2 n) (j : P.B a i), p (f i j) | null | true |
AlgebraicGeometry.continuousMapPresheafEquivOfTotallyDisconnectedSpace._proof_2 | Mathlib.AlgebraicGeometry.Sites.ConstantSheaf | ∀ (T : Type u_2) [inst : TopologicalSpace T] [inst_1 : TotallyDisconnectedSpace T] (U : AlgebraicGeometry.Scheme)
(f : C(ConnectedComponents ↥U, T)),
(fun f => { toFun := ⋯.connectedComponentsLift, continuous_toFun := ⋯ })
((fun f => f.comp { toFun := ConnectedComponents.mk, continuous_toFun := ⋯ }) f) =
... | null | false |
AlgebraicTopology.AlternatingFaceMapComplex.d_squared | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C) (n : ℕ),
CategoryTheory.CategoryStruct.comp (AlgebraicTopology.AlternatingFaceMapComplex.objD X (n + 1))
(AlgebraicTopology.AlternatingFaceMapComplex.objD X n) =
0 | null | true |
_private.Batteries.Data.List.Basic.0.List.swapAtTR.go.eq_2 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (l : List α) (v : α) (a : Array α) (head : α) (xs : List α),
List.swapAtTR.go✝ l v (head :: xs) 0 a = (head, a.toListAppend (v :: xs)) | null | true |
PrimeSpectrum.isHomeomorph_comap_tensorProductMap_of_isPurelyInseparable | Mathlib.RingTheory.Spectrum.Prime.Homeomorph | ∀ (K : Type u_2) (R : Type u_3) (S : Type u_4) [inst : Field K] [inst_1 : CommRing R] [inst_2 : CommRing S]
[inst_3 : Algebra R K] [inst_4 : Algebra R S] (L : Type u_5) [inst_5 : Field L] [inst_6 : Algebra R L]
[inst_7 : Algebra K L] [inst_8 : IsScalarTower R K L] [IsPurelyInseparable K L],
IsHomeomorph (PrimeSpe... | If `L` is a purely inseparable extension of `K` over `R` and `S` is an `R`-algebra,
the induced map `Spec (L ⊗[R] S) ⟶ Spec (K ⊗[R] S)` is a homeomorphism. | true |
Nat.mod_two_ne_zero | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, n % 2 ≠ 0 ↔ n % 2 = 1 | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Correctness.0.BirdDet.S_zero_eq_singleton._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Correctness | ∀ {n p : ℕ} {i : Fin n} {α : Fin p → Fin n}, (α ∈ BirdDet.S✝ p i) = StrictMono (Fin.cons i α) | null | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Constructions.0.NNReal.nndist_eq._simp_1_3 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b c : G},
(|a - b| ≤ c) = (a - b ≤ c ∧ b - a ≤ c) | null | false |
Lean.CasesAltInfo.recOn | Lean.Meta.CasesInfo | {motive : Lean.CasesAltInfo → Sort u} →
(t : Lean.CasesAltInfo) →
((ctorName : Lean.Name) → (numFields : ℕ) → motive (Lean.CasesAltInfo.ctor ctorName numFields)) →
((numHyps : ℕ) → motive (Lean.CasesAltInfo.default numHyps)) → motive t | null | false |
Zsqrtd.im | Mathlib.NumberTheory.Zsqrtd.Basic | {d : ℤ} → ℤ√d → ℤ | Component of the integer multiplied by `√d` | true |
SimpleGraph.reachable_iff_reflTransGen | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} (u v : V), G.Reachable u v ↔ Relation.ReflTransGen G.Adj u v | null | true |
Int16.ofInt_eq_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, Int16.ofInt ↑n = Int16.ofNat n | null | true |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.bestLabelForDecl?.visitNamespaces | Lean.Server.Completion.CompletionCollectors | (Lean.Name → StateT (Option Lean.Name) Lean.Server.Completion.M✝ Unit) →
Lean.Name → StateT (Option Lean.Name) Lean.Server.Completion.M✝ Unit | null | true |
PartialEquiv.ofSet_symm | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} (s : Set α), (PartialEquiv.ofSet s).symm = PartialEquiv.ofSet s | null | true |
CategoryTheory.Limits.IsWeakLimit.retractOfIsLimit | Mathlib.CategoryTheory.Limits.WeakLimits.Basic | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{C : Type u_3} →
[inst_1 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J C} →
{t t' : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsLimit t → CategoryTheory.Limits.IsWeakLimit t' ... | If `F` has a limit, then it is a retract of any weak limit of `F`.
| true |
SlashInvariantForm.instInhabited | Mathlib.NumberTheory.ModularForms.SlashInvariantForms | {Γ : Subgroup (GL (Fin 2) ℝ)} → {k : ℤ} → Inhabited (SlashInvariantForm Γ k) | null | true |
_private.Mathlib.Algebra.Polynomial.Bivariate.0.Polynomial.Bivariate.swap_monomial_monomial._simp_1_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {a : R} [inst : Semiring R] {n : ℕ}, (Polynomial.monomial n) a = Polynomial.C a * Polynomial.X ^ n | null | false |
Ordinal.termω₁ | Mathlib.SetTheory.Cardinal.Aleph | Lean.ParserDescr | `ω₁` is the first uncountable ordinal.
Conventions for notations in identifiers:
* The recommended spelling of `ω₁` in identifiers is `omega_one`. | true |
_private.Mathlib.Data.Int.Bitwise.0.Int.bitwise.match_1.eq_4 | Mathlib.Data.Int.Bitwise | ∀ (motive : ℤ → ℤ → Sort u_1) (m n : ℕ) (h_1 : (m n : ℕ) → motive (Int.ofNat m) (Int.ofNat n))
(h_2 : (m n : ℕ) → motive (Int.ofNat m) (Int.negSucc n)) (h_3 : (m n : ℕ) → motive (Int.negSucc m) (Int.ofNat n))
(h_4 : (m n : ℕ) → motive (Int.negSucc m) (Int.negSucc n)),
(match Int.negSucc m, Int.negSucc n with
... | null | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Defs.0.BigOperators.FinsetResult.finset.noConfusion | Mathlib.Algebra.BigOperators.Group.Finset.Defs | {P : Sort u} →
{s s' : Lean.Term} → BigOperators.FinsetResult.finset✝ s = BigOperators.FinsetResult.finset✝ s' → (s = s' → P) → P | null | false |
Fin.reverseInduction.go.match_1 | Init.Data.Fin.Lemmas | {n : ℕ} →
{motive : Fin (n + 1) → Sort u_2} →
(i : Fin (n + 1)) →
(motive_1 : (j : ℕ) → (h : j < n + 1) → ↑i ≤ j → motive ⟨j, h⟩ → ¬↑i = j → Sort u_1) →
(j : ℕ) →
(h : j < n + 1) →
(h2 : ↑i ≤ j) →
(x : motive ⟨j, h⟩) →
(hi : ¬↑i = j) →
... | null | false |
Std.DTreeMap.Internal.Impl.Const.getKey_alter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
[Inhabited α] (h : t.WF) {k k' : α} {f : Option β → Option β}
{hc : k' ∈ Std.DTreeMap.Internal.Impl.Const.alter! k f t},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).getKey k' hc =
if heq : c... | null | true |
TopologicalSpace.OpenNhdsOf.instSetLike | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → {x : α} → SetLike (TopologicalSpace.OpenNhdsOf x) α | null | true |
Std.DHashMap.Internal.Raw₀.erase_emptyWithCapacity | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {k : α} {c : ℕ},
(Std.DHashMap.Internal.Raw₀.emptyWithCapacity c).erase k = Std.DHashMap.Internal.Raw₀.emptyWithCapacity c | null | true |
Std.Http.Method.acl.elim | Std.Http.Data.Method | {motive : Std.Http.Method → Sort u} → (t : Std.Http.Method) → t.ctorIdx = 0 → motive Std.Http.Method.acl → motive t | null | false |
genericPoints.isGenericPoint | Mathlib.Topology.Sober | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x : ↑(genericPoints α)), IsGenericPoint ↑x ↑(genericPoints.component x) | null | true |
Std.Sat.CNF.Clause.not_sat_empty._simp_1 | Std.Sat.CNF.Sat | ∀ {α : Type u_1} {a : α → Bool}, Std.Sat.CNF.Clause.Sat a Std.Sat.CNF.Clause.empty = False | null | false |
inv_inv_div_inv | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), (a⁻¹ / b⁻¹)⁻¹ = a / b | null | true |
IsLocalizedModule.mk'_sub_mk' | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_6} {M' : Type u_7} [inst_1 : AddCommGroup M]
[inst_2 : SubtractionCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] (m₁ m₂ : M) (s₁ s₂ : ↥S),
IsLocalizedModule.mk' f m₁ s₁ - IsLocaliz... | null | true |
HomotopyCategory.Plus.inverseImage_quasiIso_mapCochainComplexPlus_injectiveObjectι | Mathlib.Algebra.Homology.DerivedCategory.DerivabilityStructureInjectives | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C],
(CochainComplex.Plus.quasiIso C).inverseImage (CategoryTheory.InjectiveObject.ι C).mapCochainComplexPlus =
(HomologicalComplex.homotopyEquivalences (CategoryTheory.InjectiveObject C) (ComplexShape.up ℤ)).inverseIma... | null | true |
ValuationSubring.ext_iff | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] {A B : ValuationSubring K}, A = B ↔ ∀ (x : K), x ∈ A ↔ x ∈ B | null | true |
MvPowerSeries.rescale_one | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_9} [inst : CommSemiring R], MvPowerSeries.rescale 1 = RingHom.id (MvPowerSeries σ R) | null | true |
Mathlib.Tactic.Matrix.ListMatrix.mul | Mathlib.Tactic.Matrix.ListMatrix | {α : Type u_1} → [Mul α] → [Add α] → [Zero α] → ℕ → ℕ → ℕ → List (List α) → List (List α) → List (List α) | The product of two lists of rows as `l` rows of `n` entries.
Each entry is a dot product of `m` terms, with `A` and `B` read as an `l × m` and an `m × n` matrix
respectively. | true |
WithLp.sndₗ_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : WithLp p (α × β)),
(WithLp.sndₗ p 𝕜 α β) x = x.snd | null | true |
AddSubmonoid.recOn | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] →
{motive : AddSubmonoid M → Sort u} →
(t : AddSubmonoid M) →
((toAddSubsemigroup : AddSubsemigroup M) →
(zero_mem' : 0 ∈ toAddSubsemigroup.carrier) →
motive { toAddSubsemigroup := toAddSubsemigroup, zero_mem' := zero_mem' }) →
... | null | false |
CategoryTheory.FreeMonoidalCategory.HomEquiv.tensor | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} {f f' : W.Hom X} {g g' : Y.Hom Z},
CategoryTheory.FreeMonoidalCategory.HomEquiv f f' →
CategoryTheory.FreeMonoidalCategory.HomEquiv g g' →
CategoryTheory.FreeMonoidalCategory.HomEquiv (f.tensor g) (f'.tensor g') | null | true |
Affine._aux_Mathlib_LinearAlgebra_AffineSpace_Defs___macroRules_Affine_termAffineSpace_1 | Mathlib.LinearAlgebra.AffineSpace.Defs | Lean.Macro | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.withLams | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | List Lean.FVarId →
Lean.Meta.RefinedDiscrTree.Key → StateT Lean.Meta.RefinedDiscrTree.LazyEntry Lean.MetaM Lean.Meta.RefinedDiscrTree.Key | Sometimes, we need to not index lambda binders, in particular when the body is the application of
a metavariable.
In the case where we do index the lambda binders,
`withLams` efficiently adds the lambdas and `key` to the result.
| true |
_private.Init.Data.Nat.Basic.0.Nat.succ_pred_eq_of_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | null | false |
Std.IterM.Partial.find? | Init.Data.Iterators.Consumers.Monadic.Loop | {α β : Type w} →
{m : Type w → Type w'} →
[Monad m] →
[inst : Std.Iterator α m β] → [Std.IteratorLoop α m m] → Std.IterM.Partial m β → (β → Bool) → m (Option β) | Returns the first output of the iterator for which the predicate `p` returns `true`, or `none` if
no such output is found.
`O(|it|)`. Short-circuits upon encountering the first match. The elements in `it` are examined in
order of iteration.
This function is deprecated. Instead of `it.allowNontermination.find?`, use `... | true |
FundamentalGroupoidFunctor.homotopicMapsNatIso._proof_3 | Mathlib.AlgebraicTopology.FundamentalGroupoid.InducedMaps | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f g : C(X, Y)}
(H : f.Homotopy g) ⦃X_1 Y_1 : FundamentalGroupoid X⦄ (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp ((FundamentalGroupoid.map f).map f_1) ⟦H.evalAt Y_1.as⟧ =
CategoryTheory.CategoryStruct.comp ⟦H.eva... | null | false |
Filter.instInvolutiveNeg._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : InvolutiveNeg α] (f : Filter α), Filter.map (Neg.neg ∘ Neg.neg) f = f | null | false |
MulEquiv.toFun_eq_coe | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N] (f : M ≃* N), f.toFun = ⇑f | null | true |
Lean.Meta.Sym.ProofInstInfo.argsInfo | Lean.Meta.Sym.SymM | Lean.Meta.Sym.ProofInstInfo → Array Lean.Meta.Sym.ProofInstArgInfo | Information about each argument position. | true |
USize.ofFin_or | Init.Data.UInt.Bitwise | ∀ (a b : Fin USize.size), USize.ofFin (a ||| b) = USize.ofFin a ||| USize.ofFin b | null | true |
Lean.Order.bot | Init.Internal.Order.Basic | {α : Sort u} → [Lean.Order.CCPO α] → α | The bottom element is the least upper bound of the empty chain.
This is intended to be used in the construction of `partial_fixpoint`, and not meant to be used otherwise.
| true |
Algebra.intNormAux._proof_3 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Algebra A B] [inst_3 : Field K] [inst_4 : Field L] [inst_5 : Algebra A K] [inst_6 : Algebra K L]
[inst_7 : Algebra A L] [IsScalarTower A K L] [inst_9 : Algebra B L] [IsScalarTower A B L] [IsIntegralClos... | null | false |
CategoryTheory.MorphismProperty.Comma.mapLeftIso._proof_2 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : Categor... | null | false |
ValuativeRel.ofValuation._proof_5 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {S : Type u_2} {Γ : Type u_1} [inst : Ring S] [inst_1 : LinearOrderedCommGroupWithZero Γ] (v : Valuation S Γ)
{x y : S}, v (x * y) ≤ v (y * x) | null | false |
CategoryTheory.HasWeakSheafify | Mathlib.CategoryTheory.Sites.Sheafification | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
CategoryTheory.GrothendieckTopology C → (A : Type u₂) → [CategoryTheory.Category.{v₂, u₂} A] → Prop | A proposition saying that the inclusion functor from sheaves to presheaves admits a left adjoint.
| true |
Multiset.prod_map_eq_prod_toEnumFinset | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] {M : Type u_3} [inst_1 : CommMonoid M] (m : Multiset α) (f : α → M),
(Multiset.map f m).prod = ∏ i ∈ m.toEnumFinset, f i.1 | null | true |
PadicInt.toZModHom | Mathlib.NumberTheory.Padics.RingHoms | {p : ℕ} →
[hp_prime : Fact (Nat.Prime p)] →
(v : ℕ) →
(f : ℤ_[p] → ℕ) →
(∀ (x : ℤ_[p]), x - ↑(f x) ∈ Ideal.span {↑v}) →
(∀ (x : ℤ_[p]) (a b : ℕ), x - ↑a ∈ Ideal.span {↑v} → x - ↑b ∈ Ideal.span {↑v} → ↑a = ↑b) → ℤ_[p] →+* ZMod v | `toZModHom` is an auxiliary constructor for creating ring homs from `ℤ_[p]` to `ZMod v`.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.mem_support_rotate_iff._proof_1_5 | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} [inst : DecidableEq V] (c : G.Walk v v) (u : V) (h : u ∈ c.support),
w ∈ (c.rotate u h).support ↔ w ∈ c.support | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt16.shiftLeft_add_of_toNat_lt._proof_1_2 | Init.Data.UInt.Bitwise | ∀ {b c : UInt16}, b.toNat + c.toNat < 16 → ¬b.toNat < 16 → False | null | false |
CategoryTheory.Functor.isPointwiseRightKanExtensionOfHasPointwiseLeftDerivedFunctor | Mathlib.CategoryTheory.Functor.Derived.PointwiseLeftDerived | {C : Type u₁} →
{D : Type u₂} →
{H : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} H] →
(F' : CategoryTheory.Functor D H) →
{F : CategoryTheory.Functor C H} →
... | A left derived functor is a pointwise left derived functor when
there exists a pointwise left derived functor. | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.slice_lt_slice_iff._simp_1_3 | Init.Data.String.Lemmas.Order | ∀ {i₁ i₂ : String.Pos.Raw}, (i₁ < i₂) = (i₁.byteIdx < i₂.byteIdx) | null | false |
_private.Mathlib.Order.CompleteLattice.SetLike.0.CompleteSublattice.mem_sSup._simp_1_1 | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {T : ↥L} {x : X}, (x ∈ T) = (x ∈ L.subtype T) | null | false |
SetRel.dom | Mathlib.Basic.Rel | {α : Type u_1} → {β : Type u_2} → SetRel α β → Set α | Domain of a relation. | true |
List.ofFn_inj' | Mathlib.Data.List.OfFn | ∀ {α : Type u} {m n : ℕ} {f : Fin m → α} {g : Fin n → α}, List.ofFn f = List.ofFn g ↔ ⟨m, f⟩ = ⟨n, g⟩ | `Fin.sigma_eq_iff_eq_comp_cast` may be useful to work with the RHS of this expression. | true |
Pi.ofNat_def | Mathlib.Data.Nat.Cast.Basic | ∀ {α : Type u_1} {π : α → Type u_3} (n : ℕ) [inst : (i : α) → OfNat (π i) n], OfNat.ofNat n = fun x => OfNat.ofNat n | null | true |
AddSubgroup.upperCentralSeriesAux._proof_2 | Mathlib.GroupTheory.Nilpotent | ∀ (G : Type u_1) [inst : AddGroup G] (n : ℕ), (AddSubgroup.upperCentralSeriesAux G n).fst.Characteristic | null | false |
Lean.Meta.Grind.SplitCandidateWithAnchor.mk | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitInfo → ℕ → Bool → Lean.Expr → UInt64 → Lean.Meta.Grind.SplitCandidateWithAnchor | null | true |
Function.HasUncurry.recOn | Mathlib.Logic.Function.Basic | {α : Type u_5} →
{β : Type u_6} →
{γ : Type u_7} →
{motive : Function.HasUncurry α β γ → Sort u} →
(t : Function.HasUncurry α β γ) → ((uncurry : α → β → γ) → motive { uncurry := uncurry }) → motive t | null | false |
CategoryTheory.Limits.CatCospanTransformMorphism.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | Sort u →
{A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{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.Cat... | null | false |
ENNReal.canLift | Mathlib.Basic.ENNReal.Basic | CanLift ENNReal NNReal ENNReal.ofNNReal fun x => x ≠ ⊤ | null | true |
Lean.IR.VarId.mk._flat_ctor | Lean.Compiler.IR.Basic | Lean.IR.Index → Lean.IR.VarId | null | false |
Set.Ico_eq_Ioc_same_iff | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico b a = Set.Ioc b a ↔ ¬b < a | null | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReduced.nodup_rightInvSeq._simp_1_7 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) | null | false |
IsMulFG | Mathlib.GroupTheory.Finiteness | (M : Type u_3) → [Mul M] → Prop | A type with multiplication is finitely generated if there is a finite subset such that every
element of the type can be written as a finite product of elements from this finite subset.
This generalizes and will eventually replace the four existing definitions
`Submonoid.FG`, `Monoid.FG`, `Subgroup.FG`, and `Group.FG`.... | true |
_private.Mathlib.Order.UpperLower.Closure.0.upperClosure_min.match_1_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} (_a : α) (motive : _a ∈ ↑(upperClosure s) → Prop)
(x : _a ∈ ↑(upperClosure s)), (∀ (_b : α) (hb : _b ∈ s) (hba : _b ≤ _a), motive ⋯) → motive x | null | false |
AddMonoidAlgebra.ring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] (a b : AddMonoidAlgebra R M), a - b = a + -b | null | false |
Matroid.uniqueBaseOn_inter_isBasis | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, X ⊆ E → (Matroid.uniqueBaseOn I E).IsBasis (X ∩ I) X | null | true |
Graph.map._proof_1 | Mathlib.Combinatorics.Graph.Maps | ∀ {α : Type u_1} {α' : Type u_2} {β : Type u_3} (f : α → α') (G : Graph α β) ⦃e : β⦄ ⦃x y v w : α'⦄,
Relation.Map (G.IsLink e) f f x y → Relation.Map (G.IsLink e) f f v w → x = v ∨ x = w | null | false |
ShareCommon.Object.ptrEq | Init.ShareCommon | ShareCommon.Object → ShareCommon.Object → Bool | null | true |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandFirstPrefixRapp._unsafe_rec | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.RappRef → Aesop.SafeExpansionM Q Unit | null | false |
NumberField.mixedEmbedding.fundamentalCone.equivFinRank._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K],
Fintype.card (Fin (NumberField.Units.rank K)) = Fintype.card { w // w ≠ NumberField.Units.dirichletUnitTheorem.w₀ } | null | false |
Std.Time.Internal.Bounded.LE.ofNatWrapping._proof_7 | Std.Time.Internal.Bounded | ∀ {lo hi : ℤ} (val : ℤ),
lo ≤ lo + (val - lo) % (hi - lo + 1) →
(val - lo) % (hi - lo + 1) < hi - lo + 1 →
lo ≤ ((val - lo) % (hi - lo + 1) + (hi - lo + 1)) % (hi - lo + 1) + lo ∧
((val - lo) % (hi - lo + 1) + (hi - lo + 1)) % (hi - lo + 1) + lo ≤ hi | null | false |
AddSubmonoid.comap_map_eq_of_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ (S : AddSubmonoid M), AddSubmonoid.comap f (AddSubmonoid.map f S) = S | null | true |
AddSubmonoid.IsSpanning.of_le | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_1} [inst : AddGroup G] {M N : AddSubmonoid G}, M.IsSpanning → M ≤ N → N.IsSpanning | null | true |
CategoryTheory.MonoidalCategory.whiskerLeft_rightUnitor | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associato... | null | true |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_of_lt_base | Init.Data.Nat.ToString | ∀ {b n fuel : ℕ} {cs : List Char}, n < b → n < fuel → b.toDigitsCore fuel n cs = n.digitChar :: cs | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Bilinear.0.pow_mulRightLinearMap.match_1_1 | Mathlib.LinearAlgebra.Matrix.Bilinear | ∀ (motive : ℕ → Prop) (k : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive k | null | false |
ContinuousMapZero.instAddCommMonoid._proof_2 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : AddCommMonoid R] [inst_4 : ContinuousAdd R] (a : ContinuousMapZero X R), 0 + a = a | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.formatWith.match_33 | Std.Time.Format.Basic | (motive : (format : Std.Time.ZoneName) → Std.Time.TypeFormat (Std.Time.Modifier.z format) → Sort u_1) →
(format : Std.Time.ZoneName) →
(data : Std.Time.TypeFormat (Std.Time.Modifier.z format)) →
((data : Std.Time.TypeFormat (Std.Time.Modifier.z Std.Time.ZoneName.short)) →
motive Std.Time.ZoneName.... | null | false |
CategoryTheory.ProjectiveResolution.liftCompHomotopy._proof_2 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y)
(R : CategoryTheory.ProjectiveResolution Z),
CategoryTheory.CategoryStruct.comp
(Cate... | null | false |
TemperedDistribution.fourierMultiplierCLM.congr_simp | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {E : Type u_3} (F : Type u_4) [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : NormedSpace ℂ F] [inst_4 : FiniteDimensional ℝ E]
[inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] (g g_1 : E → ℂ),
g = g_1 → TemperedDistribution.fourierMultiplierCLM F g =... | null | true |
derivWithin_congr | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
Set.EqOn f₁ f s → f₁ x = f x → derivWithin f₁ s x = derivWithin f s x | null | true |
NNReal.enorm_eq | Mathlib.Analysis.Normed.Ring.Basic | ∀ (x : NNReal), ‖↑x‖ₑ = ↑x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.