name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Algebra.Presentation.differentialsRelations_G | Mathlib.Algebra.Module.Presentation.Differentials | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(pres : Algebra.Presentation R S ι σ), pres.differentialsRelations.G = ι | null | true |
FirstOrder.Language.presburger.natCast_zero | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | ∀ {α : Type u_1}, ↑0 = 0 | null | true |
_private.Aesop.Util.EqualUpToIds.0.Aesop.EqualUpToIds.Unsafe.exprsEqualUpToIdsCore₃.match_5 | Aesop.Util.EqualUpToIds | (motive : Lean.Expr → Lean.Expr → Sort u_1) →
(x x_1 : Lean.Expr) →
((i j : ℕ) → motive (Lean.Expr.bvar i) (Lean.Expr.bvar j)) →
((fvarId₁ fvarId₂ : Lean.FVarId) → motive (Lean.Expr.fvar fvarId₁) (Lean.Expr.fvar fvarId₂)) →
((u v : Lean.Level) → motive (Lean.Expr.sort u) (Lean.Expr.sort v)) →
... | null | false |
Equiv.commRing._proof_4 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommRing β] (x y : α), e (e.symm (e x * e y)) = e x * e y | null | false |
AddSubgroup.prod.eq_1 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (H : AddSubgroup G) (K : AddSubgroup N),
H.prod K = { toAddSubmonoid := H.prod K.toAddSubmonoid, neg_mem' := ⋯ } | null | true |
IsDiscreteValuationRing.quotient | Mathlib.RingTheory.DiscreteValuationRing.Basic | {R : Type u_2} → [CommRing R] → R → R → R | A noncomputable quotient to define the Euclidean domain structure. The GCD algorithm only takes
two steps to terminate. Given `GCD(x,y)`, if `x ∣ y` then `y%x = 0` so we're done in one step;
otherwise `y%x = y` and then `GCD(x,y) = GCD(y,x)` which brings us back to the first case. | true |
AbsoluteValue.not_isNontrivial_apply | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_5} [inst : Semiring R] {S : Type u_6} [inst_1 : Semiring S] [inst_2 : PartialOrder S]
{v : AbsoluteValue R S}, ¬v.IsNontrivial → ∀ {x : R}, x ≠ 0 → v x = 1 | null | true |
Std.TreeMap.isEmpty_emptyc | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering}, ∅.isEmpty = true | null | true |
Std.DTreeMap.Internal.Impl.balanceL.match_7 | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(l : Std.DTreeMap.Internal.Impl α β) →
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced → Std.DTreeMap.Internal.Impl.BalanceLPrecond l.size r.size → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(hrb : r.Balanced) ... | null | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions.0.hasMFDerivAt_inr._simp_1_1 | 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 | false |
instToJsonShowMessageParams | Lean.Data.Lsp.Window | Lean.ToJson ShowMessageParams | null | true |
OneHom | Mathlib.Algebra.Group.Hom.Defs | (M : Type u_10) → (N : Type u_11) → [One M] → [One N] → Type (max u_10 u_11) | `OneHom M N` is the type of functions `M → N` that preserve one.
When possible, instead of parametrizing results over `(f : OneHom M N)`,
you should parametrize over `(F : Type*) [OneHomClass F M N] (f : F)`.
When you extend this structure, make sure to also extend `OneHomClass`.
| true |
Int.neg_modEq_neg._simp_1 | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ}, (-a ≡ -b [ZMOD n]) = (a ≡ b [ZMOD n]) | null | false |
ApproximatesLinearOn.open_image | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
[CompleteSpace E] {s : Set E} {c : NNReal} {f' : E →L[𝕜] F},
ApproximatesLinearOn f f' s c →
... | null | true |
SimpleGraph.Walk.isSubwalk_nil_iff_mem_support._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v' : V} (p : G.Walk u v), SimpleGraph.Walk.nil.IsSubwalk p = (v' ∈ p.support) | null | false |
TopRep.Hom.toTopModuleCatHom._proof_1 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u_2} {G : Type u_3} [inst : TopologicalSpace k] [inst_1 : Ring k] [inst_2 : IsTopologicalRing k]
[inst_3 : Monoid G] {A : TopRep k G}, ContinuousAdd ↑A | null | false |
CliffordAlgebra.changeFormEquiv._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q Q' : QuadraticForm R M} {B : LinearMap.BilinForm R M} (h : LinearMap.BilinMap.toQuadraticMap B = Q' - Q)
(x : CliffordAlgebra Q), (CliffordAlgebra.changeForm ⋯) ((CliffordAlgebra.changeForm h) x) = x | null | false |
CategoryTheory.InducedCategory.hasCoeToSort | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} → (F : C → D) → {α : Sort u_1} → [CoeSort D α] → CoeSort (CategoryTheory.InducedCategory D F) α | null | true |
Std.DTreeMap.Raw.WF.casesOn | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
{t : Std.DTreeMap.Raw α β cmp} →
{motive : t.WF → Sort u_1} → (t_1 : t.WF) → ((out : t.inner.WF) → motive ⋯) → motive t_1 | null | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_iff_exists._simp_1_3 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (a b : G), f a - f b = f (a - b) | null | false |
MeasureTheory.mem_map_restrict_ae_iff | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7} {s : Set α} {t : Set β}
{f : α → β}, MeasurableSet s → (t ∈ Filter.map f (MeasureTheory.ae (μ.restrict s)) ↔ μ ((f ⁻¹' t)ᶜ ∩ s) = 0) | null | true |
Lean.Widget.withGoalCtx | Lean.Widget.InteractiveGoal | {n : Type → Type} →
[MonadControlT Lean.MetaM n] →
[Monad n] →
[Lean.MonadError n] →
[Lean.MonadOptions n] →
[Lean.MonadMCtx n] → {α : Type} → Lean.MVarId → (Lean.LocalContext → Lean.MetavarDecl → n α) → n α | null | true |
CategoryTheory.Sieve.overEquiv._proof_2 | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {X : C} (Y : CategoryTheory.Over X)
(S : CategoryTheory.Sieve Y.left),
(fun S => CategoryTheory.Sieve.functorPushforward (CategoryTheory.Over.forget X) S)
((fun S' => CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.forget X) S') S) =
... | null | false |
UniformConvergenceCLM.uniformity_toTopologicalSpace_eq | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : UniformSpace F] [inst_8 : IsUniformAddGr... | null | true |
Part.getOrElse_of_not_dom | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α), ¬a.Dom → ∀ [inst : Decidable a.Dom] (d : α), a.getOrElse d = d | null | true |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanIndex_left | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {A : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} A] {X : C}
(data : F.PreOneHypercoverDenseData X) (P : CategoryTheory.Functor C₀ᵒᵖ A) (i : data.multicospa... | null | true |
SimpleGraph.Walk.getVert_mem_support._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (i : ℕ), (p.getVert i ∈ p.support) = True | null | false |
Submodule.Quotient.seminormedAddCommGroup._proof_14 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] {R : Type u_2} [inst_1 : Ring R] [inst_2 : Module R M]
(S : Submodule R M),
((Submodule.Quotient.seminormedAddCommGroup._aux_11 S).lift' fun s => SetRel.comp s s) ≤
Submodule.Quotient.seminormedAddCommGroup._aux_11 S | null | false |
Mathlib.TacticAnalysis.TacticNode.ctxI | Mathlib.Tactic.TacticAnalysis | Mathlib.TacticAnalysis.TacticNode → Lean.Elab.ContextInfo | `ContextInfo` at the infotree node. | true |
Set.Ico_subset_Icc_union_Ico | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a c ⊆ Set.Icc a b ∪ Set.Ico b c | null | true |
Pi.semiring._proof_3 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → Semiring (f i)] (a : (i : I) → f i), a * 1 = a | null | false |
_private.Init.Data.String.Decode.0.String.utf8EncodeChar_eq_utf8EncodeCharFast._proof_1_12 | Init.Data.String.Decode | ∀ (c : Char), ¬c.val.toNat ≤ 2047 → c.val.toNat ≤ 65535 → ¬c.val.toNat / 2 ^ 12 < 256 → False | null | false |
MonadExcept.orElse | Init.Prelude | {ε : Type u} → {m : Type v → Type w} → [MonadExcept ε m] → {α : Type v} → m α → (Unit → m α) → m α | Unconditional error recovery that ignores which exception was thrown. Usually used via the `<|>`
operator.
If both computations throw exceptions, then the result is the second exception.
| true |
Equiv.group.eq_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_3} (e : α ≃ β) [inst : Group β], e.group = Function.Injective.group ⇑e ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | null | true |
Submonoid.orderOf_le_card | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_6} [inst : Group G] (s : Submonoid G), (↑s).Finite → ∀ {x : G}, x ∈ s → orderOf x ≤ Nat.card ↥s | null | true |
CochainComplex.mapBifunctorShift₂Iso_hom_naturality₂_assoc | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Pr... | null | true |
_private.Mathlib.Data.Fintype.Quotient.0.Quotient.list_ind.match_1_1 | Mathlib.Data.Fintype.Quotient | ∀ {ι : Type u_1} (motive : (a : ι) → a ∈ [] → Prop) (a : ι) (a_1 : a ∈ []), motive a a_1 | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.opcyclesToE_map._proof_12 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ (n₁ n₂ : ℤ), autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.opcyclesToE_map._auto_7 → n₁ + 1 = n₂ | null | false |
IsCoveringMap.exists_path_lifts | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X},
IsCoveringMap p → ∀ (γ : C(↑unitInterval, X)) (e : E), γ 0 = p e → ∃ Γ, p ∘ ⇑Γ = ⇑γ ∧ Γ 0 = e | The path lifting property (existence) for covering maps. | true |
String.isNat_iff | Std.Data.String.ToNat | ∀ {s : String},
s.isNat = true ↔
s ≠ "" ∧
(∀ c ∈ s.toList, c.isDigit = true ∨ c = '_') ∧
¬['_', '_'] <:+: s.toList ∧ s.toList.head? ≠ some '_' ∧ s.toList.getLast? ≠ some '_' | null | true |
AddSubmonoid.closure_singleton_eq | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {A : Type u_2} [inst : AddMonoid A] (x : A), AddSubmonoid.closure {x} = AddMonoidHom.mrange ((multiplesHom A) x) | null | true |
MvPolynomial.algebraTensorAlgEquiv_symm_monomial | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ (R : Type u) [inst : CommSemiring R] {σ : Type u_1} (A : Type u_4) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
(m : σ →₀ ℕ) (a : A),
(MvPolynomial.algebraTensorAlgEquiv R A).symm ((MvPolynomial.monomial m) a) = a ⊗ₜ[R] (MvPolynomial.monomial m) 1 | null | true |
Nat.doubleFactorial.eq_2 | Mathlib.Data.Nat.Factorial.DoubleFactorial | Nat.doubleFactorial 1 = 1 | null | true |
AnalyticOnNhd.sum_divisor_le | Mathlib.Analysis.Complex.JensenFormula | ∀ {c : ℂ} {r R M : ℝ} {f : ℂ → ℂ},
0 < |r| →
|r| < |R| →
1 ≤ M →
AnalyticOnNhd ℂ f (Metric.closedBall c |R|) →
f c ≠ 0 →
(∀ z ∈ Metric.sphere c |R|, ‖f z‖ ≤ M) →
↑(∑ᶠ (u : ℂ), (MeromorphicOn.divisor f (Metric.closedBall c |r|)) u) ≤
Real.log (M / ‖... | **Jensen's Inequality**: Estimates the number of zeros of `f` in a ball of radius `r`
given that `f` is analytic and bounded by `M` on a larger ball of radius `R`.
| true |
PresentedGroup.mk_eq_mk_of_inv_mul_mem | Mathlib.GroupTheory.PresentedGroup | ∀ {α : Type u_1} {rels : Set (FreeGroup α)} {x y : FreeGroup α},
x⁻¹ * y ∈ rels → (PresentedGroup.mk rels) x = (PresentedGroup.mk rels) y | null | true |
Std.Ric.LawfulRcoIntersection.mk | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type w} [inst : LT α] [inst_1 : LE α] [inst_2 : Std.Ric.HasRcoIntersection α],
(∀ {a : α} {r : Std.Ric α} {s : Std.Rco α}, a ∈ Std.Ric.HasRcoIntersection.intersection r s ↔ a ∈ r ∧ a ∈ s) →
Std.Ric.LawfulRcoIntersection α | null | true |
alexDiscEquivPreord_functor | Mathlib.Topology.Order.Category.AlexDisc | alexDiscEquivPreord.functor = (CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord | null | true |
_private.Mathlib.Algebra.Order.Archimedean.Defs.0.exists_int_le.match_1_1 | Mathlib.Algebra.Order.Archimedean.Defs | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : PartialOrder R] (x : R) (motive : (∃ n, -x ≤ ↑n) → Prop)
(x_1 : ∃ n, -x ≤ ↑n), (∀ (n : ℤ) (h : -x ≤ ↑n), motive ⋯) → motive x_1 | null | false |
Lean.Meta.Config.zetaUnused | Lean.Meta.Basic | Lean.Meta.Config → Bool | Zeta reduction for unused let-declarations: `let x := v; e` reduces to `e` when `x` does not occur
in `e`.
This option takes precedence over `zeta` and `zetaHave`.
| true |
CategoryTheory.MorphismProperty.RightFraction.rec | Mathlib.CategoryTheory.Localization.CalculusOfFractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.RightFraction X Y → Sort u} →
({X' : C} → (s : X' ⟶ X) → (hs : W s) → (f : X' ⟶ Y) → motive { X' := X', s := s, hs := hs, f := f }) →
(t : W.RightF... | null | false |
Set.fintypeUnion | Mathlib.Data.Set.Finite.Basic | {α : Type u} → [DecidableEq α] → (s t : Set α) → [Fintype ↑s] → [Fintype ↑t] → Fintype ↑(s ∪ t) | null | true |
CategoryTheory.ObjectProperty.ContainsUnit.mk | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{P : CategoryTheory.ObjectProperty C}, P (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) → P.ContainsUnit | null | true |
MeasureTheory.Measure.ext_prod₃_iff' | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_4} {β : Type u_5} {γ : Type u_6} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {μ ν : MeasureTheory.Measure ((α × β) × γ)} [MeasureTheory.IsFiniteMeasure μ],
μ = ν ↔
∀ {s : Set α} {t : Set β} {u : Set γ},
MeasurableSet s → MeasurableSet t → MeasurableSet u → μ ((... | Two finite measures on a product `(α × β) × γ` are equal iff they are equal on products of sets.
See `ext_prod₃_iff` for the same statement for `α × β × γ`. | true |
Multiset.lt_singleton | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, s < {a} ↔ s = 0 | null | true |
Std.Iter.any_filterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id m] [inst_3 : Monad m] [inst_4 : MonadAttach m] [LawfulMonad m]
[WeaklyLawfulMonadAttach m] [Std.LawfulIteratorLoop α Id m] {it : Std.Iter β} {f : β → m (ULift.{w, 0} Bool)}
{p : β → Boo... | null | true |
Std.Iterators.Types.Map | Init.Data.Iterators.Combinators.Monadic.FilterMap | Type w →
{β γ : Type w} →
(m : Type w → Type w') →
(n : Type w → Type w'') →
(⦃α : Type w⦄ → m α → n α) → [Functor n] → (β → Std.Iterators.PostconditionT n γ) → Type w | Internal state of the `map` combinator. Do not depend on its internals.
| true |
Qq.SortLocalDecls.Context | Qq.SortLocalDecls | Type | null | true |
Std.TreeSet.max!_erase_eq_of_not_compare_max!_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {k : α},
(t.erase k).isEmpty = false → ¬cmp k t.max! = Ordering.eq → (t.erase k).max! = t.max! | null | true |
List.length_sym._unary | Mathlib.Data.List.Sym | ∀ {α : Type u_1} (_x : (_ : ℕ) ×' List α), (List.sym _x.1 _x.2).length = _x.2.length.multichoose _x.1 | null | false |
Rep.coinvariantsAdjunction_homEquiv_apply_hom | Mathlib.RepresentationTheory.Coinvariants | ∀ (k : Type u) (G : Type v) [inst : CommRing k] [inst_1 : Monoid G] {X : Rep.{w, u, v} k G} {Y : ModuleCat k}
(f : (Rep.coinvariantsFunctor k G).obj X ⟶ Y),
(Rep.Hom.hom (((Rep.coinvariantsAdjunction k G).homEquiv X Y) f)).toLinearMap =
ModuleCat.Hom.hom (CategoryTheory.CategoryStruct.comp ((Rep.coinvariantsMk ... | null | true |
Lean.Elab.WF.GuessLex.RecCallWithContext.mk.injEq | Lean.Elab.PreDefinition.WF.GuessLex | ∀ (ref : Lean.Syntax) (caller : ℕ) (params : Array Lean.Expr) (callee : ℕ) (args : Array Lean.Expr)
(ctxt : Lean.Elab.WF.GuessLex.SavedLocalContext) (ref_1 : Lean.Syntax) (caller_1 : ℕ) (params_1 : Array Lean.Expr)
(callee_1 : ℕ) (args_1 : Array Lean.Expr) (ctxt_1 : Lean.Elab.WF.GuessLex.SavedLocalContext),
({ re... | null | true |
instAddZeroClassTensorProduct._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (a : TensorProduct R M N), 0 + a = a | null | false |
Fin.add.match_1 | Init.Data.Fin.Basic | {n : ℕ} →
(motive : Fin n → Fin n → Sort u_1) →
(x x_1 : Fin n) → ((a : ℕ) → (h : a < n) → (b : ℕ) → (isLt : b < n) → motive ⟨a, h⟩ ⟨b, isLt⟩) → motive x x_1 | null | false |
_private.Lean.Data.RArray.0.Lean.RArray.ofFn.go | Lean.Data.RArray | {α : Type u_1} → {n : ℕ} → (Fin n → α) → (lb ub : ℕ) → lb < ub → ub ≤ n → Lean.RArray α | null | true |
Int32.ofIntLE_int16ToInt._proof_2 | Init.Data.SInt.Lemmas | Int16.maxValue.toInt ≤ Int32.maxValue.toInt | null | false |
Polynomial.Chebyshev.coeff_le_of_forall_abs_le_one | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.Extremal | ∀ {n : ℕ} {P : Polynomial ℝ},
P.degree ≤ ↑n → (∀ x ∈ Set.Icc (-1) 1, |Polynomial.eval x P| ≤ 1) → P.coeff n ≤ 2 ^ (n - 1) | null | true |
isLowerSet_compl._simp_1 | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet sᶜ = IsUpperSet s | null | false |
CategoryTheory.MorphismProperty.Arrow.forget_comp_rightFunc_map | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P Q W : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] [inst_2 : W.IsMultiplicative] {A B : P.Arrow Q W} (f : A ⟶ B),
((CategoryTheory.MorphismProperty.Arrow.forget P Q W).comp CategoryTheory.Arrow.rightFunc).map f = f.right | Occasionally useful for rewriting in the backwards direction. | true |
Lean.instReprBinderInfo | Lean.Expr | Repr Lean.BinderInfo | null | true |
CategoryTheory.Arrow.augmentedCechNerve._proof_2 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
⦃X Y : SimplexCategoryᵒᵖ⦄ (f_1 : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.id (CategoryT... | null | false |
Mathlib.Meta.FunProp.Mor.isCoeFunName | Mathlib.Tactic.FunProp.Mor | Lean.Name → Lean.CoreM Bool | Is `name` a coercion from some function space to functions? | true |
BitVec._sizeOf_1 | Init.SizeOf | {w : ℕ} → BitVec w → ℕ | null | false |
QuadraticModuleCat.mk | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | {R : Type u} → [inst : CommRing R] → (toModuleCat : ModuleCat R) → QuadraticForm R ↑toModuleCat → QuadraticModuleCat R | null | true |
CategoryTheory.Join.mapIsoWhiskerLeft_inv_app | Mathlib.CategoryTheory.Join.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {E' : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} E'] (H : CategoryTheory.Functor C E) {Fᵣ Gᵣ : CategoryTheory.Functor D E'}
(... | null | true |
CategoryTheory.ShortComplex.leftHomology | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → (S : CategoryTheory.ShortComplex C) → [S.HasLeftHomology] → C | The left homology of a short complex, given by the `H` field of a chosen left homology data. | true |
_private.Lean.Parser.Do.0.Lean.Parser.Term.doTry._regBuiltin.Lean.Parser.Term.doCatch.parenthesizer_23 | Lean.Parser.Do | IO Unit | null | false |
_private.Lean.Class.0.Lean.addClass._sparseCasesOn_1 | Lean.Class | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.InductiveVal) → motive (Lean.ConstantInfo.inductInfo val)) →
((val : Lean.AxiomVal) → motive (Lean.ConstantInfo.axiomInfo val)) →
(Nat.hasNotBit 33 t.ctorIdx → motive t) → motive t | null | false |
irrational_sqrt_of_multiplicity_odd | Mathlib.NumberTheory.Real.Irrational | ∀ (m : ℤ), 0 < m → ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], multiplicity (↑p) m % 2 = 1 → Irrational √↑m | null | true |
PosNum.cast_to_num | Mathlib.Data.Num.Lemmas | ∀ (n : PosNum), ↑n = Num.pos n | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Internalize.0.Lean.Meta.Grind.Arith.CommRing.internalize.match_3 | Lean.Meta.Tactic.Grind.Arith.CommRing.Internalize | (motive : Option Lean.Meta.Grind.Arith.CommRing.SemiringExpr → Sort u_1) →
(__x : Option Lean.Meta.Grind.Arith.CommRing.SemiringExpr) →
((re : Lean.Meta.Grind.Arith.CommRing.SemiringExpr) → motive (some re)) →
((x : Option Lean.Meta.Grind.Arith.CommRing.SemiringExpr) → motive x) → motive __x | null | false |
_private.Lean.Meta.Sym.Simp.DiscrTree.0.Lean.Meta.Sym.getMatchLoop._proof_5 | Lean.Meta.Sym.Simp.DiscrTree | ∀ {α : Type} (cs : Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α)), ¬cs.size = 0 → ¬0 < cs.size → False | null | false |
AddMonoidAlgebra.apply_eq_zero_of_not_le_supDegree | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : Semiring R] [inst_1 : SemilatticeSup B] [inst_2 : OrderBot B]
{D : A → B} {p : AddMonoidAlgebra R A} {a : A}, ¬D a ≤ AddMonoidAlgebra.supDegree D p → p a = 0 | null | true |
InitialSeg.«_aux_Mathlib_Order_InitialSeg___macroRules_InitialSeg_term_≼i__1» | Mathlib.Order.InitialSeg | Lean.Macro | null | false |
Std.HashSet.Raw.insertMany_ind | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {ρ : Type v} [inst_2 : ForIn Id ρ α]
{motive : Std.HashSet.Raw α → Prop} (m : Std.HashSet.Raw α) (l : ρ),
motive m → (∀ (m : Std.HashSet.Raw α) (a : α), motive m → motive (m.insert a)) → motive (m.insertMany l) | null | true |
instRingFreeRing._proof_19 | Mathlib.RingTheory.FreeRing | ∀ (α : Type u_1) (a : FreeRing α), a * 1 = a | null | false |
Lean.Lsp.DidOpenTextDocumentParams.recOn | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.DidOpenTextDocumentParams → Sort u} →
(t : Lean.Lsp.DidOpenTextDocumentParams) →
((textDocument : Lean.Lsp.TextDocumentItem) → motive { textDocument := textDocument }) → motive t | null | false |
CategoryTheory.abelianOfEquivalence._proof_2 | Mathlib.CategoryTheory.Abelian.Transfer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (F : CategoryTheory.Functor C D) [inst_2 : F.IsEquivalence],
CategoryTheory.Limits.PreservesFiniteLimits F.inv | null | false |
Filter.instCountableInterFilterCountableGenerate | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_1} (g : Set (Set α)), CountableInterFilter (Filter.countableGenerate g) | null | true |
WithBot.WithTop.completeLattice | Mathlib.Order.ConditionallyCompleteLattice.Basic | {α : Type u_5} → [ConditionallyCompleteLattice α] → CompleteLattice (WithBot (WithTop α)) | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs.0.CategoryTheory.IsPullback.isoIsPullback_inv_fst._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.inv f = g) = (f = CategoryTheory.CategoryStruct.comp α.hom g) | null | false |
finTwoEquiv._proof_3 | Mathlib.Logic.Equiv.Defs | ∀ (i : Fin 2), (fun b => bif b then 1 else 0) ((fun i => i == 1) i) = i | null | false |
Aesop.EqualUpToIds.readAllowAssignmentDiff | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM Bool | null | true |
LaurentSeries.LaurentSeriesRingEquiv_def | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] (f : PowerSeries K),
(LaurentSeries.LaurentSeriesRingEquiv K) ((HahnSeries.ofPowerSeries ℤ K) f) =
(LaurentSeries.LaurentSeriesPkg K).compare LaurentSeries.ratfuncAdicComplPkg ((HahnSeries.ofPowerSeries ℤ K) f) | null | true |
MeasurableSet.symmDiff | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} {s₁ s₂ : Set α},
MeasurableSet s₁ → MeasurableSet s₂ → MeasurableSet (symmDiff s₁ s₂) | null | true |
_private.Init.Core.0.dif_pos.match_1_1 | Init.Core | ∀ {c : Prop} (motive : Decidable c → Prop) (h : Decidable c),
(∀ (h : c), motive (isTrue h)) → (∀ (hnc : ¬c), motive (isFalse hnc)) → motive h | null | false |
_private.Mathlib.Data.Real.ConjExponents.0.NNReal.HolderConjugate.div_conj_eq_sub_one._simp_1_3 | Mathlib.Data.Real.ConjExponents | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Seminorm._sizeOf_inst | Mathlib.Analysis.Seminorm | (𝕜 : Type u_12) →
(E : Type u_13) →
{inst : SeminormedRing 𝕜} →
{inst_1 : AddGroup E} → {inst_2 : SMul 𝕜 E} → [SizeOf 𝕜] → [SizeOf E] → SizeOf (Seminorm 𝕜 E) | null | false |
Matrix.exp_nsmul | Mathlib.Analysis.Normed.Algebra.MatrixExponential | ∀ {m : Type u_1} {𝔸 : Type u_5} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NormedRing 𝔸] [NormedAlgebra ℚ 𝔸]
[CompleteSpace 𝔸] (n : ℕ) (A : Matrix m m 𝔸), NormedSpace.exp (n • A) = NormedSpace.exp A ^ n | null | true |
GrpCat.SurjectiveOfEpiAuxs.instSMulCarrierXWithInfinity._proof_3 | Mathlib.Algebra.Category.Grp.EpiMono | ∀ {A B : GrpCat} (f : A ⟶ B) (b : ↑B) (y : ↑(Set.range fun x => x • ↑(GrpCat.Hom.hom f).range)),
b • ↑y ∈ Set.range fun x => x • ↑(GrpCat.Hom.hom f).range | null | false |
Module.Finite.of_localizationSpan_finite | Mathlib.RingTheory.Localization.Finiteness | ∀ {R : Type u} [inst : CommSemiring R] {M : Type w} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (t : Finset R),
Ideal.span ↑t = ⊤ →
(∀ (g : ↥t), Module.Finite (Localization.Away ↑g) (LocalizedModule.Away (↑g) M)) → Module.Finite R M | If there exists a finite set `{ r }` of `R` that generates the unit ideal and such that `Mᵣ` is
`Rᵣ`-finite for each `r`, then `M` is a finite `R`-module.
See `of_localizationSpan` for a version without the finite set assumption.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.