name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
NumberField.instCommRingRingOfIntegers._proof_31 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K], autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
ISize.div_self | Init.Data.SInt.Lemmas | ∀ {a : ISize}, a / a = if a = 0 then 0 else 1 | null | true |
Affine.Simplex.altitudeFoot_mem_affineSpan_image_compl | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.altitudeFoot i ∈ affineSpan ℝ (s.points '' {i}ᶜ) | null | true |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars._unsafe_rec | Lean.Meta.Tactic.Cleanup | Lean.Expr → StateRefT' IO.RealWorld (Bool × Lean.FVarIdSet) Lean.MetaM Unit | null | false |
One.toOfNat1.hcongr_2 | Mathlib.GroupTheory.CoprodI | ∀ (α α' : Type u_1), α = α' → ∀ (inst : One α) (inst' : One α'), inst ≍ inst' → One.toOfNat1 ≍ One.toOfNat1 | null | true |
CategoryTheory.RetractArrow.left_i | Mathlib.CategoryTheory.Retract | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z W : C} {f : X ⟶ Y} {g : Z ⟶ W}
(h : CategoryTheory.RetractArrow f g), h.left.i = h.i.left | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.CooperSplit.assert.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | (motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u_1) →
(c₃? : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
((c₃ : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive (some c₃)) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive x) → motive c₃? | null | false |
CategoryTheory.GradedObject.CofanMapObjFun.inj_iso_hom | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
{X : CategoryTheory.GradedObject I C} {p : I → J} {j : J} [inst_1 : X.HasMap p] {c : X.CofanMapObjFun p j}
(hc : CategoryTheory.Limits.IsColimit c) (i : I) (hi : p i = j),
CategoryTheory.CategoryStruct.comp (CategoryTheor... | null | true |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : ↑I.multicospan.sections),
(fun s =>
⟨fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right... | null | false |
IsInvApply.rec | Mathlib.Data.FunLike.IsApply | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Inv β] →
[inst_2 : Inv F] →
{motive : IsInvApply F α β → Sort u} →
((inv_apply : ∀ (f : F) (x : α), f⁻¹ x = (f x)⁻¹) → motive ⋯) → (t : IsInvApply F α β) → motive t | null | false |
Std.Sat.CNF.Clause.Mem | Std.Sat.CNF.Basic | {α : Type u_1} → α → Std.Sat.CNF.Clause α → Prop | Variable `v` occurs in `Clause` `c`.
| true |
Std.ExtTreeSet.self_le_max?_insert | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k kmi : α},
(t.insert k).max?.get ⋯ = kmi → (cmp k kmi).isLE = true | null | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.exists_eq_some_of_findSome?_eq_some._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {x : α} {f : Fin n → Option α}, Fin.findSome? f = some x → ∃ i, f i = some x | null | false |
geom_sum₂_Ico | Mathlib.Algebra.Field.GeomSum | ∀ {K : Type u_2} [inst : Field K] {x y : K},
x ≠ y → ∀ {m n : ℕ}, m ≤ n → ∑ i ∈ Finset.Ico m n, x ^ i * y ^ (n - 1 - i) = (x ^ n - y ^ (n - m) * x ^ m) / (x - y) | null | true |
Lean.Parser.Term.binderTactic.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer | null | true |
DirectSum.Decomposition.casesOn | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid M] →
[inst_2 : SetLike σ M] →
[inst_3 : AddSubmonoidClass σ M] →
{ℳ : ι → σ} →
{motive : DirectSum.Decomposition ℳ → Sort u} →
(t ... | null | false |
CategoryTheory.Triangulated.TStructure.ge | Mathlib.CategoryTheory.Triangulated.TStructure.Basic | {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 : Ca... | the predicate of objects that are `≥ n` for `n : ℤ`. | true |
_private.Init.Data.String.Basic.0.String.Slice.Pos.ofSliceFrom_le_ofSliceFrom_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
_private.Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace.0.RestrictedProduct.continuous_dom_pi._simp_1_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | null | false |
Lean.Expr.ensureHasNoMVars | Mathlib.Lean.Expr.Basic | Lean.Expr → Lean.MetaM Unit | Check that an expression contains no metavariables (after instantiation). | true |
_private.Lean.Linter.UnusedVariables.0.Lean.Linter.mkIgnoreFnImpl.match_3 | Lean.Linter.UnusedVariables | (motive : Lean.ImportM.Context → Sort u_1) →
(x : Lean.ImportM.Context) →
((env : Lean.Environment) → (opts : Lean.Options) → motive { env := env, opts := opts }) → motive x | null | false |
Int.inductionOn'.neg._f | Mathlib.Data.Int.Init | {motive : ℤ → Sort u_1} →
(b : ℤ) →
motive b → ((k : ℤ) → k ≤ b → motive k → motive (k - 1)) → (n : ℕ) → Nat.below n → motive (b + Int.negSucc n) | null | false |
Polynomial.resultant_taylor | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (r : R),
((Polynomial.taylor r) f).resultant ((Polynomial.taylor r) g) = f.resultant g | `Res(f(x + r), g(x + r)) = Res(f, g)`. | true |
TestFunction.toBoundedContinuousFunctionCLM._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], IsBoundedSMul ℝ F | null | false |
List.mkSlice_rii_eq_mkSlice_rci | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α}, Std.Rii.Sliceable.mkSlice xs *...* = Std.Rci.Sliceable.mkSlice xs 0...* | null | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdx?.eq_def | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} (x : Std.DTreeMap.Internal.Impl α fun x => β) (x_1 : ℕ),
Std.DTreeMap.Internal.Impl.Const.entryAtIdx? x x_1 =
match x, x_1 with
| Std.DTreeMap.Internal.Impl.leaf, x => none
| Std.DTreeMap.Internal.Impl.inner size k v l r, n =>
match compare n l.size with
| Ordering.... | null | true |
Int8.toNatClampNeg_eq_zero_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {n : Int8}, (n.toNatClampNeg = 0) = (n ≤ 0) | null | false |
Mathlib.Tactic.BicategoryLike.StructuralAtom.id.elim | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
t.ctorIdx = 3 →
((e : Lean.Expr) →
(f : Mathlib.Tactic.BicategoryLike.Mor₁) → motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.id e f)) →
motive t | null | false |
USize.eq_of_toFin_eq | Init.Data.UInt.Lemmas | ∀ {a b : USize}, a.toFin = b.toFin → a = b | null | true |
UInt8._sizeOf_inst | Init.SizeOf | SizeOf UInt8 | null | false |
Std.TreeSet.getD_maxD | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp],
t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.maxD fallback) fallback' = t.maxD fallback | null | true |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiffOn_iff_target._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | false |
_private.Mathlib.Data.Sym.Basic.0.Sym.count_coe_fill_of_ne._simp_1_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {a b : α} {n : ℕ}, (b ∈ Multiset.replicate n a) = (n ≠ 0 ∧ b = a) | null | false |
_private.Mathlib.Data.Set.Finite.Basic.0.Finset.exists.match_1_3 | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u_1} {p : Finset α → Prop} (motive : (∃ s, ∃ (hs : s.Finite), p hs.toFinset) → Prop)
(x : ∃ s, ∃ (hs : s.Finite), p hs.toFinset),
(∀ (s : Set α) (hs : s.Finite) (hs' : p hs.toFinset), motive ⋯) → motive x | null | false |
Nat.chineseRemainderOfList.match_1 | Mathlib.Data.Nat.ChineseRemainder | {ι : Type u_1} →
(s : ι → ℕ) →
(motive : (x : List ι) → List.Pairwise (Function.onFun Nat.Coprime s) x → Sort u_2) →
(x : List ι) →
(x_1 : List.Pairwise (Function.onFun Nat.Coprime s) x) →
((x : List.Pairwise (Function.onFun Nat.Coprime s) []) → motive [] x) →
((i : ι) →
... | null | false |
AddConstEquiv.instPowInt._proof_1 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} [inst : Add G] {a : G} (e : AddConstEquiv G G a a) (n : ℤ) (x : G),
(↑e ^ n).toFun (x + a) = (↑e ^ n).toFun x + a | null | false |
IsCoxeterGroup | Mathlib.GroupTheory.Coxeter.Basic | (W : Type u) → [Group W] → Prop | A group is a Coxeter group if it admits a Coxeter system for some Coxeter matrix `M`. | true |
UnitAddTorus.mFourierLp._proof_7 | Mathlib.Analysis.Fourier.AddCircleMulti | ∀ {d : Type u_1}, CompactSpace (d → UnitAddCircle) | null | false |
IsAbsoluteValue.abv_nonneg | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {S : Type u_5} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_6} [inst_2 : Semiring R] (abv : R → S)
[IsAbsoluteValue abv] (x : R), 0 ≤ abv x | null | true |
Real.HolderTriple.holderConjugate_div_div | Mathlib.Data.Real.ConjExponents | ∀ {p q r : ℝ}, p.HolderTriple q r → (p / r).HolderConjugate (q / r) | null | true |
MonoidAlgebra.mapRingHom_comp_algebraMap | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_7} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Monoid M]
(f : R →+* S),
(MonoidAlgebra.mapRingHom M f).comp (algebraMap R (MonoidAlgebra R M)) = (algebraMap S (MonoidAlgebra S M)).comp f | null | true |
HasStrictFDerivAt.log | Mathlib.Analysis.SpecialFunctions.Log.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E},
HasStrictFDerivAt f f' x → f x ≠ 0 → HasStrictFDerivAt (fun x => Real.log (f x)) ((f x)⁻¹ • f') x | null | true |
LinearMap.vecEmpty | Mathlib.LinearAlgebra.Pi | {R : Type u} →
{M : Type v} →
{M₃ : Type y} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid M₃] → [inst_3 : Module R M] → [inst_4 : Module R M₃] → M →ₗ[R] Fin 0 → M₃ | The linear map defeq to `Matrix.vecEmpty` | true |
_private.Mathlib.NumberTheory.RamificationInertia.Basic.0.Ideal.FinrankQuotientMap.linearIndependent_of_nontrivial._simp_1_7 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [AddMonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
∑ x ∈ s, g (f x) = g (∑ x ∈ s, f x) | null | false |
_private.Mathlib.GroupTheory.Descent.0.Group.fg_of_descent._simp_1_6 | Mathlib.GroupTheory.Descent | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.MonoidalCategory.Arrow.PushoutProduct.associator._proof_13 | Mathlib.CategoryTheory.Monoidal.PushoutProduct | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPushouts C]
[inst_2 : CategoryTheory.MonoidalCategory C] (X₁ X₂ X₃ : CategoryTheory.Arrow C)
[inst_3 :
CategoryTheory.Limits.PreservesColimit
(CategoryTheory.Limits.span (CategoryTheory.MonoidalCategoryStruct... | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₂.quasiIsoAt_ι._proof_1_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ (n : ℤ), n ≤ n | null | false |
CoxeterMatrix.instGroupGroup._proof_20 | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} (M : CoxeterMatrix B),
autoParam
(∀ (n : ℕ) (a : M.Group),
CoxeterMatrix.instGroupGroup._aux_17 M (↑n.succ) a = CoxeterMatrix.instGroupGroup._aux_17 M (↑n) a * a)
DivInvMonoid.zpow_succ'._autoParam | null | false |
_private.Init.Data.Dyadic.Round.0.Dyadic.precision_roundDown.match_1_1 | Init.Data.Dyadic.Round | ∀ (motive : Dyadic → Prop) (x : Dyadic),
(∀ (a : Unit), motive Dyadic.zero) → (∀ (n k : ℤ) (hn : n % 2 = 1), motive (Dyadic.ofOdd n k hn)) → motive x | null | false |
Std.Http.URI.Path.mk.injEq | Std.Http.Data.URI.Basic | ∀ (segments : Array Std.Http.URI.EncodedSegment) (absolute : Bool) (segments_1 : Array Std.Http.URI.EncodedSegment)
(absolute_1 : Bool),
({ segments := segments, absolute := absolute } = { segments := segments_1, absolute := absolute_1 }) =
(segments = segments_1 ∧ absolute = absolute_1) | null | true |
EReal.coe_ennreal_le_coe_ennreal_iff._simp_1 | Mathlib.Data.EReal.Basic | ∀ {x y : ENNReal}, (↑x ≤ ↑y) = (x ≤ y) | null | false |
Finset.pimage_eq_image_filter | Mathlib.Data.Finset.PImage | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α →. β} [inst_1 : (x : α) → Decidable (f x).Dom]
{s : Finset α}, Finset.pimage f s = Finset.image (fun x => (f ↑x).get ⋯) {x ∈ s | (f x).Dom}.attach | Rewrite `s.pimage f` in terms of `Finset.filter`, `Finset.attach`, and `Finset.image`. | true |
CategoryTheory.nerveFunctor.full | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | CategoryTheory.nerveFunctor.Full | null | true |
_private.Init.Data.String.Lemmas.Search.0.String.front_eq._simp_1_1 | Init.Data.String.Lemmas.Search | ∀ {s : String}, s.front = s.toSlice.front | null | false |
AlgebraicGeometry.PrimeSpectrum.Top.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R], AlgebraicGeometry.PrimeSpectrum.Top R = TopCat.of (PrimeSpectrum R) | null | true |
CategoryTheory.Presieve.BindStruct.hg | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {S : CategoryTheory.Presieve X}
{R : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → S f → CategoryTheory.Presieve Y} {Z : C} {h : Z ⟶ X} (self : S.BindStruct R h),
R ⋯ self.g | null | true |
AlgebraicGeometry.Scheme.Hom.normalizationCoprodIso._proof_4 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U V : AlgebraicGeometry.Scheme} {iU : U ⟶ X} {iV : V ⟶ X}
(e : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.BinaryCofan.mk iU iV))
[inst_2 : AlgebraicGeometry.QuasiComp... | null | false |
Pi.comul_coe_finsupp | Mathlib.RingTheory.Coalgebra.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommSemiring R] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {M : Type u_4}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : CoalgebraStruct R M] (x : n →₀ M),
CoalgebraStruct.comul ⇑x = (TensorProduct.map Finsupp.lcoeFun Finsupp.lcoeFun) (CoalgebraStruct.comul x) | null | true |
ModuleCat.monModuleEquivalenceAlgebraForget._proof_5 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : CategoryTheory.Mon (ModuleCat R)) (x : R)
(x_1 : ↑(ModuleCat.MonModuleEquivalenceAlgebra.functor.obj A)), id (x • x_1) = id (x • x_1) | null | false |
ENNReal.mulRightOrderIso._proof_2 | Mathlib.Data.ENNReal.Inv | ∀ (a : ENNReal) (ha : IsUnit a) {a_1 b : ENNReal}, ha.unit.mulRight a_1 ≤ ha.unit.mulRight b ↔ a_1 ≤ b | null | false |
SimpleGraph.Hom.sum_apply | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_3} {V' : Type u_4} {W : Type u_5} {W' : Type u_6} {G : SimpleGraph V} {H : SimpleGraph W}
{G' : SimpleGraph V'} {H' : SimpleGraph W'} (f : G →g G') (g : H →g H') (a : V ⊕ W), (f.sum g) a = Sum.map (⇑f) (⇑g) a | null | true |
CategoryTheory.MonoidalCategory.DayConvolution.unit_uniqueUpToIso_hom_assoc | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {V : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} V]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalCategory V]
{F G : CategoryTheory.Functor C V} (h h' : CategoryTheory.MonoidalCategory.DayConvolution F G)
{Z : Cate... | null | true |
Asymptotics.isLittleOTVS_fun_neg_right | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
... | null | true |
aemeasurable_inv_iff._simp_2 | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_3} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {G : Type u_4} [inst : InvolutiveInv G]
[inst_1 : MeasurableSpace G] [MeasurableInv G] {f : α → G}, AEMeasurable (fun x => (f x)⁻¹) μ = AEMeasurable f μ | null | false |
CategoryTheory.Subobject.Classifier.instUniqueHomΩ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {c : CategoryTheory.Subobject.Classifier C} → (Y : C) → Unique (Y ⟶ c.Ω₀) | null | true |
CategoryTheory.Limits.prod.mapIso_hom | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct W X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Z]
(f : W ≅ Y) (g : X ≅ Z), (CategoryTheory.Limits.prod.mapIso f g).hom = CategoryTheory.Limits.prod.map f.hom g.hom | null | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Combination.0.Set.powersetCard.stabilizer_coe._simp_1_3 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_lt_of_msb_false._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ {p : Prop} [h : Decidable p], (false = decide p) = ¬p | null | false |
Lean.Server.Snapshots.Snapshot.recOn | Lean.Server.Snapshots | {motive : Lean.Server.Snapshots.Snapshot → Sort u} →
(t : Lean.Server.Snapshots.Snapshot) →
((stx : Lean.Syntax) →
(mpState : Lean.Parser.ModuleParserState) →
(cmdState : Lean.Elab.Command.State) → motive { stx := stx, mpState := mpState, cmdState := cmdState }) →
motive t | null | false |
MDifferentiableWithinAt.neg | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
AddLocalization.liftOn₂_mk | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u_4} (f : M → ↥S → M → ↥S → p)
(H :
∀ {a a' : M} {b b' : ↥S} {c c' : M} {d d' : ↥S},
(AddLocalization.r S) (a, b) (a', b') → (AddLocalization.r S) (c, d) (c', d') → f a b c d = f a' b' c' d')
(a c : M) (b d : ↥S), (AddLocalization.mk... | null | true |
CategoryTheory.Functor.Monoidal.whiskerLeft_app_snd | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(F₁ : CategoryTheory.Functor J C) {F₂ F₂' : CategoryTheory.Functor J C} (g : F₂ ⟶ F₂') (j : J),
CategoryTheory.CategoryStruct.comp ((C... | null | true |
IO.Process.Output.stderr | Init.System.IO | IO.Process.Output → String | Everything that was written to the process's standard error. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.exists_concat_eq_cons.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u w : V} (motive : (v : V) → G.Walk u v → G.Adj v w → Prop) (v : V)
(x : G.Walk u v) (x_1 : G.Adj v w),
(∀ (h : G.Adj u w), motive u SimpleGraph.Walk.nil h) →
(∀ (v v_1 : V) (h' : G.Adj u v_1) (p : G.Walk v_1 v) (h : G.Adj v w), motive v (SimpleGraph.Walk.cons h' p) h) →
... | null | false |
Polynomial.map_evalRingHom_eval | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.eval y (Polynomial.map (Polynomial.evalRingHom x) p) = Polynomial.evalEval x y p | null | true |
MulArchimedeanClass.mk_right_le_mk_mul_iff._simp_2 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a b : M},
(MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk (a * b)) = (MulArchimedeanClass.mk b ≤ MulArchimedeanClass.mk a) | null | false |
Equiv.subRight.eq_1 | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_5} [inst : AddGroup G] (a : G),
Equiv.subRight a = { toFun := fun b => b - a, invFun := fun b => b + a, left_inv := ⋯, right_inv := ⋯ } | null | true |
Units.isOpenMap_val | Mathlib.Analysis.Normed.Ring.Units | ∀ {R : Type u_1} [inst : NormedRing R] [HasSummableGeomSeries R], IsOpenMap Units.val | In a normed ring with summable geometric series, the coercion from `Rˣ` (equipped with the
induced topology from the embedding in `R × R`) to `R` is an open map. | true |
IsSemisimpleModule.recOn | Mathlib.RingTheory.SimpleModule.Basic | {R : Type u_2} →
[inst : Ring R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsSemisimpleModule R M → Sort u} →
(t : IsSemisimpleModule R M) →
([toComplementedLattice : ComplementedLattice (Submodule R M)] → motive ⋯) → motive ... | null | false |
_private.Lean.Elab.ConfigEval.DeriveEvalConfigItem.0.Lean.Elab.ConfigEval.HandlerTrie.below_2 | Lean.Elab.ConfigEval.DeriveEvalConfigItem | {motive_1 : Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
{motive_2 : Array (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_3 : List (String × Lean.Elab.ConfigEval.HandlerTrie✝) → Sort u} →
{motive_4 : String × Lean.Elab.ConfigEval.HandlerTrie✝ → Sort u} →
List (String × Lean.Elab.C... | null | false |
Pi.instSub | Mathlib.Algebra.Notation.Pi.Defs | {ι : Type u_1} → {G : ι → Type u_4} → [(i : ι) → Sub (G i)] → Sub ((i : ι) → G i) | null | true |
Lean.Elab.Attribute.kind | Lean.Elab.Attributes | Lean.Elab.Attribute → Lean.AttributeKind | null | true |
RingPreordering.support.congr_simp | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {R : Type u_1} [inst : CommRing R] (P P_1 : RingPreordering R) (e_P : P = P_1) [inst_1 : P.HasIdealSupport],
P.support = P_1.support | null | true |
_private.Mathlib.CategoryTheory.GlueData.0.CategoryTheory.GlueData.π_epi._proof_1 | Mathlib.CategoryTheory.GlueData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (D : CategoryTheory.GlueData C)
[inst_1 : CategoryTheory.Limits.HasMulticoequalizer D.diagram] [inst_2 : CategoryTheory.Limits.HasColimits C],
CategoryTheory.Epi D.π | null | false |
Set.Definable.compl | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {α : Type u₁} {s : Set (α → M)},
A.Definable L s → A.Definable L sᶜ | null | true |
MeasurableEmbedding.measurable | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → Measurable f | A measurable embedding is a measurable function. | true |
CategoryTheory.HasProjectiveResolution | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroObject C] → [CategoryTheory.Limits.HasZeroMorphisms C] → C → Prop | An object admits a projective resolution.
| true |
TrivialLieModule.instLieRingModule._proof_1 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x y : L) (m : TrivialLieModule R L M), 0 = 0 + 0 | null | false |
PresheafOfModules.instIsLocalizationSheafOfModulesSheafificationInverseImageFunctorOppositeAbWToPresheaf | Mathlib.Algebra.Category.ModuleCat.Sheaf.Localization | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | null | true |
Std.DHashMap.get?_eq_some_getD | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α}
{fallback : β a}, a ∈ m → m.get? a = some (m.getD a fallback) | null | true |
Finset.sup_eq_sSup_image | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : CompleteLattice β] (s : Finset α) (f : α → β), s.sup f = sSup (f '' ↑s) | null | true |
CategoryTheory.IsSplitEpi.mk | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
Nonempty (CategoryTheory.SplitEpi f) → CategoryTheory.IsSplitEpi f | null | true |
instContMDiffVectorBundleOfNatWithTopENat_1 | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {𝕜 : Type u_1} {B : Type u_2} (F : Type u_4) (E : B → Type u_6) [inst : NontriviallyNormedField 𝕜] {EB : Type u_7}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB... | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.toSeq | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | {basis_hd : ℝ → ℝ} →
{basis_tl : Tactic.ComputeAsymptotics.Basis} →
Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl →
Stream'.Seq (ℝ × Tactic.ComputeAsymptotics.MultiseriesExpansion basis_tl) | Converts a `Multiseries basis_hd basis_tl` to a `Seq (ℝ × MultiseriesExpansion basis_tl)`. | true |
Finset.bipartiteAbove_swap | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteAbove (Function.swap r) s b = Finset.bipartiteBelow r s b | null | true |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier | Mathlib.Algebra.Category.MonCat.Basic | CategoryTheory.ConcreteCategory AddCommMonCat fun x1 x2 => ↑x1 →+ ↑x2 | null | true |
PSet.Equiv._unsafe_rec | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop | null | false |
Ordinal.typein_lt_nat | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (x : ℕ), (Ordinal.typein LT.lt).toRelEmbedding x = ↑x | null | true |
AddCommute.add_left._simp_1 | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : AddSemigroup S] {a b c : S}, AddCommute a c → AddCommute b c → AddCommute (a + b) c = True | null | false |
_private.Mathlib.NumberTheory.Height.NumberField.0.Mathlib.Meta.Positivity.evalHeightTotalWeight._proof_1 | Mathlib.NumberTheory.Height.NumberField | ∀ (α : Q(Type)) (x : Q(Zero «$α»)) (__defeqres : PLift («$x» =Q Nat.instMulZeroClass.toZero)),
«$x» =Q Nat.instMulZeroClass.toZero | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.