name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.TreeMap.minKey?_le_of_contains | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k km : α}
(hc : t.contains k = true), t.minKey?.get ⋯ = km → (cmp km k).isLE = true | null | true |
Filter.Tendsto.finInit | Mathlib.Topology.Constructions | ∀ {Y : Type v} {n : ℕ} {A : Fin (n + 1) → Type u_6} [inst : (i : Fin (n + 1)) → TopologicalSpace (A i)]
{f : Y → (j : Fin (n + 1)) → A j} {l : Filter Y} {x : (j : Fin (n + 1)) → A j},
Filter.Tendsto f l (nhds x) → Filter.Tendsto (fun a => Fin.init (f a)) l (nhds (Fin.init x)) | null | true |
Lean.Exception.internal.elim | Lean.Exception | {motive : Lean.Exception → Sort u} →
(t : Lean.Exception) →
t.ctorIdx = 1 →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive t | null | false |
SimpleGraph.Reachable.of_isUniversal | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {u : V} (v : V), G.IsUniversal u → G.Reachable u v | null | true |
Lean.LibrarySuggestions.Config._sizeOf_inst | Lean.LibrarySuggestions.Basic | SizeOf Lean.LibrarySuggestions.Config | null | false |
_private.Lean.Meta.Match.Match.0.Lean.Meta.Match.processArrayLit | Lean.Meta.Match.Match | Lean.Meta.Match.Problem → Lean.MetaM (Array Lean.Meta.Match.Problem) | null | true |
FirstOrder.Language.Formula | Mathlib.ModelTheory.Syntax | FirstOrder.Language → Type u' → Type (max u v u') | `Formula α` is the type of formulas with free variables indexed by `α` and no bound variables in
scope. | true |
TopologicalGroup.IsSES.inducedMeasure._proof_2 | Mathlib.MeasureTheory.Measure.Haar.Extension | ContinuousConstSMul ℝ ℝ | null | false |
CategoryTheory.Abelian.SpectralObject.isoMapFourδ₁Toδ₀'_hom_inv_id_assoc | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι' : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : Preorder ι'] (X' : CategoryTheory.Abelian.SpectralObject C ι') (i₀ i₁ i₂ i₃ i₄ : ι') (hi₀₁ : i₀ ≤ i₁)
(hi₁₂ : i₁ ≤ i₂) (hi₂₃ : i₂ ≤ i₃) (hi₃₄ : i₃ ≤ i₄) (n₀ n₁ n₂ : ℤ)
(h : CategoryTheory.L... | null | true |
Lean.Expr.bvarIdx? | Mathlib.Lean.Expr.Basic | Lean.Expr → Option ℕ | null | true |
OptionT.instAlternativeMonadOfMonad | Batteries.Control.AlternativeMonad | (m : Type u_1 → Type u_2) → [Monad m] → AlternativeMonad (OptionT m) | null | true |
FiniteDimensional.of_isCompact_closedBall₀ | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ (𝕜 : Type u) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {V : Type u_1} [inst_2 : NormedAddCommGroup V]
[inst_3 : Module 𝕜 V] [ContinuousSMul 𝕜 V] {r : ℝ}, 0 < r → IsCompact (Metric.closedBall 0 r) → FiniteDimensional 𝕜 V | **Riesz's theorem**: if a closed ball with center zero of positive radius is compact in a vector
space, then the space is finite-dimensional. | true |
Std.DTreeMap.Internal.Impl.getKeyD._f | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} → [Ord α] → α → α → (t : Std.DTreeMap.Internal.Impl α β) → Std.DTreeMap.Internal.Impl.below t → α | null | false |
CommAlgCat.binaryCofanIsColimit._proof_4 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (A : CommAlgCat R), IsScalarTower R R ↑A | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0.Fin.reduceAdd._regBuiltin.Fin.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.2030378594._hygCtx._hyg.31 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Rayleigh.0.ContinuousLinearMap.rayleighQuotient_le_of_mem_resolventSet._proof_1_5 | Mathlib.Analysis.InnerProductSpace.Rayleigh | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
ContinuousConstSMul 𝕜 E | null | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_3 | Lean.Meta.LitValues | (motive : Option ((n : ℕ) × Fin n) → Sort u_1) →
(__do_lift : Option ((n : ℕ) × Fin n)) →
((fst : ℕ) → (n : Fin fst) → motive (some ⟨fst, n⟩)) →
((x : Option ((n : ℕ) × Fin n)) → motive x) → motive __do_lift | null | false |
MeasureTheory.L1.integral_def | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_5} {E : Type u_6} [inst : NormedAddCommGroup E] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_1 : NormedSpace ℝ E] [inst_2 : CompleteSpace E], MeasureTheory.L1.integral = ⇑MeasureTheory.L1.integralCLM | null | true |
Matrix.cons_transpose | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {m : ℕ} {n' : Type uₙ} (v : n' → α) (A : Matrix (Fin m) n' α),
(Matrix.of (Matrix.vecCons v A)).transpose = Matrix.of fun i => Matrix.vecCons (v i) (A.transpose i) | null | true |
SeparationQuotient.lift₂.congr_simp | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} {α : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(f f_1 : X → Y → α) (e_f : f = f_1)
(hf : ∀ (a : X) (b : Y) (c : X) (d : Y), Inseparable a c → Inseparable b d → f a b = f c d)
(a a_1 : SeparationQuotient X),
a = a_1 →
∀ (a_2 a_3 : SeparationQuotient Y... | null | true |
LowerSet.instCommMonoid._proof_4 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (x : LowerSet α), x ^ 0 = 1 | null | false |
Lean.Plugin.noConfusion | Lean.Setup | {P : Sort u} → {t t' : Lean.Plugin} → t = t' → Lean.Plugin.noConfusionType P t t' | null | false |
CategoryTheory.Functor.CommShift.mk | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{A : Type u_6} →
[inst_2 : AddMonoid A] →
[inst_3 : CategoryTheory.HasShift C A] →
... | null | true |
instAddCommMonoidUniformFun._proof_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommMonoid β] (a b : UniformFun α β), a + b = b + a | null | false |
Sym2.fromRel.decidablePred._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} (sym : Std.Symm r) (a b : α), Subsingleton (Decidable (s(a, b) ∈ Sym2.fromRel sym)) | null | false |
Int.Cooper.le_zero_resolve_left | Init.Data.Int.Cooper | ∀ (a c d p x : ℤ), p ≤ a * x → 0 ≤ Int.Cooper.resolve_left a c d p x | `resolve_left` is nonnegative when `p ≤ a * x`. | true |
_private.Mathlib.Computability.AkraBazzi.GrowsPolynomially.0.AkraBazziRecurrence.GrowsPolynomially.eventually_zero_of_frequently_zero._proof_1_4 | Mathlib.Computability.AkraBazzi.GrowsPolynomially | ∀ (k : ℕ), -↑k - 1 ≤ -↑k | null | false |
Std.Http.Method.pri.sizeOf_spec | Std.Http.Data.Method | sizeOf Std.Http.Method.pri = 1 | null | true |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass | Mathlib.CategoryTheory.Abelian.Injective.Ext | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
{X Y : C} →
(R : CategoryTheory.InjectiveResolution Y) →
{n : ℕ} →
CategoryTheory.Abelian.Ext X Y n ≃
CochainCompl... | If `R` is an injective resolution of `Y`, then `Ext X Y n` identifies
to the type of cohomology classes of degree `n` from `(singleFunctor C 0).obj X`
to `R.cochainComplex`. | true |
QPF.mk.noConfusion | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type v} →
{P : Sort u_1} →
{toFunctor : Functor F} →
{P_1 : PFunctor.{u, u'}} →
{abs : {α : Type u} → ↑P_1 α → F α} →
{repr : {α : Type u} → F α → ↑P_1 α} →
{abs_repr : ∀ {α : Type u} (x : F α), abs (repr x) = x} →
{abs_map : ∀ {α β : Type u} (f : α ... | null | false |
CategoryTheory.PreZeroHypercover.bind_f | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {T : C} (E : CategoryTheory.PreZeroHypercover T)
(F : (i : E.I₀) → CategoryTheory.PreZeroHypercover (E.X i)) (ij : (i : E.I₀) × (F i).I₀),
(E.bind F).f ij = CategoryTheory.CategoryStruct.comp ((F ij.fst).f ij.snd) (E.f ij.fst) | null | true |
Std.Http.URI.RelativeRef.mk.noConfusion | Std.Http.Data.URI.Basic | {P : Sort u} →
{authority : Option Std.Http.URI.Authority} →
{path : Std.Http.URI.Path} →
{query : Option Std.Http.URI.Query} →
{fragment : Option String} →
{authority' : Option Std.Http.URI.Authority} →
{path' : Std.Http.URI.Path} →
{query' : Option Std.Http.URI.... | null | false |
CategoryTheory.Abelian.SpectralObject.liftE_ιE_fromOpcycles._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
Lean.Lsp.instFromJsonClientInfo | Lean.Data.Lsp.InitShutdown | Lean.FromJson Lean.Lsp.ClientInfo | null | true |
IO.Error.mkResourceExhaustedFile | Init.System.IOError | String → UInt32 → String → IO.Error | null | true |
CategoryTheory.pullbackShiftIso | Mathlib.CategoryTheory.Shift.Pullback | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{A : Type u_2} →
{B : Type u_3} →
[inst_1 : AddMonoid A] →
[inst_2 : AddMonoid B] →
[inst_3 : CategoryTheory.HasShift C B] →
(φ : A →+ B) →
(a : A) →
(b : B) →
... | When `b = φ a`, this is the canonical
isomorphism `shiftFunctor (PullbackShift C φ) a ≅ shiftFunctor C b`. | true |
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : Inhabited α]
(h : t.WF) {l : List α} {k : α},
k ∈ t → (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)).getKey! k = t.getKey! k | null | true |
CategoryTheory.Limits.createsColimitUnop | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
(K : CategoryTheory.Functor J C) →
(F : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ) →
... | If `F : Cᵒᵖ ⥤ Dᵒᵖ` creates limits of `K.op : Jᵒᵖ ⥤ Cᵒᵖ`, then `F.unop : C ⥤ D` creates
colimits of `K : J ⥤ C`. | true |
FractionalIdeal.count_coe_nonneg | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R) (J : Ideal R),
0 ≤ FractionalIdeal.count K v ↑J | null | true |
SubStarSemigroup.mk._flat_ctor | Mathlib.Algebra.Star.NonUnitalSubsemiring | {M : Type v} →
[inst : Mul M] →
[inst_1 : Star M] →
(carrier : Set M) →
(∀ {a b : M}, a ∈ carrier → b ∈ carrier → a * b ∈ carrier) →
(∀ {a : M}, a ∈ carrier → star a ∈ carrier) → SubStarSemigroup M | null | false |
Int.Internal.Linear.instBEqExpr.beq.match_1 | Init.Data.Int.Linear | (motive : Int.Internal.Linear.Expr → Int.Internal.Linear.Expr → Sort u_1) →
(x x_1 : Int.Internal.Linear.Expr) →
((a b : ℤ) → motive (Int.Internal.Linear.Expr.num a) (Int.Internal.Linear.Expr.num b)) →
((a b : Int.Internal.Linear.Var) → motive (Int.Internal.Linear.Expr.var a) (Int.Internal.Linear.Expr.var b... | null | false |
_private.Mathlib.Order.Northcott.0.northcott_iff_tendsto._simp_1_1 | Mathlib.Order.Northcott | ∀ {α : Type u_1} {β : Type u_2} (h : α → β) [inst : LE β], Northcott h = ∀ (b : β), {a | h a ≤ b}.Finite | null | false |
MvPolynomial.weightedDecomposition.decompose'_eq | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ (R : Type u_1) {M : Type u_2} [inst : CommSemiring R] {σ : Type u_3} (w : σ → M) [inst_1 : AddCommMonoid M]
[inst_2 : DecidableEq M],
DirectSum.Decomposition.decompose' = fun φ =>
(DirectSum.mk (fun i => ↥(MvPolynomial.weightedHomogeneousSubmodule R w i))
(Finset.image (⇑(Finsupp.weight w)) φ.support)... | null | true |
_private.Std.WP.Monad.Sound.0.Std.WP.ExceptT.instLawfulWPMonadAttach.match_1 | Std.WP.Monad.Sound | {ε : Type (max u_1 u_2)} →
(α : Type (max u_1 u_2)) →
(motive : Except ε α → Sort u_3) →
(r : Except ε α) → ((b : α) → motive (Except.ok b)) → ((a : ε) → motive (Except.error a)) → motive r | null | false |
String.Slice.eq_append_of_dropPrefix?_string_eq_some | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s res : String.Slice}, s.dropPrefix? pat = some res → s.copy = pat ++ res.copy | null | true |
CategoryTheory.SimplicialObject.Augmented.rightOpLeftOpIso_inv_right | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject.Augmented C),
X.rightOpLeftOpIso.inv.right = CategoryTheory.CategoryStruct.id X.right | null | true |
GaussianInt.toComplex._proof_1 | Mathlib.NumberTheory.Zsqrtd.GaussianInt | Complex.I * Complex.I = ↑(-1) | null | false |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_dvd.match_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℤ} (motive : a = ↑a.natAbs ∨ a = -↑a.natAbs → Prop) (x : a = ↑a.natAbs ∨ a = -↑a.natAbs),
(∀ (e : a = ↑a.natAbs), motive ⋯) → (∀ (e : a = -↑a.natAbs), motive ⋯) → motive x | null | false |
ValuativeRel.IsNontrivial.casesOn | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : Semiring R] →
[inst_1 : ValuativeRel R] →
{motive : ValuativeRel.IsNontrivial R → Sort u} →
(t : ValuativeRel.IsNontrivial R) → ((condition : ∃ γ, γ ≠ 0 ∧ γ ≠ 1) → motive ⋯) → motive t | null | false |
_private.Mathlib.Analysis.Polynomial.MahlerMeasure.0.Polynomial.logMahlerMeasure_C_mul_X_add_C._simp_1_1 | Mathlib.Analysis.Polynomial.MahlerMeasure | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | null | false |
_private.Mathlib.Analysis.Normed.Affine.AsymptoticCone.0.AffineSpace.asymptoticNhds_le_cobounded.match_1_1 | Mathlib.Analysis.Normed.Affine.AsymptoticCone | ∀ {P : Type u_1} (motive : Nonempty P → Prop) (x : Nonempty P), (∀ (p : P), motive ⋯) → motive x | null | false |
allocprof | Init.System.IO | {α : Type} → String → IO α → IO α | null | true |
Int32.not_maxValue_lt | Init.Data.SInt.Lemmas | ∀ {a : Int32}, ¬Int32.maxValue < a | null | true |
CategoryTheory.Sieve.overEquiv.eq_1 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (Y : CategoryTheory.Over X),
CategoryTheory.Sieve.overEquiv Y =
{ toFun := CategoryTheory.Sieve.functorPushforward (CategoryTheory.Over.forget X),
invFun := CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.forget X), left_inv := ⋯, ri... | null | true |
Algebra.instCompleteLatticeSubalgebra._proof_2 | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(s : Set (Subalgebra R A)), IsGLB s (sInf s) | null | false |
CategoryTheory.Iso.commSemiRingCatIsoToRingEquiv._proof_2 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommSemiRingCat} (e : R ≅ S),
(CommSemiRingCat.Hom.hom e.inv).comp (CommSemiRingCat.Hom.hom e.hom) = RingHom.id ↑R | null | false |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofEq.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {a b : Lean.Expr} {la lb : Lean.Meta.Grind.Arith.Linear.LinExpr} {a_1 b_1 : Lean.Expr}
{la_1 lb_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofEq a b la lb =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ofEq a_1 b_1 la_1 lb_1 →
a = a_1 ∧ b = b_1 ∧ la = la_1 ∧ lb ... | null | true |
LinearMap.IsNonneg.mk | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{I₁ I₂ : R →+* R} [inst_3 : LE R] {B : M →ₛₗ[I₁] M →ₛₗ[I₂] R}, (∀ (x : M), 0 ≤ (B x) x) → B.IsNonneg | null | true |
BoxIntegral.Box | Mathlib.Analysis.BoxIntegral.Box.Basic | Type u_2 → Type u_2 | A nontrivial rectangular box in `ι → ℝ` with corners `lower` and `upper`. Represents the product
of half-open intervals `(lower i, upper i]`. | true |
Std.Iter.findSome? | Init.Data.Iterators.Consumers.Loop | {α β : Type w} →
{γ : Type x} → [inst : Std.Iterator α Id β] → [Std.IteratorLoop α Id Id] → Std.Iter β → (β → Option γ) → Option γ | Returns the first non-`none` result of applying `f` to each output of the iterator, in order.
Returns `none` if `f` returns `none` for all outputs.
`O(|it|)`. Short-circuits when `f` returns `some _`.The outputs of `it` are examined in order of
iteration.
If the iterator is not finite, this function might run forever... | true |
UniformSpace.Completion.instAddMonoid._proof_11 | Mathlib.Topology.Algebra.GroupCompletion | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] (a : UniformSpace.Completion α),
0 • a = 0 | null | false |
LinearPMap.sup | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
[inst : Ring R] →
[inst_1 : Ring S] →
{σ : R →+* S} →
{E : Type u_4} →
[inst_2 : AddCommGroup E] →
[inst_3 : Module R E] →
{F : Type u_5} →
[inst_4 : AddCommGroup F] →
[inst_5 ... | Given two partial linear maps that agree on the intersection of their domains,
`f.sup g h` is the unique partial linear map on `f.domain ⊔ g.domain` that agrees
with `f` and `g`. | true |
_private.Init.Data.SInt.Lemmas.0.Int16.ne_of_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int16}, (x = y) = (x.toInt = y.toInt) | null | false |
AddSubgroup.addSubgroupOfContinuousAddEquivOfLe._proof_6 | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] {H K : AddSubgroup G} (hHK : H ≤ K) (s : Set ↥H),
IsOpen (⇑(AddSubgroup.addSubgroupOfEquivOfLe hHK) ⁻¹' s) ↔ IsOpen s | null | false |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup.0.SubMulAction.IsPretransitive.isPretransitive_ofFixingSubgroup_inter.match_1_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ {M : Type u_2} {α : Type u_1} [inst : Group M] [inst_1 : MulAction M α] {s : Set α} {g : M}
(motive : ↑(s ∩ g • s) → Prop) (x : ↑(s ∩ g • s)), (∀ (y : α) (hy : y ∈ s ∩ g • s), motive ⟨y, hy⟩) → motive x | null | false |
_private.Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing.0.IsDedekindDomain.FiniteAdeleRing.isUnit_iff._simp_1_4 | Mathlib.RingTheory.DedekindDomain.FiniteAdeleRing | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | null | false |
CategoryTheory.ObjectProperty.IsConservativeFamilyOfPoints.mk._flat_ctor | Mathlib.CategoryTheory.Sites.Point.Conservative | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
{P : CategoryTheory.ObjectProperty J.Point},
(CategoryTheory.JointlyReflectIsomorphisms fun Φ => Φ.obj.sheafFiber) → P.IsConservativeFamilyOfPoints | null | false |
_private.Mathlib.Order.ScottContinuity.0.ScottContinuous.const._simp_1_1 | Mathlib.Order.ScottContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
ScottContinuous f = ScottContinuousOn Set.univ f | null | false |
CategoryTheory.AddGrpObj.eq_lift_neg_left | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : C} [inst_2 : CategoryTheory.AddGrpObj B] (f g h : A ⟶ B),
f =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.lift
(CategoryTheory.CategoryStr... | null | true |
Filter.Realizer.map._proof_5 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_3} {β : Type u_1} (m : α → β) {f : Filter α} (F : f.Realizer) (x : Set β),
x ∈ { f := fun s => m '' F.F.f s, pt := F.F.pt, inf := F.F.inf, inf_le_left := ⋯, inf_le_right := ⋯ }.toFilter.sets ↔
x ∈ (Filter.map m f).sets | null | false |
Seminorm.sSup_empty | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E], sSup ∅ = ⊥ | null | true |
Matroid.not_indep_iff | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, autoParam (X ⊆ M.E) Matroid.not_indep_iff._auto_1 → (¬M.Indep X ↔ M.Dep X) | null | true |
AlgebraicGeometry.Spec.map | Mathlib.AlgebraicGeometry.Scheme | {R S : CommRingCat} → (R ⟶ S) → (AlgebraicGeometry.Spec S ⟶ AlgebraicGeometry.Spec R) | The induced map of a ring homomorphism on the ring spectra, as a morphism of schemes. | true |
Complex.IsExpCmpFilter.isLittleO_zpow_mul_exp | Mathlib.Analysis.SpecialFunctions.CompareExp | ∀ {l : Filter ℂ} {b₁ b₂ : ℝ},
Complex.IsExpCmpFilter l →
b₁ < b₂ → ∀ (m n : ℤ), (fun z => z ^ m * Complex.exp (↑b₁ * z)) =o[l] fun z => z ^ n * Complex.exp (↑b₂ * z) | If `l : Filter ℂ` is an "exponential comparison filter", then for any complex `a₁`, `a₂` and any
integer `b₁ < b₂`, we have
`(fun z ↦ z ^ a₁ * exp (b₁ * z)) =o[l] (fun z ↦ z ^ a₂ * exp (b₂ * z))`. | true |
SSet.PtSimplex.RelStruct₀.equiv₀._proof_7 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {x : X.obj (Opposite.op { len := 0 })} {f g : X.PtSimplex 0 x}
(e : SSet.Edge ((SSet.PtSimplex.equiv₀ x) g) ((SSet.PtSimplex.equiv₀ x) f)),
∀ j < Fin.castSucc 0,
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ j) (SSet.yonedaEquiv.symm e.edge) = SSet.const x | null | false |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.skipPrefixWhile_eq_startPos_iff._simp_1_3 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {s : String}, s.startPos.toSlice = s.toSlice.startPos | null | false |
Lean.Grind.CommRing.instBEqExpr | Init.Grind.Ring.CommSolver | BEq Lean.Grind.CommRing.Expr | null | true |
CategoryTheory.monoidalOpOp._proof_4 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(X' : C) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.opOp C).obj X')
((CategoryTheory.opOp C).map f))
(Cat... | null | false |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_10 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x y : ↥(Unitization.unitsFstOne R A)),
PreQuasiregular.equiv.symm
↑{ val := PreQuasiregular.equiv (↑↑(x * y)).toProd.2, inv := PreQuasireg... | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Simproc.0._regBuiltin.Lean.Meta.Grind.Arith.expandDiv.declare_19._@.Lean.Meta.Tactic.Grind.Arith.Simproc.2348362565._hygCtx._hyg.14 | Lean.Meta.Tactic.Grind.Arith.Simproc | IO Unit | null | false |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum | Lean.Compiler.NameMangling | (s : String) → s.Pos → Lean.Name → ℕ → Lean.Name | null | true |
sup_eq_right._simp_2 | Mathlib.Order.Defs.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a ⊔ b = b) = (a ≤ b) | null | false |
nsmul_pos | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [AddLeftMono M] {a : M},
0 < a → ∀ {k : ℕ}, k ≠ 0 → 0 < k • a | null | true |
IndexedPartition.piecewise_preimage | Mathlib.Order.Setoid.Partition | ∀ {ι : Type u_1} {α : Type u_2} {s : ι → Set α} (hs : IndexedPartition s) {β : Type u_3} (f : ι → α → β) (t : Set β),
hs.piecewise f ⁻¹' t = ⋃ i, s i ∩ f i ⁻¹' t | null | true |
Nat.unpaired | Mathlib.Computability.Primrec.Basic | {α : Sort u_1} → (ℕ → ℕ → α) → ℕ → α | Calls the given function on a pair of entries `n`, encoded via the pairing function. | true |
NonUnitalNonAssocCommSemiring.noConfusion | Mathlib.Algebra.Ring.Defs | {P : Sort u_1} →
{α : Type u} →
{t : NonUnitalNonAssocCommSemiring α} →
{α' : Type u} →
{t' : NonUnitalNonAssocCommSemiring α'} → α = α' → t ≍ t' → NonUnitalNonAssocCommSemiring.noConfusionType P t t' | null | false |
WeierstrassCurve.a₂ | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → WeierstrassCurve R → R | The `a₂` coefficient of a Weierstrass curve. | true |
finInsepDegree_eq_pow | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (q : ℕ) [ExpChar F q]
[FiniteDimensional F E], ∃ n, Field.finInsepDegree F E = q ^ n | null | true |
Lean.Meta.LazyDiscrTree.getMatchLoop | Lean.Meta.LazyDiscrTree | {α : Type} →
Array Lean.Meta.LazyDiscrTree.PartialMatch →
Lean.Meta.LazyDiscrTree.MatchResult α → Lean.Meta.LazyDiscrTree.MatchM α (Lean.Meta.LazyDiscrTree.MatchResult α) | Evaluate all partial matches and add resulting matches to `MatchResult`.
The partial matches are stored in an array that is used as a stack. When adding
multiple partial matches to explore next, to ensure the order of results matches
user expectations, this code must add paths we want to prioritize and return
results ... | true |
Fin2.insertPerm.eq_def | Mathlib.Data.Vector3 | ∀ (x : ℕ) (x_1 x_2 : Fin2 x),
x_1.insertPerm x_2 =
match x, x_1, x_2 with
| .(n + 1), Fin2.fz, Fin2.fz => Fin2.fz
| .(n + 1), Fin2.fz, j.fs => j.fs
| .(a.succ + 1), a_1.fs, Fin2.fz => Fin2.fz.fs
| .(a.succ + 1), i.fs, j.fs =>
match i.insertPerm j with
| Fin2.fz => Fin2.fz
| k.fs ... | null | true |
String.Slice.Pos.skipWhile._unsafe_rec | Init.Data.String.Slice | {ρ : Type} → {s : String.Slice} → s.Pos → (pat : ρ) → [String.Slice.Pattern.ForwardPattern pat] → s.Pos | null | false |
Nonneg.linearOrderedCommGroupWithZero._proof_6 | Mathlib.Algebra.Order.Nonneg.Field | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α], 0⁻¹ = 0 | null | false |
_private.Mathlib.CategoryTheory.Limits.Types.Colimits.0.CategoryTheory.Limits.Types.isColimit_iff_coconeTypesIsColimit._simp_1_1 | Mathlib.CategoryTheory.Limits.Types.Colimits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] {F : CategoryTheory.Functor J (Type u)} (c : F.CoconeTypes),
c.IsColimit = Nonempty (CategoryTheory.Limits.IsColimit (F.coconeTypesEquiv c)) | null | false |
EReal.toENNReal_ne_zero_iff | Mathlib.Data.EReal.Basic | ∀ {x : EReal}, x.toENNReal ≠ 0 ↔ 0 < x | null | true |
DirectLimit.instSemigroupOfMulHomClass.eq_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → Semigroup (G ... | null | true |
CategoryTheory.Limits.colimitYonedaHomIsoLimit'.eq_1 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [inst_1 : CategoryTheory.Category.{v₂, v₁} I]
(D : CategoryTheory.Functor I Cᵒᵖ) (F : CategoryTheory.Functor Cᵒᵖ (Type u₂))
[inst_2 : CategoryTheory.Limits.HasColimit (D.leftOp.comp CategoryTheory.yoneda)]
[inst_3 : CategoryTheory.Limits.Ha... | null | true |
CategoryTheory.yonedaMonObjIsoOfRepresentableBy.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) (F : CategoryTheory.Functor Cᵒᵖ MonCat) (α : (F.comp (CategoryTheory.forget MonCat)).RepresentableBy X),
CategoryTheory.yonedaMonObjIsoOfRepresentableBy X F α =
CategoryTheory.NatIso.ofComp... | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.750911636._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
Lean.LocalContext.auxDeclToFullName | Lean.LocalContext | Lean.LocalContext → Lean.FVarIdMap Lean.Name | null | true |
AddSubgroup.normalClosure_closure_eq_normalClosure | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {s : Set G},
AddSubgroup.normalClosure ↑(AddSubgroup.closure s) = AddSubgroup.normalClosure s | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.