name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Matrix.updateRow_subsingleton | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_5} [inst : Subsingleton m] (A : Matrix m n R) (i : m) (b : n → R),
A.updateRow i b = (Matrix.replicateRow (Fin 1) b).submatrix (Function.const m 0) id | null | true |
IsAddRegular.nsmul | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {a : R} (n : ℕ), IsAddRegular a → IsAddRegular (n • a) | null | true |
LocallyConstant.coe_inv | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Inv Y] (f : LocallyConstant X Y), ⇑f⁻¹ = (⇑f)⁻¹ | null | true |
DoubleCentralizer.instCStarAlgebraComplex | Mathlib.Analysis.CStarAlgebra.Multiplier | {A : Type u_1} → [inst : NonUnitalCStarAlgebra A] → CStarAlgebra (DoubleCentralizer ℂ A) | null | true |
_private.Mathlib.Order.Filter.Tendsto.0.Filter.not_tendsto_iff_exists_frequently_notMem._simp_1_2 | Mathlib.Order.Filter.Tendsto | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.gluedCocone._simp_1 | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | null | false |
_private.Batteries.Data.List.Lemmas.0.List.countBefore_cons_succ_of_not_beq._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} {xs : List α} {i : ℕ} [inst : BEq α] {a : α},
(a == x) = false → List.countBefore x (a :: xs) (i + 1) = List.countBefore x xs i | null | false |
TrivSqZeroExt.instL1SeminormedRing.match_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} (motive : TrivSqZeroExt R M → TrivSqZeroExt R M → Prop) (x x_1 : TrivSqZeroExt R M),
(∀ (r₁ : R) (m₁ : M) (r₂ : R) (m₂ : M), motive (r₁, m₁) (r₂, m₂)) → motive x x_1 | null | false |
CategoryTheory.MonadicRightAdjoint.mk._flat_ctor | Mathlib.CategoryTheory.Monad.Adjunction | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
(L : CategoryTheory.Functor C D) →
(adj : L ⊣ R) → (CategoryTheory.Monad.comparison adj).IsEquivalence → CategoryTheo... | null | false |
Std.Do.SPred.bientails.of_eq | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q : Std.Do.SPred σs}, P = Q → P ⊣⊢ₛ Q | null | true |
MeasureTheory.predictablePart_add_ae_eq | Mathlib.Probability.Martingale.Centering | ∀ {Ω : Type u_1} {E : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] {ℱ : MeasureTheory.Filtration ℕ m0} [CompleteSpace E]
[MeasureTheory.SigmaFiniteFiltration μ ℱ] {f g : ℕ → Ω → E},
MeasureTheory.Martingale f ℱ μ →
(MeasureTheory.Str... | null | true |
Nat.exists_eq_add_one._simp_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ}, (∃ n, a = n + 1) = (0 < a) | null | false |
CategoryTheory.Arrow.RightHomotopy.compRight | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{u v w : CategoryTheory.Arrow V} →
{e f : u ⟶ v} →
CategoryTheory.Arrow.RightHomotopy e f →
(g : v ⟶ w) →
CategoryTheory.Arrow.RightHomotopy (CategoryTheory.... | Right homotopy is closed under composition (on the right). | true |
Lean.Meta.Grind.AC.EqCnstrProof.erase0.injEq | Lean.Meta.Tactic.Grind.AC.Types | ∀ (c c_1 : Lean.Meta.Grind.AC.EqCnstr),
(Lean.Meta.Grind.AC.EqCnstrProof.erase0 c = Lean.Meta.Grind.AC.EqCnstrProof.erase0 c_1) = (c = c_1) | null | true |
Std.AnyAsyncStream.casesOn | Std.Sync.StreamMap | {α : Type} →
{motive : Std.AnyAsyncStream α → Sort u} →
(t : Std.AnyAsyncStream α) →
({t : Type} → [inst : Std.Async.IO.AsyncStream t α] → (a : t) → motive (Std.AnyAsyncStream.mk a)) → motive t | null | false |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.«_aux_Std_Data_DHashMap_Internal_RawLemmas___macroRules_Std_DHashMap_Internal_Raw₀_tacticSimp_to_model[_]Using__1»._sparseCasesOn_1 | Std.Data.DHashMap.Internal.RawLemmas | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.addMatchCondsToSplitter._sunfold | Lean.Meta.Tactic.Grind.CasesMatch | Lean.Expr → ℕ → Lean.Expr | null | false |
DividedPowers.ideal_from_ringHom._proof_1 | Mathlib.RingTheory.DividedPowers.DPMorphism | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] [inst_1 : CommSemiring B] {I : Ideal A} {J : Ideal B}
(hI : DividedPowers I) (hJ : DividedPowers J) {f : A →+* B},
Ideal.map f I ≤ J →
∀ {a b : A},
a ∈ {x | x ∈ I ∧ ∀ (n : ℕ), f (hI.dpow n x) = hJ.dpow n (f x)} →
b ∈ {x | x ∈ I ∧ ∀ (n : ℕ), f... | null | false |
CategoryTheory.Limits.colimitIsoSwapCompColim_hom_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(G : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (X : K),
(CategoryThe... | null | true |
Array.mem_map | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {xs : Array α}, b ∈ Array.map f xs ↔ ∃ a ∈ xs, f a = b | null | true |
Action.actionPUnitEquivalence | Mathlib.CategoryTheory.Action.Basic | {V : Type u_1} → [inst : CategoryTheory.Category.{v_1, u_1} V] → Action V PUnit.{u_3 + 1} ≌ V | Actions/representations of the trivial monoid are just objects in the ambient category. | true |
Lean.Parser.Term.logNamedWarningAtMacro.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.WithTerminal.liftStar_inv | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
{Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z)
(hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x),
(CategoryTheory.WithTerminal.liftSt... | null | true |
StalkSkyscraperPresheafAdjunctionAuxs.counit_app | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type v}
[inst_1 : CategoryTheory.Category.{u, v} C] [inst_2 : CategoryTheory.Limits.HasTerminal C]
[inst_3 : CategoryTheory.Limits.HasColimits C] (c : C),
(StalkSkyscraperPresheafAdjunctionAuxs.counit p₀).app c = (skyscrap... | null | true |
Aesop.EqualUpToIds.Unsafe.localDeclsEqualUpToIdsCore | Aesop.Util.EqualUpToIds | Lean.LocalDecl → Lean.LocalDecl → ReaderT Aesop.EqualUpToIds.GoalContext Aesop.EqualUpToIdsM Bool | null | true |
ZeroAtInftyContinuousMap.instStar | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : AddMonoid β] → [inst_3 : StarAddMonoid β] → [ContinuousStar β] → Star (ZeroAtInftyContinuousMap α β) | null | true |
Fin.lt_of_lt_of_le | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b c : Fin n}, a < b → b ≤ c → a < c | null | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Monoidal_Rigid_Basic___unexpand_CategoryTheory_leftAdjointMate_1 | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.PrettyPrinter.Unexpander | null | false |
Std.Time.Weekday.instTransOrdOrdinal | Std.Time.Date.Unit.Weekday | Std.TransOrd Std.Time.Weekday.Ordinal | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise.0.Finpartition.equitabilise_aux._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Regularity.Equitabilise | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
FormalMultilinearSeries.compContinuousLinearMap_apply | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} {G : Type x} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommMonoid F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : Continu... | null | true |
Lean.Compiler.LCNF.SpecState.mk.injEq | Lean.Compiler.LCNF.SpecInfo | ∀ (specInfo specInfo_1 : Lean.PHashMap Lean.Name Lean.Compiler.LCNF.SpecEntry),
({ specInfo := specInfo } = { specInfo := specInfo_1 }) = (specInfo = specInfo_1) | null | true |
AlgebraicGeometry.Scheme.AffineZariskiSite.relativeGluingData._proof_1 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} {F : CategoryTheory.Functor X.AffineZariskiSiteᵒᵖ CommRingCat}
{α : (AlgebraicGeometry.Scheme.AffineZariskiSite.toOpensFunctor X).op.comp X.presheaf ⟶ F},
CategoryTheory.NatTrans.Coequifibered α →
CategoryTheory.NatTrans.Equifibered
(CategoryTheory.CategoryStruct.comp
... | null | false |
LocallyConstant.instAddCommGroup._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddCommGroup Y], ⇑0 = ⇑0 | null | false |
AddSubgroup.IsSubnormal.brecOn | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_2} [inst : AddGroup G] {motive : (a : AddSubgroup G) → a.IsSubnormal → Prop} {a : AddSubgroup G}
(t : a.IsSubnormal),
(∀ (a : AddSubgroup G) (t : a.IsSubnormal), AddSubgroup.IsSubnormal.below t → motive a t) → motive a t | null | true |
CategoryTheory.Limits.WalkingSpan.Hom.snd | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | CategoryTheory.Limits.WalkingSpan.zero ⟶ CategoryTheory.Limits.WalkingSpan.right | The right arrow of the walking span. | true |
FiniteField.frobeniusAlgEquiv_symm_apply | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_1) (R : Type u_2) [inst : Field K] [inst_1 : Fintype K] [inst_2 : CommRing R] [inst_3 : Algebra K R]
(p : ℕ) [inst_4 : ExpChar R p] [inst_5 : PerfectRing R p] (b : R),
(FiniteField.frobeniusAlgEquiv K R p).symm b = Function.surjInv ⋯ b | null | true |
ProfiniteGrp.limit | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] → CategoryTheory.Functor J ProfiniteGrp.{max v u} → ProfiniteGrp.{max v u} | The abbreviation for the limit of `ProfiniteGrp`s. | true |
AddMonoidAlgebra.single_commute_single | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {r₁ r₂ : R} {m₁ m₂ : M} [inst_1 : Add M],
AddCommute m₁ m₂ → Commute r₁ r₂ → Commute (AddMonoidAlgebra.single m₁ r₁) (AddMonoidAlgebra.single m₂ r₂) | null | true |
Lean.Meta.hasAssignableLevelMVar._unsafe_rec | Lean.Meta.HasAssignableMVar | Lean.Level → Lean.MetaM Bool | null | false |
Ordinal.veblen_zero_le_veblen_zero._simp_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ {o₁ o₂ : Ordinal.{u}}, (Ordinal.veblen o₁ 0 ≤ Ordinal.veblen o₂ 0) = (o₁ ≤ o₂) | null | false |
_private.Mathlib.Tactic.Linter.DocString.0.Mathlib.Linter.lintVersoSyntax | Mathlib.Tactic.Linter.DocString | String →
optParam (Option String) none →
Lean.Elab.Command.CommandElabM (Array (String.Pos.Raw × Lean.Parser.SyntaxStack × Lean.Parser.Error)) | Try to parse `docComment` as a Verso docstring, and report any parse errors,
ignoring those that should be silenced by linters.
`fileName` is the file where this docstring is defined (default: the file currently being
elaborated).
| true |
CategoryTheory.Limits.BinaryBicone.isBilimitOfKernelInl._proof_3 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
(b : CategoryTheory.Limits.BinaryBicone X Y) (hb : CategoryTheory.Limits.IsLimit b.sndKernelFork) {T : C} (f : T ⟶ X)
(g : T ⟶ Y) (m : T ⟶ b.toCone.pt),
CategoryTheory.CategoryStruct.comp m (CategoryTh... | null | false |
Submodule.IsCompl.projection_apply_left | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q) (x : ↥p), (p.projection q hpq) ↑x = ↑x | **Alias** of `Submodule.projection_apply_left`. | true |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.mkCongrOfAux.match_3 | Mathlib.Tactic.TermCongr | (motive : Lean.Expr → Lean.Expr → Sort u_1) →
(lhs rhs : Lean.Expr) →
((fn arg fn_1 arg_1 : Lean.Expr) → motive (fn.app arg) (fn_1.app arg_1)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
(binderName_1 : Lean.Name) →
... | null | false |
AntivaryOn.neg_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : AddCommGroup β]
[inst_2 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
AntivaryOn f g s → MonovaryOn f (-g) s | **Alias** of the reverse direction of `monovaryOn_neg_right`. | true |
Finsupp.mem_supported | Mathlib.LinearAlgebra.Finsupp.Supported | ∀ {α : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{s : Set α} (p : α →₀ M), p ∈ Finsupp.supported M R s ↔ ↑p.support ⊆ s | null | true |
ContinuousLinearMap.piEquivL._proof_2 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {ι : Type u_1} (F : ι → Type u_2) [inst : (i : ι) → AddCommGroup (F i)] [inst_1 : (i : ι) → TopologicalSpace (F i)]
[∀ (i : ι), IsTopologicalAddGroup (F i)], IsTopologicalAddGroup ((b : ι) → F b) | null | false |
Lean.Order.MonoBind.mk._flat_ctor | Init.Internal.Order.Basic | ∀ {m : Type u → Type v} [inst : Bind m] [inst_1 : (α : Type u) → Lean.Order.PartialOrder (m α)],
(∀ {α β : Type u} {a₁ a₂ : m α} {f : α → m β},
Lean.Order.PartialOrder.rel a₁ a₂ → Lean.Order.PartialOrder.rel (a₁ >>= f) (a₂ >>= f)) →
(∀ {α β : Type u} {a : m α} {f₁ f₂ : α → m β},
(∀ (x : α), Lean.Ord... | null | false |
Equiv.Perm.OnCycleFactors.coe_toPermHom | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (g : Equiv.Perm α) (k : ↥(Subgroup.centralizer {g}))
(c : ↥g.cycleFactorsFinset), ↑(((Equiv.Perm.OnCycleFactors.toPermHom g) k) c) = ↑k * ↑c * (↑k)⁻¹ | null | true |
Lean.Exception.casesOn | Lean.Exception | {motive : Lean.Exception → Sort u} →
(t : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) → motive t | null | false |
OrderIso.sumLexAssoc_symm_apply_inl | Mathlib.Order.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : LE α] [inst_1 : LE β] [inst_2 : LE γ] (a : α),
(OrderIso.sumLexAssoc α β γ).symm (Sum.inl a) = Sum.inl (Sum.inl a) | null | true |
_private.Mathlib.MeasureTheory.Function.L1Space.Integrable.0.MeasureTheory.Integrable.real_toNNReal._simp_1_1 | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G},
(|a| ≤ b) = (-b ≤ a ∧ a ≤ b) | null | false |
Matroid.delete_eq_delete_iff | Mathlib.Combinatorics.Matroid.Minor.Delete | ∀ {α : Type u_1} {M : Matroid α} {D₁ D₂ : Set α}, M.delete D₁ = M.delete D₂ ↔ D₁ ∩ M.E = D₂ ∩ M.E | null | true |
BialgCat.hasForgetToCoalgebra._proof_3 | Mathlib.Algebra.Category.BialgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {x x_1 : BialgCat R},
CoalgHomClass (x.carrier →ₐc[R] x_1.carrier) R x.carrier x_1.carrier | null | false |
Module.support | Mathlib.RingTheory.Support | (R : Type u_1) → (M : Type u_2) → [inst : CommRing R] → [inst_1 : AddCommGroup M] → [Module R M] → Set (PrimeSpectrum R) | The support of a module, defined as the set of primes `p` such that `Mₚ ≠ 0`. | true |
_private.Mathlib.RingTheory.AdicCompletion.Exactness.0.AdicCompletion.mapExactAux._proof_2 | Mathlib.RingTheory.AdicCompletion.Exactness | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} {M : Type u_1} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_1} [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : Type u_1} [inst_5 : AddCommGroup P]
[inst_6 : Module R P] {f : M →ₗ[R] N} {g : N →ₗ[R] P} (hfg : Function.Exact ⇑f ⇑g) (hg : Function.... | null | false |
SlashInvariantForm.quotientFunc | Mathlib.NumberTheory.ModularForms.NormTrace | {𝒢 ℋ : Subgroup (GL (Fin 2) ℝ)} →
{F : Type u_1} →
[inst : FunLike F UpperHalfPlane ℂ] →
{k : ℤ} → [SlashInvariantFormClass F 𝒢 k] → F → ↥ℋ ⧸ 𝒢.subgroupOf ℋ → UpperHalfPlane → ℂ | For `f` invariant under `𝒢`, this is a function on `(ℋ ⧸ 𝒢 ⊓ ℋ) × ℍ → ℂ` which packages up the
translates of `f` by `ℋ`. | true |
Lean.Elab.InlayHintTextEdit.toLspTextEdit | Lean.Server.FileWorker.InlayHints | Lean.FileMap → Lean.Elab.InlayHintTextEdit → Lean.Lsp.TextEdit | null | true |
CategoryTheory.TwoSquare.structuredArrowRightwardsOpEquivalence.functor_obj_left_left_as | Mathlib.CategoryTheory.GuitartExact.Opposite | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} {C₄ : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃... | null | true |
FiniteGaloisIntermediateField.instOrderBot._proof_1 | Mathlib.FieldTheory.Galois.GaloisClosure | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K]
(x : FiniteGaloisIntermediateField k K), ⊥ ≤ x.toIntermediateField | null | false |
LaurentPolynomial.toLaurent_support | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R),
(Polynomial.toLaurent f).coeff.support = Finset.map Nat.castEmbedding f.support | **Alias** of `LaurentPolynomial.support_coeff_toLaurent`.
---
The support of a polynomial `f` is a finset in `ℕ`. The lemma `toLaurent_support f`
shows that the support of `f.toLaurent` is the same finset, but viewed in `ℤ` under the natural
inclusion `ℕ ↪ ℤ`. | true |
String.Slice.revAll_bool_eq | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String.Slice}, s.revAll p = s.copy.toList.all p | null | true |
_private.Mathlib.RingTheory.MvPowerSeries.GaussNorm.0.MvPowerSeries.gaussNorm_add_le_max._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.GaussNorm | ∀ {α : Type u} [inst : SemilatticeSup α] {a b : α}, (a ⊔ b = a) = (b ≤ a) | null | false |
GenContFract.exists_conts_a_of_num | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} {n : ℕ} [inst : DivisionRing K] {A : K},
g.nums n = A → ∃ conts, g.conts n = conts ∧ conts.a = A | null | true |
Std.WP.Assertion.NondetFun.noConfusionType | Std.WP.Assertion | Sort u_1 →
{Pred : Type u} →
{Fun : Type v} →
{α : Type w} →
[inst : Std.WP.Assertion Pred] →
Std.WP.Assertion.NondetFun Pred Fun α →
{Pred' : Type u} →
{Fun' : Type v} →
{α' : Type w} → [inst' : Std.WP.Assertion Pred'] → Std.WP.Assertion.NondetFun... | null | false |
Affine.Triangle.equilateral_iff_dist_01_eq_02_and_dist_01_eq_12 | Mathlib.Analysis.Normed.Affine.Simplex | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring R] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : PseudoMetricSpace P] [inst_3 : Module R V] [inst_4 : NormedAddTorsor V P] {t : Affine.Triangle R P},
Affine.Simplex.Equilateral t ↔
dist (t.points 0) (t.points 1) = dist (t.points 0) (t.points 2) ∧
... | null | true |
SupClosed.iSup_mem | Mathlib.Order.SupClosed | ∀ {ι : Sort u_1} {α : Type u_3} [inst : CompleteLattice α] {f : ι → α} {s : Set α} [Finite ι],
SupClosed s → ⊥ ∈ s → (∀ (i : ι), f i ∈ s) → ⨆ i, f i ∈ s | null | true |
_private.Mathlib.LinearAlgebra.SesquilinearForm.Basic.0.LinearMap.isPairSelfAdjoint_equiv._simp_1_3 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} {M₁ : Type u_6} {M₃ : Type u_8} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid M₁] [inst_4 : Module R M₁] [inst_5 : AddCommMonoid M₃]
[inst_6 : Module R M₃] {I : R →+* R} {B : M →ₗ[R] M →ₛₗ[I] M₃} {B' : M₁ →ₗ[R] M₁ →ₛₗ[I] M₃} {f : M →... | null | false |
instMulSemiringActionSubtypeMemSubalgebraIntegralClosure._proof_6 | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | ∀ {G : Type u_3} {R : Type u_2} {K : Type u_1} [inst : CommRing R] [inst_1 : CommRing K] [inst_2 : Algebra R K]
[inst_3 : Group G] [inst_4 : MulSemiringAction G K] [inst_5 : SMulCommClass G R K] (g : G)
(x y : ↥(integralClosure R K)), g • (x * y) = g • x * g • y | null | false |
Lean.Parser.Termination.partialFixpoint.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
ProbabilityTheory.IsPreBrownianReal._auto_1 | Mathlib.Probability.BrownianMotion.Basic | Lean.Syntax | null | false |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Module.isPrincipal_submodule_iff.match_1_2 | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p : Submodule R M}
(a : ↥p) (m : M) (hm : m ∈ p) (motive : (∃ a_1, a_1 • a = ⟨m, hm⟩) → Prop) (x : ∃ a_1, a_1 • a = ⟨m, hm⟩),
(∀ (r : R) (hr : r • a = ⟨m, hm⟩), motive ⋯) → motive x | null | false |
seminormFromConst._proof_4 | Mathlib.Analysis.Normed.Unbundled.SeminormFromConst | ∀ {R : Type u_1} [inst : CommRing R] {c : R} {f : RingSeminorm R},
f c ≠ 0 →
IsPowMul ⇑f → ∀ (x y : R), seminormFromConst' c f (x + y) ≤ seminormFromConst' c f x + seminormFromConst' c f y | null | false |
AlgebraicGeometry.Scheme.stalkMapIsoOfIsPullback._proof_5 | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {P Y Z : AlgebraicGeometry.Scheme} {snd : P ⟶ Y} {g : Y ⟶ Z} [AlgebraicGeometry.IsOpenImmersion g] (p : ↥P),
CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Hom.stalkMap g (snd p)) | null | false |
openSegment_symm | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : SMul 𝕜 E] (x y : E), openSegment 𝕜 x y = openSegment 𝕜 y x | null | true |
Int.le_refl | Init.Data.Int.Order | ∀ (a : ℤ), a ≤ a | null | true |
Set.mem_graphOn._simp_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {f : α → β} {x : α × β}, (x ∈ Set.graphOn f s) = (x.1 ∈ s ∧ f x.1 = x.2) | null | false |
_private.Mathlib.Algebra.Ring.IsFormallyReal.0.IsFormallyReal.of_eq_zero_of_mul_self_of_eq_zero_of_add._proof_1_3 | Mathlib.Algebra.Ring.IsFormallyReal | ∀ {R : Type u_1} [inst : AddCommMonoid R] [inst_1 : Mul R],
(∀ {a : R}, a * a = 0 → a = 0) →
(∀ {s₁ s₂ : R}, IsSumSq s₁ → IsSumSq s₂ → s₁ + s₂ = 0 → s₁ = 0) →
∀ {b s : R}, b ≠ 0 → IsSumNonzeroSq s → ¬b * b + s = 0 | null | false |
Filter.eventually_all_finset._simp_1 | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Type u_1} (I : Finset ι) {l : Filter α} {p : ι → α → Prop},
(∀ᶠ (x : α) in l, ∀ i ∈ I, p i x) = ∀ i ∈ I, ∀ᶠ (x : α) in l, p i x | null | false |
Function.Injective.commMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : CommMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) → (∀ (x : M₁) (n : ℕ... | A type endowed with `1` and `*` is a commutative monoid, if it admits an injective map that
preserves `1` and `*` to a commutative monoid. See note [reducible non-instances]. | true |
Std.DTreeMap.Internal.Impl.Const.minEntry?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v}, Std.DTreeMap.Internal.Impl.Const.minEntry? Std.DTreeMap.Internal.Impl.leaf = none | null | true |
CauSeq.const_inv | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] {x : β} (hx : x ≠ 0),
CauSeq.const abv x⁻¹ = (CauSeq.const abv x).inv ⋯ | null | true |
Filter.map_eval_pi | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} (f : (i : ι) → Filter (α i)) [∀ (i : ι), (f i).NeBot] (i : ι),
Filter.map (Function.eval i) (Filter.pi f) = f i | null | true |
CategoryTheory.Limits.pullbackDiagonalMapIdIso._proof_13 | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{S T : C} (f : X ⟶ T) (g : Y ⟶ T) (i : T ⟶ S) [CategoryTheory.Limits.HasPullback f g],
CategoryTheory.Limits.HasPullback
(CategoryTheory.CategoryStruct.comp f
(CategoryTheory.inv (Categ... | null | false |
FormalGroup.constantCoeff_zeroX | Mathlib.RingTheory.FormalGroup.Basic | ∀ {R : Type u_1} [inst : CommRing R] (F : FormalGroup R), PowerSeries.constantCoeff F.zeroX = 0 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.contains_of_contains_insertManyIfNewUnit_list._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.CategoryTheory.Comma.Over.OverClass.0.CategoryTheory.instIsIsoOverInferInstanceOverClass._proof_1 | Mathlib.CategoryTheory.Comma.Over.OverClass | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (S : C), CategoryTheory.IsIso (S ↘ S) | null | false |
Polynomial.aeval_eq_smeval | Mathlib.Algebra.Polynomial.Smeval | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : Semiring S] [inst_2 : Algebra R S] (x : S)
(p : Polynomial R), (Polynomial.aeval x) p = p.smeval x | null | true |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.eqvTypes._sparseCasesOn_1 | Lean.Compiler.LCNF.InferType | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → mo... | null | false |
Std.ExtHashMap.size_alter_eq_self_of_not_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
k ∉ m → (f m[k]?).isNone = true → (m.alter k f).size = m.size | null | true |
NonemptyInterval.instPartialOrder | Mathlib.Order.Interval.Basic | {α : Type u_1} → [inst : PartialOrder α] → PartialOrder (NonemptyInterval α) | null | true |
CategoryTheory.Pi.laxMonoidalPi'_μ | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : (i : I) → CategoryTheory.Functor D (C i)) [inst_4 ... | null | true |
Set.Nonempty.sigma_fst | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_3} {s : Set ι} {t : (i : ι) → Set (α i)}, (s.sigma t).Nonempty → s.Nonempty | null | true |
Std.Http.Server.RemoteAddr._sizeOf_inst | Std.Http.Server.Connection | SizeOf Std.Http.Server.RemoteAddr | null | false |
HasLineDerivAt.le_of_lip' | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {v : E}
{f : E → F} {f' : F} {x₀ : E},
HasLineDerivAt 𝕜 f f' x₀ v → ∀ {C : ℝ}, 0 ≤ C → (∀ᶠ (x : E) in nhds x₀... | Converse to the mean value inequality: if `f` is line differentiable at `x₀` and `C`-lipschitz
on a neighborhood of `x₀` then its line derivative at `x₀` in the direction `v` has norm
bounded by `C * ‖v‖`. This version only assumes that `‖f x - f x₀‖ ≤ C * ‖x - x₀‖` in a
neighborhood of `x`. | true |
AlgebraicGeometry.Scheme.IdealSheafData.instCompleteLattice._proof_3 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (a b c : X.IdealSheafData), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c | null | false |
countableSupClosure_prod | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (s : Set α) (t : Set β),
countableSupClosure (s ×ˢ t) = countableSupClosure s ×ˢ countableSupClosure t | null | true |
Matrix.nnnorm_conjTranspose | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] [inst_3 : StarAddMonoid α] [NormedStarGroup α] (A : Matrix m n α),
‖A.conjTranspose‖₊ = ‖A‖₊ | null | true |
NumberField.mixedEmbedding.euclidean.toMixed | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | (K : Type u_1) →
[inst : Field K] →
[NumberField K] → NumberField.mixedEmbedding.euclidean.mixedSpace K ≃L[ℝ] NumberField.mixedEmbedding.mixedSpace K | The continuous linear equivalence between the Euclidean mixed space and the mixed space. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.