name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Valued.hasBasis_nhds_zero | Mathlib.Topology.Algebra.Valued.ValuationTopology | ∀ (R : Type u) [inst : Ring R] (Γ₀ : Type v) [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [_i : Valued R Γ₀],
(nhds 0).HasBasis (fun x => True) fun γ => {x | Valued.v.restrict x < ↑γ} | null | true |
QuotientGroup.quotientMulEquivOfEq.congr_simp | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {G : Type u} [inst : Group G] {M N : Subgroup G} [inst_1 : M.Normal] [inst_2 : N.Normal] (h : M = N),
QuotientGroup.quotientMulEquivOfEq h = QuotientGroup.quotientMulEquivOfEq h | null | true |
Std.TreeMap.getKey?_maxKeyD | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback : α}, t.getKey? (t.maxKeyD fallback) = some (t.maxKeyD fallback) | null | true |
Std.ExtHashSet.get?_ofList_of_mem | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true → List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (Std.ExtHashSet.ofList l).get? k' = some k | null | true |
CategoryTheory.ShortComplex.π₂Toπ₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
CategoryTheory.ShortComplex.π₂ ⟶ CategoryTheory.ShortComplex.π₃ | The natural transformation `π₂ ⟶ π₃` induced by `S.g` for all `S : ShortComplex C`. | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse.0.Real.cosPartialHomeomorph._proof_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ ⦃x_1 : ℝ⦄, x_1 ∈ Set.Ioo 0 Real.pi → Real.cos x_1 ∈ Set.Ioo (-1) 1 | null | false |
MeasurableSet.sInter | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} {s : Set (Set α)},
s.Countable → (∀ t ∈ s, MeasurableSet t) → MeasurableSet (⋂₀ s) | null | true |
Array.scanlM_reverse | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {init : β} [inst : Monad m] [LawfulMonad m] {f : β → α → m β}
{as : Array α}, Array.scanlM f init as.reverse = Array.reverse <$> Array.scanrM (flip f) init as | null | true |
ContinuousGeneratedByCat.Hom.mk._flat_ctor | Mathlib.Topology.Convenient.Category | {ι : Type t} →
{X : ι → Type u} →
[inst : (i : ι) → TopologicalSpace (X i)] →
{Y Z : ContinuousGeneratedByCat X} → Topology.ContinuousMapGeneratedBy X ↑Y ↑Z → Y.Hom Z | null | false |
CommGrpCat.hasForgetToGroup.eq_1 | Mathlib.Algebra.Category.Grp.Basic | CommGrpCat.hasForgetToGroup =
{
forget₂ :=
{ obj := fun X => ↧↑X, map := fun {X Y} f => GrpCat.ofHom (CommGrpCat.Hom.hom f),
map_id := CommGrpCat.hasForgetToGroup._proof_1, map_comp := @CommGrpCat.hasForgetToGroup._proof_2 },
forget_comp := CommGrpCat.hasForgetToGroup._proof_4 } | null | true |
AddMonoidAlgebra.single_add_single_inj | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {r₁ r₂ : R} {m₁ m₂ m₁' m₂' : M},
r₁ ≠ 0 →
r₂ ≠ 0 →
(AddMonoidAlgebra.single m₁ r₁ + AddMonoidAlgebra.single m₂ r₂ =
AddMonoidAlgebra.single m₁' r₁ + AddMonoidAlgebra.single m₂' r₂ ↔
m₁ = m₁' ∧ m₂ = m₂' ∨ r₁ = r₂ ∧ m₁ = m₂' ∧ m₂ = m₁' ∨ r₁... | null | true |
CochainComplex.Plus.modelCategoryQuillen.instModelCategory._proof_10 | Mathlib.Algebra.Homology.ModelCategory.Injective | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
[CategoryTheory.EnoughInjectives C],
(HomotopicalAlgebra.cofibrations (CochainComplex.Plus C)).HasFactorization
(HomotopicalAlgebra.trivialFibrations (CochainComplex.Plus C)) | null | false |
CategoryTheory.SmallObject.SuccStruct.ofCocone_obj_eq_pt._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.FunctorOfCocone | ∀ {J : Type u_1} [inst : LinearOrder J] {j : J}, j ∈ Set.Iic j | null | false |
Std.BundledIterM._sizeOf_1 | Std.Data.Iterators.Lemmas.Equivalence.Basic | {m : Type w → Type w'} → {β : Type w} → [(a : Type w) → SizeOf (m a)] → [SizeOf β] → Std.BundledIterM m β → ℕ | null | false |
CircularPartialOrder.mk.noConfusion | Mathlib.Order.Circular | {α : Type u_1} →
{P : Sort u} →
{toCircularPreorder : CircularPreorder α} →
{btw_antisymm : ∀ {a b c : α}, btw a b c → btw c b a → a = b ∨ b = c ∨ c = a} →
{toCircularPreorder' : CircularPreorder α} →
{btw_antisymm' : ∀ {a b c : α}, btw a b c → btw c b a → a = b ∨ b = c ∨ c = a} →
... | null | false |
_private.Mathlib.Probability.Process.Predictable.0.MeasureTheory.IsStronglyPredictable.of_measurable_add_one.match_1_1.splitter | Mathlib.Probability.Process.Predictable | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | true |
_private.Mathlib.Analysis.Calculus.Rademacher.0.LipschitzWith.integral_inv_smul_sub_mul_tendsto_integral_lineDeriv_mul'._simp_1_1 | Mathlib.Analysis.Calculus.Rademacher | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
ModuleCat.image | Mathlib.Algebra.Category.ModuleCat.Images | {R : Type u} → [inst : Ring R] → {G H : ModuleCat R} → (G ⟶ H) → ModuleCat R | The image of a morphism in `ModuleCat R` is just the bundling of `LinearMap.range f` | true |
_private.Lean.Compiler.LCNF.StructProjCases.0.Lean.Compiler.LCNF.StructProjCases.findStructCtorInfo?._sparseCasesOn_6 | Lean.Compiler.LCNF.StructProjCases | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
String.Slice.Pos.instLinearOrderPackage._proof_8 | Init.Data.String.OrderInstances | ∀ {s : String.Slice},
let this := inferInstance;
let this_1 := inferInstance;
let this_2 :=
let this := inferInstance;
let this_2 := inferInstance;
Min.leftLeaningOfLE s.Pos;
∀ (a b : s.Pos), a ⊓ b = if a ≤ b then a else b | null | false |
Bool.toUInt16 | Init.Data.UInt.Basic | Bool → UInt16 | Converts `true` to `1` and `false` to `0`.
| true |
_private.Mathlib.ModelTheory.Algebra.Field.IsAlgClosed.0.FirstOrder.Field.instModelACFOfCharPOfIsAlgClosed._simp_3 | Mathlib.ModelTheory.Algebra.Field.IsAlgClosed | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.gci._proof_5 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (x : X.IdealSheafData), sSup {J | J.ideal ≤ x.ideal} ≤ x | null | false |
AlgEquiv.coe_apply_coe_coe_symm_apply | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] {F : Type u_1} [inst_5 : EquivLike F A₁ A₂]
[inst_6 : AlgEquivClass F R A₁ A₂] (f : F) (x : A₂), f ((↑f).symm x) = x | **Alias** of `AlgEquiv.apply_ofClass_symm_apply`. | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_mem_pairs._simp_1_4 | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Mathlib.Tactic.Coherence.LiftHom.associatorInv | Mathlib.Tactic.CategoryTheory.Coherence | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(X Y Z : C) →
[inst_2 : Mathlib.Tactic.Coherence.LiftObj X] →
[inst_3 : Mathlib.Tactic.Coherence.LiftObj Y] →
[inst_4 : Mathlib.Tactic.Coherence.LiftObj Z] →
... | null | true |
_private.Mathlib.RingTheory.PowerSeries.Inverse.0.PowerSeries.instStrongNormalizationMonoid._simp_2 | Mathlib.RingTheory.PowerSeries.Inverse | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), a⁻¹ * b⁻¹ = (a * b)⁻¹ | null | false |
_private.Mathlib.Topology.Spectral.ConstructibleTopology.0.compactSpace_withConstructibleTopology._proof_15 | Mathlib.Topology.Spectral.ConstructibleTopology | ∀ {X : Type u_1} [inst : TopologicalSpace X],
∀ s ∈ {P | P ⊆ constructibleTopologySubbasis X ∧ (∀ Q ⊆ P, Q.Finite → (⋂₀ Q).Nonempty) ∧ ⋂₀ P = ∅},
∀ (B : Set (Set X)) (Y₁ Y₂ : Set X),
⋂₀ {s | s ∈ B ∧ IsClosed s} ⊆ Y₁ ∪ Y₂ →
∀ x₁ ∈ ⋂₀ {s | s ∈ B ∧ IsClosed s} ∩ Y₁ᶜ,
∀ x₂ ∈ ⋂₀ {s | s ∈ B ∧ Is... | null | false |
Matrix.toLinAlgEquiv_mul | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type u_4} [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M₁ : Type u_5}
[inst_3 : AddCommMonoid M₁] [inst_4 : Module R M₁] (v₁ : Module.Basis n R M₁) (A B : Matrix n n R),
(Matrix.toLinAlgEquiv v₁) (A * B) = (Matrix.toLinAlgEquiv v₁) A ∘ₗ (Matrix.toLinAlgEquiv v₁) B | null | true |
MeasurableSet.disjointed | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {mα : MeasurableSpace α} {f : ℕ → Set α},
(∀ (i : ℕ), MeasurableSet (f i)) → ∀ (n : ℕ), MeasurableSet (disjointed f n) | null | true |
CategoryTheory.Discrete.productEquiv._proof_13 | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ {J : Type u_2} {K : Type u_1} {X Y : CategoryTheory.Discrete (J × K)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Discrete (J × K))).map f)
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Discrete (J × K))).obj Y)).hom =
CategoryTheory.C... | null | false |
_private.Mathlib.Algebra.Ring.Subsemiring.Basic.0.Subsemiring.isMulCommutative_iSup._simp_1_1 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {M : Type u_2} [inst : Mul M], IsMulCommutative M = ∀ (a b : M), a * b = b * a | null | false |
IsCyclotomicExtension.Rat.isPrime_span_zeta_sub_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
(Ideal.span {hζ.toInteger - 1}).IsPrime | null | true |
IntermediateField.fintypeOfAlgHomAdjoinIntegral | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | (F : Type u_1) →
[inst : Field F] →
{E : Type u_2} →
[inst_1 : Field E] →
[inst_2 : Algebra F E] →
{α : E} →
{K : Type u} → [inst_3 : Field K] → [inst_4 : Algebra F K] → IsIntegral F α → Fintype (↥F⟮α⟯ →ₐ[F] K) | Fintype of algebra homomorphism `F⟮α⟯ →ₐ[F] K` | true |
Std.DTreeMap.Internal.Const.RccSliceData._sizeOf_1 | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} → {inst : Ord α} → [SizeOf α] → [SizeOf β] → Std.DTreeMap.Internal.Const.RccSliceData α β → ℕ | null | false |
LieModuleHom.mk | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
... | null | true |
Rat.zero_num | Init.Data.Rat.Lemmas | Rat.num 0 = 0 | null | true |
MonoidHom.subsingleton_coe_range | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {N : Type u_4} [inst_1 : Group N] [Subsingleton G] (f : G →* N),
(↑f.range).Subsingleton | null | true |
Polynomial.leadingCoeff_map_of_leadingCoeff_ne_zero | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {p : Polynomial R} (f : R →+* S),
f p.leadingCoeff ≠ 0 → (Polynomial.map f p).leadingCoeff = f p.leadingCoeff | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.subgraphOfAdj_symm._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
_private.Batteries.Data.MLList.Basic.0.MLList.MLListImpl.thunk.noConfusion | Batteries.Data.MLList.Basic | {m : Type u → Type u} →
{α : Type u} →
{P : Sort u_1} →
{a a' : Thunk (MLList.MLListImpl✝ m α)} →
MLList.MLListImpl.thunk✝ a = MLList.MLListImpl.thunk✝ a' → (a ≍ a' → P) → P | null | false |
Set.zero_mem_sub_iff | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s t : Set α}, 0 ∈ s - t ↔ ¬Disjoint s t | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.proj._regBuiltin.Lean.Parser.Term.proj.formatter_9 | Lean.Parser.Term | IO Unit | null | false |
Inclusion.InclusionConfig.mk._flat_ctor | Mathlib.Tactic.Inclusion.Core.Core | Bool → Bool → Lean.NameMap Lean.Expr → Array Lean.Name → Inclusion.InclusionConfig | null | false |
ValuationSubring.instSemilatticeSup._proof_3 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (R S : ValuationSubring K), ∀ x ∈ S, x ∈ R.toSubring ⊔ S.toSubring | null | false |
_private.Init.Data.List.Impl.0.List.takeWhileTR.go._sunfold | Init.Data.List.Impl | {α : Type u_1} → (α → Bool) → List α → List α → Array α → List α | null | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.checkSuccess | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm | {matType : ℕ → ℕ → Type} →
[inst : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType] →
Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Bool | Check if the solution is found: the objective function is positive and all basic variables are
nonnegative.
| true |
CategoryTheory.PreOneHypercover.Homotopy.wl | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} {f g : E.Hom F} (self : CategoryTheory.PreOneHypercover.Homotopy f g)
(i : E.I₀), CategoryTheory.CategoryStruct.comp (self.a i) (F.p₁ (self.H i)) = f.h₀ i | null | true |
LSeriesSummable_congr' | Mathlib.NumberTheory.LSeries.Basic | ∀ {f g : ℕ → ℂ} (s : ℂ), f =ᶠ[Filter.atTop] g → (LSeriesSummable f s ↔ LSeriesSummable g s) | If `f` and `g` agree on large `n : ℕ`, then the `LSeries` of `f` converges at `s`
if and only if that of `g` does. | true |
AlgebraicTopology.DoldKan.Γ₀.Obj.obj₂._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K : ChainComplex C ℕ) (Δ : SimplexCategoryᵒᵖ) [CategoryTheory.Limits.HasFiniteCoproducts C],
CategoryTheory.Limits.HasColimit
(CategoryTheory.Discrete.functor fun A => AlgebraicTopology.DoldKan.Γ₀.Obj.summand... | null | false |
_private.Mathlib.Order.UpperLower.Relative.0.isRelLowerSet_Icc_ge._simp_1_1 | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
NumberField.InfinitePlace.Completion.instNormedField._proof_12 | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} [inst : Field K] (v : NumberField.InfinitePlace K) (a : v.Completion), 0 * a = 0 | null | false |
Lean.Lsp.instFromJsonCodeActionContext | Lean.Data.Lsp.CodeActions | Lean.FromJson Lean.Lsp.CodeActionContext | null | true |
Algebra.PreSubmersivePresentation.differential._proof_1 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u_1} {S : Type u_3} {ι : Type u_2} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ),
RingHomInvPair (RingHom.id P.Ring) (RingHom.id P.Ring) | null | false |
CommRingCat.moduleCatExtendScalarsPseudofunctor._proof_6 | Mathlib.Algebra.Category.ModuleCat.Pseudofunctor | ∀ {b₀ b₁ : CommRingCat} (f : b₀ ⟶ b₁),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Cat.Hom.isoMk
(ModuleCat.extendScalarsComp (CommRingCat.Hom.hom f)
(CommRingCat.Hom.hom (CategoryTheory.CategoryStruct.id b₁)))).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.B... | null | false |
TopCat.toSSetObjEquiv_σ_apply | Mathlib.AlgebraicTopology.SimplicialSet.TopAdj | ∀ {X : TopCat} {n : ℕ} (x : (TopCat.toSSet.obj X).obj (Opposite.op { len := n })) (i : Fin (n + 1))
(z : Convexity.StdSimplex ℝ (Fin (n + 2))),
((X.toSSetObjEquiv (Opposite.op { len := n + 1 }))
((CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.σ (TopCat.toSSet.obj X) i)) x))
z =
... | null | true |
List.Cursor.length_prefix_le_length | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {c : l.Cursor}, c.prefix.length ≤ l.length | null | true |
Unitary.instMulActionSubtypeMemSubmonoidUnitary._proof_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} {A : Type u_2} [inst : Monoid R] [inst_1 : Monoid A] [inst_2 : MulAction R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] [inst_5 : StarMul R] [inst_6 : StarMul A]
[inst_7 : StarModule R A] (x x_1 : ↥(unitary R)) (x_2 : ↥(unitary A)), (x * x_1) • x_2 = x • x_1 • x_2 | null | false |
Lean.Lsp.instToJsonClientCapabilities.toJson | Lean.Data.Lsp.Capabilities | Lean.Lsp.ClientCapabilities → Lean.Json | null | true |
Set.principalSegIioIicOfLE._proof_2 | Mathlib.Order.Interval.Set.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] {i j : α} (h : i ≤ j) (x x_1 : ↑(Set.Iio i)),
(fun k => ⟨↑k, ⋯⟩) x = (fun k => ⟨↑k, ⋯⟩) x_1 → x = x_1 | null | false |
MeasureTheory.measureReal_eq_measureReal_of_null_sdiff._auto_1 | Mathlib.MeasureTheory.Measure.Real | Lean.Syntax | null | false |
CommBialgCat.Hom._mkInternal.sizeOf_spec | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u} [inst : CommRing R] {A B : CommBialgCat R} [inst_1 : SizeOf R] (hom' : ↑A →ₐc[R] ↑B),
sizeOf { hom' := hom' } = 1 + sizeOf hom' | null | false |
instIdempotentOpInt64HAnd | Init.Data.SInt.Bitwise | Std.IdempotentOp fun x1 x2 => x1 &&& x2 | null | true |
Std.Iter.toList_takeWhile_of_finite | Std.Data.Iterators.Lemmas.Combinators.TakeWhile | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {P : β → Bool} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.takeWhile P it).toList = List.takeWhile P it.toList | null | true |
Measurable.of_uncurry_right | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
{f : α → β → γ}, Measurable (Function.uncurry f) → ∀ {y : β}, Measurable fun x => f x y | null | true |
QuotientAddGroup.orbit_mk_eq_vadd | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (x : α), AddAction.orbitRel.Quotient.orbit ↑x = x +ᵥ ↑s | null | true |
DividedPowers.ofInjective._proof_5 | Mathlib.RingTheory.DividedPowers.Padic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] (I : Ideal A) (J : Ideal B)
(f : A →+* B),
Function.Injective ⇑f →
∀ (hJ : DividedPowers J),
Ideal.map f I = J →
∀ (hmem : ∀ (n : ℕ) {x : A}, x ∈ I → ∃ y, ∃ (_ : n ≠ 0 → y ∈ I), f y = hJ.dpow n (f x)) {n : ℕ} {x y : ... | null | false |
ContinuousMultilinearMap.continuous_precomp | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopological... | null | true |
IdealFilter.isPFilter_gabrielComposition | Mathlib.RingTheory.IdealFilter.Basic | ∀ {A : Type u_1} [inst : Ring A] (F G : IdealFilter A), Order.IsPFilter {L | ∃ K ∈ G, F.IsTorsionQuot L K} | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach.0.Std.Iterators.Types.Attach.Monadic.modifyStep.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Attach | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] {P : β → Prop}
(it : Std.IterM m { out // P out }) (motive : it.internalState.inner.Step → Sort u_3) (it' : Std.IterM m β)
(h : it.internalState.inner.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.IterM m β) →
... | null | true |
CategoryTheory.Span.SpanBicat.associator_hom_hom_πᵣ_πᵣ_assoc | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | true |
_private.Mathlib.Analysis.Normed.Order.Lattice.0.Int.hasSolidNorm._simp_1 | Mathlib.Analysis.Normed.Order.Lattice | ∀ (m : ℤ), ‖m‖ = ‖↑m‖ | null | false |
Std.DTreeMap.Const.get?_inter_of_not_mem_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
{k : α}, k ∉ t₂ → Std.DTreeMap.Const.get? (t₁ ∩ t₂) k = none | null | true |
ArchimedeanClass.lt_of_lt_stdPart | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {x : K} (f : ℝ →+*o K) {r : ℝ},
0 ≤ ArchimedeanClass.mk x → r < ArchimedeanClass.stdPart x → f r < x | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Mon.mul.go.match_1.eq_2 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Mon → Lean.Grind.CommRing.Mon → Sort u_1) (m₂ : Lean.Grind.CommRing.Mon)
(h_1 : (m₁ : Lean.Grind.CommRing.Mon) → motive m₁ Lean.Grind.CommRing.Mon.unit)
(h_2 : (m₂ : Lean.Grind.CommRing.Mon) → motive Lean.Grind.CommRing.Mon.unit m₂)
(h_3 :
(pw₁ : Lean.Grind.CommRing.Power) →
... | null | true |
TopCat.toCondensedSet._proof_1 | Mathlib.Condensed.TopComparison | ∀ (x x_1 : CompHausLike fun x => True) (x_2 : x ⟶ x_1),
[CategoryTheory.EffectiveEpi x_2, CategoryTheory.Epi x_2,
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom x_2)][1 - 1]? =
some (CategoryTheory.EffectiveEpi x_2) | null | false |
CategoryTheory.Limits.BinaryBicone.toCocone_ι_app_right | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (c : CategoryTheory.Limits.BinaryBicone P Q),
c.toCocone.ι.app { as := CategoryTheory.Limits.WalkingPair.right } = c.inr | null | true |
Finsupp.edist_def | Mathlib.Analysis.Normed.Lp.Finsupp | ∀ {ι : Type u_1} {X : Type u_2} [inst : Zero X] [inst_1 : PseudoEMetricSpace X] {p : NNReal} [inst_2 : Fact (1 ≤ p)]
(f g : WithLp (↑p) (ι →₀ X)), edist f g = ((Finsupp.zipWith edist ⋯ f.ofLp g.ofLp).sum fun _i r => r ^ ↑p) ^ (↑p)⁻¹ | null | true |
LaurentSeries.powerSeriesEquivSubring._proof_2 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K], SubsemiringClass (Subring (LaurentSeries K)) (LaurentSeries K) | null | false |
Lean.Meta.Grind.Arith.Linear.State.exprToNatStructId._default | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr ℕ | null | false |
_private.Batteries.Util.Cache.0.Batteries.Tactic.Cache.get.match_1 | Batteries.Util.Cache | {α : Type} →
(motive : Lean.MetaM α ⊕ Task (Except Lean.Exception α) → Sort u_1) →
(__do_lift : Lean.MetaM α ⊕ Task (Except Lean.Exception α)) →
((t : Task (Except Lean.Exception α)) → motive (Sum.inr t)) →
((init : Lean.MetaM α) → motive (Sum.inl init)) → motive __do_lift | null | false |
Std.RecursiveMutex.tryAtomically | Std.Sync.RecursiveMutex | {m : Type → Type} →
{α β : Type} →
[Monad m] → [MonadLiftT BaseIO m] → [MonadFinally m] → Std.RecursiveMutex α → Std.AtomicT α m β → m (Option β) | `mutex.tryAtomically k` tries to lock `mutex` and runs `k` on it if it succeeds. On success the
return value of `k` is returned as `some`, on failure `none` is returned.
This function does not block on the `mutex`. Additionally `mutex.tryAtomically`, while already
holding the underlying `BaseRecursiveMutex` in the sam... | true |
_private.Mathlib.Analysis.Analytic.Composition.0.HasFPowerSeriesWithinAt.comp._simp_1_2 | Mathlib.Analysis.Analytic.Composition | ∀ {r : NNReal}, (0 < ↑r) = (0 < r) | null | false |
CategoryTheory.Triangulated.TStructure.triangleLEGT_obj_obj₂ | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
Lean.CodeAction.CommandCodeActionEntry.mk.inj | Lean.Server.CodeActions.Attr | ∀ {declName : Lean.Name} {cmdKinds : Array Lean.Name} {declName_1 : Lean.Name} {cmdKinds_1 : Array Lean.Name},
{ declName := declName, cmdKinds := cmdKinds } = { declName := declName_1, cmdKinds := cmdKinds_1 } →
declName = declName_1 ∧ cmdKinds = cmdKinds_1 | null | true |
ForInStep.yield.elim | Init.Core | {α : Type u} →
{motive : ForInStep α → Sort u_1} →
(t : ForInStep α) → t.ctorIdx = 1 → ((a : α) → motive (ForInStep.yield a)) → motive t | null | false |
Multiplicative.mem_toSubgroup._simp_1 | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {A : Type u_2} [inst : AddGroup A] (S : AddSubgroup A) (a : Multiplicative A),
(a ∈ AddSubgroup.toSubgroup S) = (Multiplicative.toAdd a ∈ S) | null | false |
Lean.Meta.Hint.Suggestion.previewSpan? | Lean.Meta.Hint | Lean.Meta.Hint.Suggestion → Option Lean.Syntax | The syntax to render in the inline diff preview. This syntax must have valid position information
and must contain the span at which the edit occurs.
| true |
Ordering.isLT_iff_eq_lt | Init.Data.Ord.Basic | ∀ {o : Ordering}, o.isLT = true ↔ o = Ordering.lt | null | true |
CategoryTheory.Precoverage.IsStableUnderSup.recOn | Mathlib.CategoryTheory.Sites.Precoverage | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.Precoverage C} →
{motive : J.IsStableUnderSup → Sort u_1} →
(t : J.IsStableUnderSup) →
((sup_mem_coverings :
∀ {X : C} {R S : CategoryTheory.Presieve X},
R ∈ J.coverings X → S ∈... | null | false |
Profinite.Extend.cocone_pt | Mathlib.Topology.Category.Profinite.Extend | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (G : CategoryTheory.Functor Profiniteᵒᵖ C)
(S : Profinite), (Profinite.Extend.cocone G S).pt = G.obj (Opposite.op S) | null | true |
HomologicalComplex₂.d_comm_assoc | Mathlib.Algebra.Homology.HomologicalBicomplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_2} {I₂ : Type u_3} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂} (K : HomologicalComplex₂ C c₁ c₂)
(i₁ i₁' : I₁) (i₂ i₂' : I₂) {Z : C} (h : (K.X i₁').X i₂' ⟶ Z),
CategoryTheory.CategoryS... | null | true |
_private.Lean.Meta.WrapInstance.0.Lean.Meta.getParentStructType?._sparseCasesOn_1 | Lean.Meta.WrapInstance | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Unitization.antilipschitzWith_addEquiv | Mathlib.Analysis.Normed.Algebra.Unitization | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : IsScalarTower 𝕜 A A] [inst_4 : SMulCommClass 𝕜 A A]
[inst_5 : RegularNormedAlgebra 𝕜 A], AntilipschitzWith 2 ⇑(Unitization.addEquiv 𝕜 A) | null | true |
StarAlgEquiv.mul_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (f g : R ≃⋆ₐ[S] R)
(x : R), (f * g) x = f (g x) | null | true |
Turing.PartrecToTM2.trLList.eq_def | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (x : List (List ℕ)),
Turing.PartrecToTM2.trLList x =
match x with
| [] => []
| l :: ls => Turing.PartrecToTM2.trList l ++ Turing.PartrecToTM2.Γ'.consₗ :: Turing.PartrecToTM2.trLList ls | null | true |
SimpleGraph.eq_top_of_chromaticNumber_eq_card | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} [inst : Fintype V], G.chromaticNumber = ↑(Fintype.card V) → G = ⊤ | null | true |
_private.Mathlib.RingTheory.LocalRing.RingHom.Basic.0.IsLocalRing.instIsLocalHomRingHomOfNontrivial._simp_1 | Mathlib.RingTheory.LocalRing.RingHom.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, IsUnit a = (a ≠ 0) | null | false |
SSet.Truncated.Path₁.vertex | Mathlib.AlgebraicTopology.SimplicialSet.Path | {X : SSet.Truncated 1} →
{n : ℕ} →
X.Path₁ n → Fin (n + 1) → X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Path₁._proof_1 }) | A path includes the data of `n + 1` 0-simplices in `X`. | true |
_private.Mathlib.Order.Zorn.0.zorn_ge_nonempty_Iic₀.match_1_3 | Mathlib.Order.Zorn | ∀ {α : Type u_1} [inst : Preorder α] (c : Set α) (motive : (∃ ub, ∀ z ∈ c, ub ≤ z) → Prop) (x : ∃ ub, ∀ z ∈ c, ub ≤ z),
(∀ (ub : α) (hub : ∀ z ∈ c, ub ≤ z), motive ⋯) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.