name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Compiler.LCNF.AuxDeclCacheKey.casesOn | Lean.Compiler.LCNF.AuxDeclCache | {motive : Lean.Compiler.LCNF.AuxDeclCacheKey → Sort u} →
(t : Lean.Compiler.LCNF.AuxDeclCacheKey) →
((pu : Lean.Compiler.LCNF.Purity) → (decl : Lean.Compiler.LCNF.Decl pu) → motive { pu := pu, decl := decl }) →
motive t | null | false |
HomogeneousSubsemiring.ext | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : AddMonoid ι] [inst_1 : Semiring A] [inst_2 : SetLike σ A]
[inst_3 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_4 : DecidableEq ι] [inst_5 : GradedRing 𝒜]
{R S : HomogeneousSubsemiring 𝒜}, R.toSubsemiring = S.toSubsemiring → R = S | null | true |
CategoryTheory.Limits.IsLimit.pushoutOfHasExactLimitsOfShape._proof_2 | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [CategoryTheory.Limits.HasPushouts C] {F : CategoryTheory.Functor J C}
{c : CategoryTheory.Limits.Cone F} {X : C} (f : c.pt ⟶ X),
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.sp... | null | false |
perfectClosure.eq_bot_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.PerfectClosure | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
perfectClosure F E = ⊥ | If `E / F` is separable, then the perfect closure of `F` in `E` is equal to `F`. Note that
the converse is not necessarily true (see https://math.stackexchange.com/a/3009197)
even when `E / F` is algebraic. | true |
_private.Mathlib.Order.Setoid.Partition.0.IndexedPartition.range_piecewise.match_1_1 | Mathlib.Order.Setoid.Partition | ∀ {ι : Type u_2} {α : Type u_3} {s : ι → Set α} {β : Type u_1} (f : ι → α → β) (x : β)
(motive : x ∈ ⋃ i, f i '' s i → Prop) (x_1 : x ∈ ⋃ i, f i '' s i),
(∀ (t : Set β) (i : ι) (hi : (fun i => f i '' s i) i = t) (ht : x ∈ t), motive ⋯) → motive x_1 | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.IsBipartite.exists_isBipartiteWith._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Bipartite | NeZero (1 + 1) | null | false |
ContinuousLinearMap.flipMultilinearEquiv._proof_4 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) {ι : Type u_2} (E : ι → Type u_3) (G : Type u_5) (G' : Type u_4) [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | null | false |
Std.Internal.List.getEntry?._sunfold | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [BEq α] → α → List ((a : α) × β a) → Option ((a : α) × β a) | null | false |
_private.Mathlib.GroupTheory.Submonoid.Inverses.0.Submonoid.leftInvEquiv._simp_2 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, (↑u⁻¹ = a) = (↑u * a = 1) | null | false |
Int.fib_neg_one | Mathlib.Data.Int.Fib.Basic | Int.fib (-1) = 1 | null | true |
MonadReader.casesOn | Init.Prelude | {ρ : Type u} →
{m : Type u → Type v} →
{motive : MonadReader ρ m → Sort u_1} → (t : MonadReader ρ m) → ((read : m ρ) → motive { read := read }) → motive t | null | false |
NumberField.instIsAlgebraicSubtypeMemSubfield | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {K : Type u_2} [inst : Field K] [inst_1 : CharZero K] [Algebra.IsAlgebraic ℚ K] (k : Subfield K),
Algebra.IsAlgebraic (↥k) K | null | true |
Set.graphOn_singleton | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x : α), Set.graphOn f {x} = {(x, f x)} | null | true |
_private.Init.Data.Nat.Internal.Linear.0.Nat.Internal.Linear.Poly.isZero.match_1.eq_1 | Init.Data.Nat.Internal.Linear | ∀ (motive : Nat.Internal.Linear.Poly → Sort u_1) (h_1 : Unit → motive [])
(h_2 : (x : Nat.Internal.Linear.Poly) → motive x),
(match [] with
| [] => h_1 ()
| x => h_2 x) =
h_1 () | null | true |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.norm_intCast_eq_one_iff._simp_1_3 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {m n : ℤ}, IsCoprime m n = (m.gcd n = 1) | null | false |
mul_le_mul_left_of_neg._simp_1 | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulStrictMono R] [AddRightMono R]
[AddRightReflectLE R] {a b c : R}, c < 0 → (c * a ≤ c * b) = (b ≤ a) | null | false |
linearIndependent_fin_succ | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {n : ℕ}
{v : Fin (n + 1) → V},
LinearIndependent K v ↔ LinearIndependent K (Fin.tail v) ∧ v 0 ∉ Submodule.span K (Set.range (Fin.tail v)) | **Alias** of `linearIndependent_finSucc`. | true |
subset_affineSpan | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : Set P), s ⊆ ↑(affineSpan k s) | A set is contained in its affine span. | true |
Lean.ScopedEnvExtension.State.mk.injEq | Lean.ScopedEnvExtension | ∀ {σ : Type} (state : σ) (activeScopes : Lean.NameSet) (delimitsLocal : Bool) (state_1 : σ)
(activeScopes_1 : Lean.NameSet) (delimitsLocal_1 : Bool),
({ state := state, activeScopes := activeScopes, delimitsLocal := delimitsLocal } =
{ state := state_1, activeScopes := activeScopes_1, delimitsLocal := delimit... | null | true |
_private.Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts.0.CategoryTheory.hasCoproduct_fin | Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C]
[CategoryTheory.Limits.HasInitial C] (n : ℕ) (f : Fin n → C), CategoryTheory.Limits.HasCoproduct f | If `C` has an initial object and binary coproducts, then it has a coproduct for objects indexed by
`Fin n`.
This is a helper lemma for `hasFiniteCoproducts_of_has_binary_and_initial`, which is more general
than this.
| true |
Lean.Parser.Command.structExplicitBinder | Lean.Parser.Command | Lean.Parser.Parser | null | true |
Lean.Meta.Contradiction.Config.emptyType | Lean.Meta.Tactic.Contradiction | Lean.Meta.Contradiction.Config → Bool | Check whether any of the hypotheses is an empty type. | true |
CoxeterSystem.length_wordProd_le | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B),
cs.length (cs.wordProd ω) ≤ ω.length | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Point___macroRules__private_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Point_0_termZ_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | Lean.Macro | null | false |
Pi.Colex.instCompleteLinearOrderColexForall._proof_10 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedGT ι] (a b : Colex ((i : ι) → α i)), Lattice.inf a b ≤ b | null | false |
MoritaEquivalence.mk.injEq | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} [inst : CommSemiring R] {A : Type u₁} [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u₂}
[inst_3 : Ring B] [inst_4 : Algebra R B] (eqv : ModuleCat A ≌ ModuleCat B)
(linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam)
(eqv_1 : ModuleCat A ≌ Modu... | null | true |
Set.one_mem_sdiv_iff._simp_2 | Mathlib.Algebra.Torsor.Basic | ∀ {G : Type u_1} {P : Type u_2} [inst : Group G] [T : Torsor G P] {s t : Set P}, (1 ∈ s /ₛ t) = ¬Disjoint s t | null | false |
HomotopicalAlgebra.FibrantObject.homMk_id | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_2 : CategoryTheory.Limits.HasTerminal C] (X : C) [inst_3 : HomotopicalAlgebra.IsFibrant X],
HomotopicalAlgebra.FibrantObject.homMk (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryS... | null | true |
Equiv.Perm.sign_inv | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] (f : Equiv.Perm α), Equiv.Perm.sign f⁻¹ = Equiv.Perm.sign f | null | true |
RootableBy.mk._flat_ctor | Mathlib.GroupTheory.Divisible | {A : Type u_1} →
{α : Type u_2} →
[inst : Monoid A] →
[inst_1 : Pow A α] →
[inst_2 : Zero α] →
(root : A → α → A) →
(∀ (a : A), root a 0 = 1) → (∀ {n : α} (a : A), n ≠ 0 → root a n ^ n = a) → RootableBy A α | null | false |
HahnEmbedding.Seed.hahnCoeff_apply | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[ins... | null | true |
Std.TreeMap.getKeyLT | Std.Data.TreeMap.AdditionalOperations | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.lt) → α | Given a proof that such a mapping exists, retrieves the largest key that is
less than the given key.
| true |
_private.Mathlib.Geometry.Convex.ConvexSpace.Defs.0.Convexity.StdSimplex.mem_range_map_iff._simp_1_9 | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
TensorProduct.induction_on | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {motive : TensorProduct R M N → Prop}
(z : TensorProduct R M N),
motive 0 →
(∀ (x : M) (y : N), motive (x ⊗ₜ[R] y)) →
(∀ (x y : TensorP... | null | true |
Finset.isPWO_support_addAntidiagonal | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α] {s t : Set α}
{hs : s.IsPWO} {ht : t.IsPWO}, {a | (Finset.antidiagonal hs ht a).Nonempty}.IsPWO | **Alias** of `Finset.isPWO_support_antidiagonal`. | true |
SSet.relativeCellComplexOfMono.Cell.ctorIdx | Mathlib.AlgebraicTopology.SimplicialSet.Skeleton | {X Y : SSet} → {i : X ⟶ Y} → {d : ℕ} → SSet.relativeCellComplexOfMono.Cell i d → ℕ | null | false |
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.ne_bot_iff._simp_1_1 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | null | false |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_11 | 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) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
CategoryTheory.Limits.hasFiniteLimits_of_hasLimitsLimits_of_createsFiniteLimits | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasFiniteLimits D]
[CategoryTheory.Limits.CreatesFiniteLimits F], CategoryTheory.Limits.HasFiniteLimits C | null | true |
_private.Init.Data.SInt.Lemmas.0.Int32.toInt64_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x < y) = (x.toInt < y.toInt) | null | false |
SSet.finite_of_hasDimensionLT | Mathlib.AlgebraicTopology.SimplicialSet.Finite | ∀ (X : SSet) (d : ℕ) [X.HasDimensionLT d], (∀ i < d, Finite ↑(X.nonDegenerate i)) → X.Finite | null | true |
Language.one_add_self_mul_kstar_eq_kstar | Mathlib.Computability.Language | ∀ {α : Type u_1} (l : Language α), 1 + l * KStar.kstar l = KStar.kstar l | null | true |
Int16.add_eq_left._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a + b = a) = (b = 0) | null | false |
Std.ExtDHashMap.getKey_eq_getKey! | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {a : α} {h : a ∈ m}, m.getKey a h = m.getKey! a | null | true |
_private.Mathlib.Order.Filter.Map.0.Filter.compl_mem_kernMap._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {m : α → β} {f : Filter α} {s : Set β},
(s ∈ Filter.kernMap m f) = ∃ t, tᶜ ∈ f ∧ m '' t = sᶜ | null | false |
divp_mul_eq_mul_divp | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : CommMonoid α] (x y : α) (u : αˣ), x /ₚ u * y = x * y /ₚ u | null | true |
Std.Do.SPred.Tactic.instIsPure | Std.Do.SPred.DerivedLaws | ∀ {φ : Prop} {σ : Type u_1} {s : σ} (σs : List (Type u_1)) (P : Std.Do.SPred (σ :: σs))
[inst : Std.Do.SPred.Tactic.IsPure P φ], Std.Do.SPred.Tactic.IsPure (P s) φ | null | true |
TopRep.coind₁ι._proof_2 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u_3} [inst : TopologicalSpace k] [inst_1 : Ring k] {G : Type u_1} [inst_2 : Group G] (rep : TopRep k G),
IsTopologicalAddGroup ↑rep | null | false |
String.Slice.RevByteIterator.ctorIdx | Init.Data.String.Iterate | String.Slice.RevByteIterator → ℕ | null | false |
NonUnitalSubsemiring.corner._proof_4 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalSemiring R] {a b : R},
a ∈ (Subsemigroup.corner e).carrier → b ∈ (Subsemigroup.corner e).carrier → a * b ∈ (Subsemigroup.corner e).carrier | null | false |
Std.DTreeMap.Internal.Impl.get_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
[inst_1 : Std.LawfulEqOrd α] (h : t.WF) {k a : α} {v : β k} {h₁ : a ∈ Std.DTreeMap.Internal.Impl.insertIfNew! k v t},
(Std.DTreeMap.Internal.Impl.insertIfNew! k v t).get a h₁ =
if h₂ : compare k a = Or... | null | true |
_private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosed.liftAux | Mathlib.FieldTheory.IsAlgClosed.Basic | (K : Type u) →
[inst : Field K] →
(L : Type v) →
(M : Type w) →
[inst_1 : Field L] →
[inst_2 : Algebra K L] →
[inst_3 : Field M] → [inst_4 : Algebra K M] → [IsAlgClosed M] → [Algebra.IsAlgebraic K L] → L →ₐ[K] M | Less general version of `lift`. | true |
_private.Mathlib.GroupTheory.Subgroup.Centralizer.0.Subgroup.normalizerMonoidHom_ker._simp_1_6 | Mathlib.GroupTheory.Subgroup.Centralizer | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a = b * c⁻¹) = (a * c = b) | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique.0.AlgebraNorm.instFieldCopy._proof_22 | Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique | ∀ {K : Type u_1} {L : Type u_2} [inst : NontriviallyNormedField K] [inst_1 : Field L] [inst_2 : Algebra K L]
(_f : AlgebraNorm K L) (x : L), autoParam (∀ (x_1 : AlgebraNorm.copy✝ _f x), x_1 ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
_private.Mathlib.Data.Set.SMulAntidiagonal.0.Set.SMulAntidiagonal.finite_of_finite_fst._proof_1_3 | Mathlib.Data.Set.SMulAntidiagonal | ∀ {G : Type u_1} {P : Type u_2} {s : Set G} [inst : SMul G P] [IsLeftCancelSMul G P] (t : Set P) (p : P),
∀ x ∈ s.smulAntidiagonal t p, ∀ x_2 ∈ s.smulAntidiagonal t p, x.1 = x_2.1 → x = x_2 | null | false |
_private.Lean.Meta.Basic.0.Lean.Meta.isSyntheticMVar.match_1 | Lean.Meta.Basic | (motive : Lean.MetavarKind → Sort u_1) →
(__do_lift : Lean.MetavarKind) →
(Unit → motive Lean.MetavarKind.synthetic) →
(Unit → motive Lean.MetavarKind.syntheticOpaque) → ((x : Lean.MetavarKind) → motive x) → motive __do_lift | null | false |
CategoryTheory.Pseudofunctor.DescentData.toDescentDataCompPullFunctorIso | Mathlib.CategoryTheory.Sites.Descent.DescentData | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{S' : C} →
{p : S' ⟶ S} →
... | Given families of morphisms `f : X i ⟶ S` and `f' : X' j ⟶ S'`, suitable
commutative diagrams `w j : p' j ≫ f (α j) = f' j ≫ p`, this is the natural
isomorphism between the descent data relative to `f'` that are obtained either:
* by considering the obvious descent data relative to `f` given by an object `M : F.obj (op... | true |
MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuousMap_continuous_integral | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.ProbabilityMeasure Ω} [CompactSpace Ω],
Continuous μs ↔ ∀ (f : C(Ω, ℝ)), Continuous fun x => ∫ (ω : Ω), f ω ∂↑(μs x) | The characterization of weak convergence of probability measures by the usual (defining)
condition that the integrals of every continuous bounded function are continuous. | true |
Metric.frontier_thickening_disjoint | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (A : Set α),
Pairwise (Function.onFun Disjoint fun r => frontier (Metric.thickening r A)) | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable.0.EisensteinSeries.E2_eq_tsum_cexp._simp_1_6 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Summable | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Mathlib.Tactic.NormNum.NatFactorial.0.Mathlib.Meta.NormNum.evalNatDescFactorial._proof_2 | Mathlib.Tactic.NormNum.NatFactorial | ∀ (x y z : Q(ℕ)), «$x» =Q «$z» + «$y» | null | false |
denselyOrdered_multiplicative_iff | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {X : Type u_2} [inst : LT X], DenselyOrdered (Multiplicative X) ↔ DenselyOrdered X | null | true |
Lean.Lsp.SemanticTokenType.method.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SemanticTokenType.method = 1 | null | true |
RatFunc.valuation_isEquiv_adic_of_valuation_X_le_one | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_1} {Γ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [Valuation.IsTrivialOn K v] [v.IsNontrivial],
v RatFunc.X ≤ 1 → ∃ u, v.IsEquiv (IsDedekindDomain.HeightOneSpectrum.valuation (RatFunc K) u) | null | true |
GrpCat.uliftFunctor_preservesLimitsOfSize | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.Limits.PreservesLimitsOfSize.{w', w, u, max u v, u + 1, max (u + 1) (v + 1)} GrpCat.uliftFunctor | The universe lift for groups preserves limits of arbitrary size.
| true |
MeasureTheory.regular_inv_iff | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : Group G] [IsTopologicalGroup G], μ.inv.Regular ↔ μ.Regular | null | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter.match_3.eq_3 | Std.Data.DTreeMap.Internal.Operations | ∀ (motive : Ordering → Sort u_1) (h_1 : Ordering.eq = Ordering.lt → motive Ordering.lt)
(h_2 : Ordering.eq = Ordering.gt → motive Ordering.gt) (h_3 : Ordering.eq = Ordering.eq → motive Ordering.eq),
(match h : Ordering.eq with
| Ordering.lt => h_1 h
| Ordering.gt => h_2 h
| Ordering.eq => h_3 h) =
h... | null | true |
ULift.semiring._proof_5 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Semiring R] (n : ℕ) (x : ULift.{u_1, u_2} R), x ^ (n + 1) = x ^ n * x | null | false |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.nonempty_algHom_adjoin_of_splits.match_1_1 | Mathlib.FieldTheory.Extension | ∀ {F : Type u_3} {E : Type u_1} {K : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Field K]
[inst_3 : Algebra F E] [inst_4 : Algebra F K] {S : Set E}
(motive : (∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb) → Prop)
(x : ∃ φ, φ.comp (IntermediateField.inclusion ⋯) = ⊥.emb),
(∀ (φ : ↥(Intermediat... | null | false |
CategoryTheory.Limits.CatCospanTransform.inv_whiskerRight | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type 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.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | true |
EReal.abs_neg | Mathlib.Data.EReal.Inv | ∀ (x : EReal), (-x).abs = x.abs | null | true |
Std.Http.Internal.Mock.Server.casesOn | Std.Http.Transport | {motive : Std.Http.Internal.Mock.Server → Sort u} →
(t : Std.Http.Internal.Mock.Server) →
((shared : Std.Http.Internal.Mock.SharedState✝) → motive { shared := shared }) → motive t | null | false |
Mathlib.Tactic.Ring.ExProd.cast._unsafe_rec | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{v : Lean.Level} →
{β : Q(Type v)} →
{sβ : Q(CommSemiring «$β»)} →
{a : Q(«$α»)} → Mathlib.Tactic.Ring.ExProd sα a → (a : Q(«$β»)) × Mathlib.Tactic.Ring.ExProd sβ a | null | false |
Std.DHashMap.Raw.get!_inter_of_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α} [inst_3 : Inhabited (β k)], k ∈ m₂ → (m₁ ∩ m₂).get! k = m₁.get! k | null | true |
NumberField.mixedEmbedding.convexBodySum.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B B_1 : ℝ),
B = B_1 →
∀ (a a_1 : NumberField.mixedEmbedding.mixedSpace K),
a = a_1 → NumberField.mixedEmbedding.convexBodySum K B a = NumberField.mixedEmbedding.convexBodySum K B_1 a_1 | null | true |
AntivaryOn.neg_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, AntivaryOn f g s → MonovaryOn (-f) g s | **Alias** of the reverse direction of `monovaryOn_neg_left`. | true |
Nat.ascFactorial_le | Mathlib.Data.Nat.Factorial.Basic | ∀ (k : ℕ) {n m : ℕ}, n ≤ m → n.ascFactorial k ≤ m.ascFactorial k | null | true |
_private.Mathlib.Analysis.Complex.Exponential.0.Real.exp_lt_two_add_div_two_sub._proof_1_4 | Mathlib.Analysis.Complex.Exponential | ∀ {x : ℝ}, x < 2 → x / 2 ≤ 1 | null | false |
Ideal.IsHomogeneous.iSup₂ | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜] {κ : Sort u_4}
{κ' : κ → Sort u_5} {f : (i : κ) → κ' i → Ideal A},
(∀ (i : κ) (j : κ' i), Ideal.IsHomogen... | null | true |
List.max?.eq_1 | Init.Data.List.MinMax | ∀ {α : Type u} [inst : Max α], [].max? = none | null | true |
Equiv.Perm.toList_ne_singleton | Mathlib.GroupTheory.Perm.Cycle.Concrete | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (p : Equiv.Perm α) (x y : α), p.toList x ≠ [y] | null | true |
CategoryTheory.Limits.IsZero.iso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (hX : CategoryTheory.Limits.IsZero X),
CategoryTheory.CategoryStruct.comp (hX.to_ Y) (hX.from_ Y) = CategoryTheory.CategoryStruct.id X | null | false |
Float.Model.UnpackedFloat.ofScientific._proof_1 | Init.Data.Float.Model.Unpacked.Operations.OfScientific | ∀ (e : ℤ), 0 < 10 ^ e.toNat | null | false |
Std.WP.WPMonad | Std.WP.Monad.Basic | (m : Type u → Type v) →
(Pred : outParam (Type w)) →
(EPred : outParam (Type w')) →
[Monad m] → [Std.WP.Assertion Pred] → [Std.WP.Assertion EPred] → Type (max (max (max (u + 1) v) w) w') | Weakest precondition monad: a monad `m` whose weakest precondition interpretation is sound for
`pure` and `bind`. The interpretation for every result type is carried as the `toWP` field; an
instance exposes it as a `WP (m α) …` interpretation. | true |
LowerSet.instDiv._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [IsOrderedMonoid α] (s t : LowerSet α),
IsLowerSet (s.carrier / ↑t) | null | false |
_private.Mathlib.Algebra.Free.0.FreeMagma.length_pos.match_1_1 | Mathlib.Algebra.Free | ∀ {α : Type u_1} (motive : FreeMagma α → Prop) (x : FreeMagma α),
(∀ (a : α), motive (FreeMagma.of a)) → (∀ (y z : FreeMagma α), motive (y.mul z)) → motive x | null | false |
Membership.mem.out | Mathlib.Data.Set.Operations | ∀ {α : Type u} {a : α} {p : α → Prop}, a ∈ {x | p x} → p a | If `h : a ∈ {x | p x}` then `h.out : p x`. These are definitionally equal, but this can
nevertheless be useful for various reasons, e.g. to apply further projection notation or in an
argument to `simp`. | true |
CategoryTheory.Limits.pullbackConeOfLeftIso_fst | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso f],
(CategoryTheory.Limits.pullbackConeOfLeftIso f g).fst = CategoryTheory.CategoryStruct.comp g (CategoryTheory.inv f) | null | true |
QuotientAddGroup.lift._proof_2 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {M : Type u_2} [inst : AddGroup G] [inst_1 : AddMonoid M] (N : AddSubgroup G) [nN : N.Normal]
(φ : G →+ M), N ≤ φ.ker → QuotientAddGroup.con N ≤ AddCon.ker φ | null | false |
SignType.ofNat | Mathlib.Basic.Sign.Defs | ℕ → SignType | null | true |
Filter.Germ.instSemigroup._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {l : Filter α} {M : Type u_2} [inst : Semigroup M] (a b c : l.Germ M), a * b * c = a * (b * c) | null | false |
LinearMap.index_of_subsingleton | Mathlib.Algebra.Module.LinearMap.Index | ∀ {M : Type u_1} {N : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup N] {R : Type u_3} [inst_2 : Ring R]
[inst_3 : Module R M] [inst_4 : Module R N] {f : M →ₗ[R] N} [Subsingleton R], f.index = 0 | null | true |
Int.mul_tmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).tmod b = 0 | null | true |
Lean.Lsp.ReferenceContext.rec | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.ReferenceContext → Sort u} →
((includeDeclaration : Bool) → motive { includeDeclaration := includeDeclaration }) →
(t : Lean.Lsp.ReferenceContext) → motive t | null | false |
Mathlib.Meta.Positivity.evalFinsetSum | Mathlib.Tactic.Positivity.Finset | Mathlib.Meta.Positivity.PositivityExt | The `positivity` extension which proves that `∑ a ∈ s, f a` is nonnegative if `f` is, and
positive if either each `f i` is and `s` is nonempty, or some `f a` is where `a ∈ s` is an
assumption.
TODO: The following example does not work
```
example (s : Finset ℕ) (f : ℕ → ℤ) (hf : ∀ n, 0 ≤ f n) : 0 ≤ s.sum f := by posit... | true |
_private.Init.Grind.Offset.0.Lean.Grind.Nat.le_offset._proof_1_1 | Init.Grind.Offset | ∀ (a k : ℕ), ¬k ≤ a + k → False | null | false |
CategoryTheory.CommGrp.forget₂Grp_obj_one | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
CategoryTheory.MonObj.one = CategoryTheory.MonObj.one | null | true |
FiniteField.instFieldExtension._proof_22 | Mathlib.FieldTheory.Finite.Extension | ∀ (k : Type u_1) [inst : Field k] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP k p] (n : ℕ),
autoParam (∀ (x : FiniteField.Extension k p n), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
AffineBasis.tot | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {ι : Type u_1} {k : Type u_5} {V : Type u_6} {P : Type u_7} [inst : AddCommGroup V] [inst_1 : AddTorsor V P]
[inst_2 : Ring k] [inst_3 : Module k V] (b : AffineBasis ι k P), affineSpan k (Set.range ⇑b) = ⊤ | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.inv_Ioc._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioc a b = Set.Ioi a ∩ Set.Iic b | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.