name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Time.instReprOffsetX | Std.Time.Format.Modifier | Repr Std.Time.OffsetX | null | true |
OrderIso.divRight₀_apply | Mathlib.Algebra.Order.GroupWithZero.OrderIso | ∀ {G₀ : Type u_1} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [inst_2 : MulPosReflectLT G₀] (a : G₀)
(ha : 0 < a) (x : G₀), (OrderIso.divRight₀ a ha) x = x / a | null | true |
GroupSeminorm.instMin._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : CommGroup E] (p q : GroupSeminorm E) (r : ℝ), 0 < r → p 1 + q (1 / 1) < r | null | false |
Module.compHom.toLinearEquiv._proof_2 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S] (g : R ≃+* S) (x y : R),
g.toFun (x + y) = g.toFun x + g.toFun y | null | false |
MvPFunctor.M.Path.root | Mathlib.Data.PFunctor.Multivariate.M | {n : ℕ} →
{P : MvPFunctor.{u} (n + 1)} →
(x : P.last.M) →
(a : P.A) → (f : P.last.B a → P.last.M) → x.dest = ⟨a, f⟩ → (i : Fin2 n) → P.drop.B a i → MvPFunctor.M.Path P x i | null | true |
HNNExtension.toSubgroup.eq_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] (A B : Subgroup G) (u : ℤˣ), HNNExtension.toSubgroup A B u = if u = 1 then A else B | null | true |
String.Slice.Pos.le_ofSliceFrom._simp_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ : s.Pos} {pos : (s.sliceFrom p₀).Pos}, (p₀ ≤ String.Slice.Pos.ofSliceFrom pos) = True | null | false |
HNNExtension.NormalWord.instMulAction_1._proof_1 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (φ : ↥A ≃* ↥B) {d : HNNExtension.NormalWord.TransversalPair G A B}
(a : ↥A),
HNNExtension.NormalWord.unitsSMulEquiv φ * (MulAction.toPermHom G (HNNExtension.NormalWord d)) ↑a =
(MulAction.toPermHom G (HNNExtension.NormalWord d)) ↑(φ a) * HNNExtension.NormalWo... | null | false |
OrderIso.sumCongr | Mathlib.Order.Sum.Order | {α₁ : Type u_4} →
{α₂ : Type u_5} →
{β₁ : Type u_6} →
{β₂ : Type u_7} →
[inst : LE α₁] →
[inst_1 : LE α₂] → [inst_2 : LE β₁] → [inst_3 : LE β₂] → α₁ ≃o α₂ → β₁ ≃o β₂ → α₁ ⊕ β₁ ≃o α₂ ⊕ β₂ | `Equiv.sumCongr` promoted to an order isomorphism. | true |
Lean.Lsp.FileSystemWatcher.globPattern | Lean.Data.Lsp.Workspace | Lean.Lsp.FileSystemWatcher → String | null | true |
Zsqrtd.decidableNonnegg._proof_2 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ (c d a a_1 : ℕ),
((c * (a_1 + 1) * (a_1 + 1)).ble (d * a * a)).Reflects (Zsqrtd.Nonnegg c d (Int.ofNat a) (Int.negSucc a_1)) | null | false |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.schroeder_bernstein_of_rel._proof_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α},
g '' (f '' OrderHom.lfp { toFun := fun s => (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ })ᶜ =
(OrderHom.lfp { toFun := fun s => (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ })ᶜ →
∀ a ∉ OrderHom.lfp { toFun := fun s => (g '' (f '' s)ᶜ)ᶜ, monotone' := ⋯ },
a ∈ g '' (f... | null | false |
_private.Mathlib.RingTheory.LocalProperties.Basic.0.Ideal.iInf_ker_le._simp_1_1 | Mathlib.RingTheory.LocalProperties.Basic | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | null | false |
Lean.PersistentHashMap.EntriesNode | Lean.Data.PersistentHashMap | Type u_1 → Type u_2 → Type (max 0 u_2 u_1) | null | true |
Std.Tactic.BVDecide.BVPred._sizeOf_inst | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | SizeOf Std.Tactic.BVDecide.BVPred | null | false |
wellApproximable.eq_1 | Mathlib.NumberTheory.WellApproximable | ∀ (A : Type u_1) [inst : SeminormedGroup A] (δ : ℕ → ℝ),
wellApproximable A δ = Filter.blimsup (fun n => approxOrderOf A n (δ n)) Filter.atTop fun n => 0 < n | null | true |
_private.Mathlib.Data.Set.Basic.0.Set.nonempty_of_not_subset.match_1_1 | Mathlib.Data.Set.Basic | ∀ {α : Type u_1} {s t : Set α} (motive : (∃ a ∈ s, a ∉ t) → Prop) (x : ∃ a ∈ s, a ∉ t),
(∀ (x : α) (xs : x ∈ s) (xt : x ∉ t), motive ⋯) → motive x | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations.0.RootPairing.GeckConstruction.lie_e_f_ne._proof_1_8 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Relations | ∀ {ι : Type u_2} {R : Type u_3} {M : Type u_1} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {b : P.Base}
{i j : ↥b.support} (k l l' : ι),
P.root l' = P.root l + P.root ↑i →
∀ (x : ι), x ≠ l' → ¬(P.r... | null | false |
UInt64.natCast | Init.GrindInstances.Ring.UInt | NatCast UInt64 | null | true |
_private.Mathlib.Order.Disjointed.0.preimage_find_eq_disjointed._simp_1_1 | Mathlib.Order.Disjointed | ∀ {m : ℕ} {p : ℕ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (Nat.find h = m) = (p m ∧ ∀ n < m, ¬p n) | null | false |
Zsqrtd.addGroupWithOne._proof_2 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} (n : ℕ), Zsqrtd.ofInt ↑(n + 1) = Zsqrtd.ofInt ↑n + 1 | null | false |
_private.Mathlib.AlgebraicGeometry.Gluing.0.AlgebraicGeometry.Scheme.IsLocallyDirected.«_aux_Mathlib_AlgebraicGeometry_Gluing___delab_app__private_Mathlib_AlgebraicGeometry_Gluing_0_AlgebraicGeometry_Scheme_IsLocallyDirected_term↓__1» | Mathlib.AlgebraicGeometry.Gluing | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
AlternatingMap.domCoprod' | Mathlib.LinearAlgebra.Alternating.DomCoprod | {ιa : Type u_1} →
{ιb : Type u_2} →
[Fintype ιa] →
[Fintype ιb] →
{R' : Type u_3} →
{Mᵢ : Type u_4} →
{N₁ : Type u_5} →
{N₂ : Type u_6} →
[inst : CommSemiring R'] →
[inst_1 : AddCommGroup N₁] →
[inst_2 : Module... | A more bundled version of `AlternatingMap.domCoprod` that maps
`((ι₁ → N) → N₁) ⊗ ((ι₂ → N) → N₂)` to `(ι₁ ⊕ ι₂ → N) → N₁ ⊗ N₂`. | true |
AffineMap.restrict._proof_2 | Mathlib.LinearAlgebra.AffineSpace.Restrict | ∀ {k : Type u_2} {V₁ : Type u_1} {P₁ : Type u_3} {V₂ : Type u_4} {P₂ : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] (φ : P₁ →ᵃ[k] P₂) {E : AffineSubspace k P₁}
{F : AffineSubspace... | null | false |
ConnectedComponents.isQuotientMap_coe | Mathlib.Topology.Connected.Clopen | ∀ {α : Type u} [inst : TopologicalSpace α], Topology.IsQuotientMap ConnectedComponents.mk | null | true |
CentroidHomClass.mk | Mathlib.Algebra.Ring.CentroidHom | ∀ {F : Type u_6} {α : outParam (Type u_7)} [inst : NonUnitalNonAssocSemiring α] [inst_1 : FunLike F α α]
[toAddMonoidHomClass : AddMonoidHomClass F α α],
(∀ (f : F) (a b : α), f (a * b) = a * f b) → (∀ (f : F) (a b : α), f (a * b) = f a * b) → CentroidHomClass F α | null | true |
Real.toNNReal_le_toNNReal | Mathlib.Basic.NNReal.Defs | ∀ {r p : ℝ}, r ≤ p → r.toNNReal ≤ p.toNNReal | null | true |
Lean.Order.PredTrans.apply | Std.Internal.Order.PredTrans | {Pred : Type u} → {EPred : Type v} → {α : Type w} → Lean.Order.PredTrans Pred EPred α → (α → Pred) → EPred → Pred | Apply the predicate transformer to a postcondition and exception postcondition. | true |
RingTheory.Sequence.IsWeaklyRegular.recIterModByRegularWithRing.match_3 | Mathlib.RingTheory.Regular.RegularSequence | (motive :
(x : Type u_1) →
(x_1 : CommRing x) →
(x_2 : Type u_2) →
(x_3 : AddCommGroup x_2) →
(x_4 : Module x x_2) → (x_5 : List x) → RingTheory.Sequence.IsWeaklyRegular x_2 x_5 → Sort u_3) →
(x : Type u_1) →
(x_1 : CommRing x) →
(x_2 : Type u_2) →
(x_3 : AddC... | null | false |
Mathlib.Meta.NormNum.inferLinearOrderedSemifield | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
(α : Q(Type u)) → Lean.MetaM ((x : Q(Semifield «$α»)) × (x_1 : Q(LinearOrder «$α»)) × Q(IsStrictOrderedRing «$α»)) | Helper function to synthesize typed `Semifield α` `LinearOrder α` `IsStrictOrderedRing α`
expressions. | true |
Field.nnratCast._inherited_default | Mathlib.Algebra.Field.Defs | {K : Type u} → (ℕ → K) → (K → K → K) → ℚ≥0 → K | null | false |
instNonemptyOfMonad | Init.Prelude | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [Monad m] [Nonempty α], Nonempty (m α) | null | true |
IsAdjoinRoot.adjoin_root_eq_top | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] {f : Polynomial R} [inst_2 : Algebra R S]
(h : IsAdjoinRoot S f), R[h.root] = ⊤ | null | true |
CompletelyNormalSpace.recOn | Mathlib.Topology.Separation.Regular | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : CompletelyNormalSpace X → Sort u_1} →
(t : CompletelyNormalSpace X) →
((completely_normal :
∀ ⦃s t : Set X⦄, Disjoint (closure s) t → Disjoint s (closure t) → Disjoint (nhdsSet s) (nhdsSet t)) →
motive ⋯) →
mo... | null | false |
HahnSeries.instMul._proof_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} [inst : AddCommMonoid Γ] [inst_1 : PartialOrder Γ] [IsOrderedCancelAddMonoid Γ],
IsOrderedCancelVAdd Γ Γ | null | false |
Finset.piecewise_le_of_le_of_le | Mathlib.Data.Finset.Piecewise | ∀ {ι : Type u_1} (s : Finset ι) [inst : (j : ι) → Decidable (j ∈ s)] {π : ι → Type u_3} {f g h : (i : ι) → π i}
[inst_1 : (i : ι) → Preorder (π i)], f ≤ h → g ≤ h → s.piecewise f g ≤ h | null | true |
CategoryTheory.Limits.exists_hom₂_of_preservesColimit_coyoneda | Mathlib.CategoryTheory.Presentable.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] {D : CategoryTheory.Functor J C} [CategoryTheory.IsFiltered J]
{c : CategoryTheory.Limits.Cocone D} (hc : CategoryTheory.Limits.IsColimit c) {X : C}
[CategoryTheory.Limits.PreservesColimit D ... | null | true |
LocalizedModule.instRing._proof_6 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] {S : Submonoid R},
autoParam (∀ (n : ℕ) (a : LocalizedModule S A), Int.negSucc n • a = -(↑n.succ • a)) SubNegMonoid.zsmul_neg'._autoParam | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic.0.RootPairing.GeckConstruction.instIsLieAbelianSubtypeMatrixSumMemFinsetSupportLieSubalgebraLieAlgebraCartanSubalgebra'._simp_3 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
LocallyConstant.instRing._proof_2 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Ring Y], ⇑1 = ⇑1 | null | false |
LinearMap.map_sub₂ | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_1} {R₂ : Type u_2} {S : Type u_3} {S₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : Semiring S] [inst_3 : Semiring S₂] {N : Type u_7} [inst_4 : AddCommMonoid N] [inst_5 : Module S N]
{M' : Type u_12} {P' : Type u_13} [inst_6 : AddCommGroup M'] [inst_7 : AddCommGroup P'] [inst_8 : Mo... | null | true |
FreeMonoid.instUniqueOfIsEmpty.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} [inst : IsEmpty α],
FreeMonoid.instUniqueOfIsEmpty = { toInhabited := FreeMonoid.instInhabited, uniq := ⋯ } | null | true |
CategoryTheory.instIsSplitEpiOppositeOpOfIsSplitMono | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} [CategoryTheory.IsSplitMono f],
CategoryTheory.IsSplitEpi f.op | null | true |
Nat.Internal.Linear.Poly.norm.go._sunfold | Init.Data.Nat.Internal.Linear | Nat.Internal.Linear.Poly → Nat.Internal.Linear.Poly → Nat.Internal.Linear.Poly | null | false |
_private.Mathlib.RingTheory.HahnSeries.Summable.0.HahnSeries.SummableFamily.coeff_hsum_mul._simp_1_2 | Mathlib.RingTheory.HahnSeries.Summable | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | null | false |
CategoryTheory.Adjunction.compUliftCoyonedaIso._proof_4 | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_4, u_3} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((F.op.comp CategoryTheory.uliftCoyoneda.{max u_... | null | false |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.quadrant_I._simp_1_2 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u} {f : Filter α} {p : α → Prop} {s : Set α},
(∀ᶠ (x : α) in f ⊓ Filter.principal s, p x) = ∀ᶠ (x : α) in f, x ∈ s → p x | null | false |
Lean.Elab.Term.BinderView.mk.inj | Lean.Elab.Binders | ∀ {ref id type : Lean.Syntax} {bi : Lean.BinderInfo} {ref_1 id_1 type_1 : Lean.Syntax} {bi_1 : Lean.BinderInfo},
{ ref := ref, id := id, type := type, bi := bi } = { ref := ref_1, id := id_1, type := type_1, bi := bi_1 } →
ref = ref_1 ∧ id = id_1 ∧ type = type_1 ∧ bi = bi_1 | null | true |
CategoryTheory.ShortComplex.ShortExact.extClass._proof_7 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExtClass | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomologicalComplex.single C (ComplexShape.up ℤ) 0).PreservesZeroMorphisms | null | false |
CategoryTheory.Comma.mapRightId_hom_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {B : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} B] {A : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} A]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
(L : CategoryTheory.Functor A T) (X : CategoryTheory.Comma L R),
((CategoryTheory.Comma.mapRightId R ... | null | true |
Set.subtypeInsertEquivOption.congr_simp | Mathlib.RingTheory.Algebraic.MvPolynomial | ∀ {α : Type u_1} [inst : DecidableEq α] {t : Set α} {x : α} (h : x ∉ t),
Set.subtypeInsertEquivOption h = Set.subtypeInsertEquivOption h | null | true |
CategoryTheory.Idempotents.Karoubi.rec | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Idempotents.Karoubi C → Sort u} →
((X : C) →
(p : X ⟶ X) → (idem : CategoryTheory.CategoryStruct.comp p p = p) → motive { X := X, p := p, idem := idem }) →
(t : CategoryTheory.Idempotents.Karoubi C) →... | null | false |
Matrix.TransvectionStruct.toMatrix.eq_1 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {R : Type u₂} [inst : DecidableEq n] [inst_1 : CommRing R] (t : Matrix.TransvectionStruct n R),
t.toMatrix = Matrix.transvection t.i t.j t.c | null | true |
ClassGroup.fintypeOfAdmissibleOfFinite._proof_12 | Mathlib.NumberTheory.ClassNumber.Finite | ∀ {R : Type u_1} {S : Type u_2} (L : Type u_3) [inst : EuclideanDomain R] [inst_1 : CommRing S] [inst_2 : Field L]
[algRL : Algebra R L] [inst_3 : Algebra R S] [inst_4 : Algebra S L] [ist : IsScalarTower R S L]
[IsIntegralClosure S R L], Algebra.IsIntegral R S | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.farFromTriangleFree_of_disjoint_triangles_aux._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {V : Type u_1} {G : SimpleGraph V} {e : Sym2 V} [inst : Fintype ↑G.edgeSet], (e ∈ G.edgeFinset) = (e ∈ G.edgeSet) | null | false |
_private.Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four.0.CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono''._proof_7 | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ∀ {n k : ℕ}, k + 3 ≤ n → ∀ (k₀ k₁ k₂ k₃ : ℕ), k₀ = k → k₁ = k + 1 → k₂ = k + 2 → k₃ = k + 3 → ¬k₂ ≤ n → False | null | false |
Int16.ofBitVec_sdiv | Init.Data.SInt.Lemmas | ∀ (a b : BitVec 16), Int16.ofBitVec (a.sdiv b) = Int16.ofBitVec a / Int16.ofBitVec b | null | true |
FractionalIdeal.dual_eq_zero_iff._simp_1 | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L... | null | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.getKeyD_insertIfNew._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Algebra.IsStandardEtale.mk._flat_ctor | Mathlib.RingTheory.Etale.StandardEtale | ∀ {R : Type u_4} {S : Type u_5} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Nonempty (StandardEtalePresentation R S) → Algebra.IsStandardEtale R S | null | false |
LineDerivAdd.rec | Mathlib.Analysis.Distribution.DerivNotation | {V : Type u} →
{E : Type v} →
{F : Type w} →
[inst : AddCommGroup V] →
[inst_1 : AddCommGroup E] →
[inst_2 : AddCommGroup F] →
[inst_3 : LineDeriv V E F] →
{motive : LineDerivAdd V E F → Sort u_1} →
((lineDerivOp_add :
∀ (v : ... | null | false |
IntermediateField.le_extendScalars_iff | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {F E : IntermediateField K L}
(h : F ≤ E) (E' : IntermediateField (↥F) L),
E' ≤ IntermediateField.extendScalars h ↔ IntermediateField.restrictScalars K E' ≤ E | null | true |
squeeze_one_norm | Mathlib.Analysis.Normed.Group.Continuity | ∀ {α : Type u_1} {E : Type u_4} [inst : SeminormedGroup E] {f : α → E} {a : α → ℝ} {t₀ : Filter α},
(∀ (n : α), ‖f n‖ ≤ a n) → Filter.Tendsto a t₀ (nhds 0) → Filter.Tendsto f t₀ (nhds 1) | Special case of the sandwich theorem: if the norm of `f` is bounded by a real function `a` which
tends to `0`, then `f` tends to `1`. | true |
FunLike.divInvOneMonoid._proof_2 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : Mul F] [inst_2 : DivInvOneMonoid β]
[IsMulApply F α β] (f g : F), ⇑(f * g) = ⇑f * ⇑g | null | false |
Matroid.IsBasis'.contract_indep_iff | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {I J X : Set α},
M.IsBasis' I X → ((M.contract X).Indep J ↔ M.Indep (J ∪ I) ∧ Disjoint X J) | null | true |
ValuativeRel.instCommMonoidWithZeroValueGroupWithZero._proof_3 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] (x : R) (y : ↥(ValuativeRel.posSubmonoid R)),
1 * ValuativeRel.ValueGroupWithZero.mk x y = ValuativeRel.ValueGroupWithZero.mk x y | null | false |
Function.locallyFinsuppWithin.instSMulInt | Mathlib.Topology.LocallyFinsupp | {X : Type u_1} →
[inst : TopologicalSpace X] →
{U : Set X} → {Y : Type u_2} → [inst_1 : AddGroup Y] → SMul ℤ (Function.locallyFinsuppWithin U Y) | null | true |
CategoryTheory.Lax.OplaxTrans.Hom.of.inj | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {as as_1 : CategoryTheory.Lax.OplaxTrans.Modification η θ},
{ as := as } = { as := as_1 } → as = as_1 | null | true |
WeierstrassCurve.Jacobian.nonsingular_iff_of_Y_eq_negY | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F},
P 2 ≠ 0 → P 1 = W.negY P → (W.Nonsingular P ↔ W.Equation P ∧ (MvPolynomial.eval P) W.polynomialX ≠ 0) | null | true |
Std.DTreeMap.Internal.Impl.Const.get!_alter_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k : α} [inst : Inhabited β] {f : Option β → Option β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl k =
(f (Std.DTreeMap.Internal.Impl.Const.get... | null | true |
Units.divp_sub | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Ring α] (a b : α) (u : αˣ), a /ₚ u - b = (a - b * ↑u) /ₚ u | null | true |
Lean.Meta.Match.Pattern.hasExprMVar._unsafe_rec | Lean.Meta.Match.Basic | Lean.Meta.Match.Pattern → Bool | null | false |
ModuleCat.biproductIsoPi | Mathlib.Algebra.Category.ModuleCat.Biproducts | {R : Type u} → [inst : Ring R] → {J : Type} → [inst_1 : Finite J] → (f : J → ModuleCat R) → ⨁ f ≅ ↧((j : J) → ↑(f j)) | We verify that the biproduct we've just defined is isomorphic to the `ModuleCat R` structure
on the dependent function type.
| true |
AddAction.IsPretransitive | Mathlib.Algebra.Group.Action.Pretransitive | (M : Type u_5) → (α : Type u_6) → [VAdd M α] → Prop | `M` acts pretransitively on `α` if for any `x y` there is `g` such that `g +ᵥ x = y`.
A transitive action should furthermore have `α` nonempty. | true |
Monoid.CoprodI.Word.prod_cons | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (i : ι) (m : M i) (w : Monoid.CoprodI.Word M)
(h1 : m ≠ 1) (h2 : w.fstIdx ≠ some i), (Monoid.CoprodI.Word.cons m w h2 h1).prod = Monoid.CoprodI.of m * w.prod | null | true |
Lean.Meta.SynthInstance.Context._sizeOf_inst | Lean.Meta.SynthInstance | SizeOf Lean.Meta.SynthInstance.Context | null | false |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.mkProofOverApp.go | Lean.Compiler.LCNF.ToLCNF | Lean.Expr → Lean.Expr → ℕ → Array Lean.Expr → Lean.MetaM Lean.Expr | null | true |
instOneTangentSpaceRealModelWithCornersSelf | Mathlib.Geometry.Manifold.Instances.Icc | (x : ℝ) → One (TangentSpace (modelWithCornersSelf ℝ ℝ) x) | null | true |
finprod_pow | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] {f : α → M},
Function.HasFiniteMulSupport f → ∀ (n : ℕ), (∏ᶠ (i : α), f i) ^ n = ∏ᶠ (i : α), f i ^ n | null | true |
DirectLimit.NonUnitalRing.of._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] (G : ι → Type u_1) {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
(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 : ι) → NonUnitalNonA... | null | false |
ENat.natCast_lt_top._simp_2 | Mathlib.Tactic.ENatToNat | ∀ (n : ℕ), (↑n < ⊤) = True | null | false |
OrderIso.sumAssoc | Mathlib.Order.Sum.Order | (α : Type u_10) →
(β : Type u_11) → (γ : Type u_12) → [inst : LE α] → [inst_1 : LE β] → [inst_2 : LE γ] → (α ⊕ β) ⊕ γ ≃o α ⊕ β ⊕ γ | `Equiv.sumAssoc` promoted to an order isomorphism. | true |
CategoryTheory.Limits.isKernelOfComp._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {W : C} (g : Y ⟶ W) (h : X ⟶ W),
CategoryTheory.CategoryStruct.comp f g = h →
∀ (s : CategoryTheory.Limits.Fork f 0), CategoryTheory.CategoryStruct.comp s.ι h = 0 | null | false |
AddMonoidAlgebra.one_def | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : Zero M], 1 = AddMonoidAlgebra.single 0 1 | null | true |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.norm_LFunction_product_ge_one.match_1_1 | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {x : ℝ} (y : ℝ)
(motive : 1 < (1 + ↑x).re ∧ 1 < (1 + ↑x + Complex.I * ↑y).re ∧ 1 < (1 + ↑x + 2 * Complex.I * ↑y).re → Prop)
(x_1 : 1 < (1 + ↑x).re ∧ 1 < (1 + ↑x + Complex.I * ↑y).re ∧ 1 < (1 + ↑x + 2 * Complex.I * ↑y).re),
(∀ (h₀ : 1 < (1 + ↑x).re) (h₁ : 1 < (1 + ↑x + Complex.I * ↑y).re) (h₂ : 1 < (1 + ↑x + 2 *... | null | false |
Std.ExtTreeMap.getD_map | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {f : α → β → γ} {k : α} {fallback : γ},
(Std.ExtTreeMap.map f t).getD k fallback = (Option.map (f k) t[k]?).getD fallback | null | true |
Group.exists_finiteIndexNormalSubgroup_of_residuallyFinite | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : Group G] [Group.ResiduallyFinite G] (g h : G), g ≠ h → ∃ H, ↑g ≠ ↑h | If `G` is residually finite, for every pair of distinct elements `g`, `h` there exists a finite
index normal subgroup `H` such that `g` and `h` differ in the quotient `G ⧸ H`. | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.getElem!_toArray_roo_ne_zero_iff._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ¬(i < (n - (m + 1)).toNat ∧ m + 1 + ↑i ≠ 0 ↔ i < (n - (m + 1)).toNat ∧ m + ↑i ≠ -1) → False | null | false |
CPolynomialAt.contDiffAt | Mathlib.Analysis.Calculus.ContDiff.CPolynomial | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E}, CPolynomialAt 𝕜 f x → ∀ {n : WithTop ℕ∞}, ContDiffAt 𝕜 n f x | null | true |
Lex.instCommGroupWithZero._proof_6 | Mathlib.Algebra.Order.GroupWithZero.Synonym | ∀ {α : Type u_1} [inst : CommGroupWithZero α], 0⁻¹ = 0 | null | false |
Monoid.CoprodI.inv_def | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} (G : ι → Type u_4) [inst : (i : ι) → Group (G i)] (x : Monoid.CoprodI G),
x⁻¹ =
MulOpposite.unop
((Monoid.CoprodI.lift fun i => (MonoidHom.op Monoid.CoprodI.of).comp (MulEquiv.inv' (G i)).toMonoidHom) x) | null | true |
Matrix.IsHermitian.rank_eq_card_non_zero_eigs | Mathlib.Analysis.Matrix.Spectrum | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {n : Type u_2} [inst_1 : Fintype n] {A : Matrix n n 𝕜} [inst_2 : DecidableEq n]
(hA : A.IsHermitian), A.rank = Fintype.card { i // hA.eigenvalues i ≠ 0 } | rank of a Hermitian matrix is the number of nonzero eigenvalues of the Hermitian matrix | true |
Set.imageFactorization | Mathlib.Data.Set.Operations | {α : Type u} → {β : Type v} → (f : α → β) → (s : Set α) → ↑s → ↑(f '' s) | Restriction of `f` to `s` factors through `s.imageFactorization f : s → f '' s`. | true |
Lean.Parser.FirstTokens.optTokens.elim | Lean.Parser.Types | {motive : Lean.Parser.FirstTokens → Sort u} →
(t : Lean.Parser.FirstTokens) →
t.ctorIdx = 3 → ((a : List Lean.Parser.Token) → motive (Lean.Parser.FirstTokens.optTokens a)) → motive t | null | false |
_private.Lean.Meta.Sym.SymM.0.Lean.Meta.Sym.foldProjs.match_3 | Lean.Meta.Sym.SymM | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((structName : Lean.Name) → (idx : ℕ) → (s : Lean.Expr) → motive (Lean.Expr.proj structName idx s)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
_private.Mathlib.Tactic.Group.0.Mathlib.Tactic.Group._aux_Mathlib_Tactic_Group___macroRules_Mathlib_Tactic_Group_group_1.match_1 | Mathlib.Tactic.Group | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.location) → Sort u_1) →
(loc : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) →
((loc : Lean.TSyntax `Lean.Parser.Tactic.location) → motive (some loc)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.location)) → motive x) → motive loc | null | false |
List.getElem_dropLast | Init.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i : ℕ} (h : i < xs.dropLast.length), xs.dropLast[i] = xs[i] | null | true |
CategoryTheory.Idempotents.whiskeringLeftObjToKaroubiFullyFaithful._proof_2 | Mathlib.CategoryTheory.Idempotents.FunctorExtension | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D]
{F G : CategoryTheory.Functor (CategoryTheory.Idempotents.Karoubi C) D}
(τ :
((CategoryTheory.Functor.whiskeringLeft C (CategoryTheory.Idempotents.Karoubi C) D).obj
(Catego... | null | false |
AddGroupNorm.instPartialOrder._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E], Function.Injective DFunLike.coe | null | false |
Lean.Server.Completion.HoverInfo.ctorElimType | Lean.Server.Completion.CompletionUtils | {motive : Lean.Server.Completion.HoverInfo → Sort u} → ℕ → Sort (max 1 u) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.