name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.uliftYonedaEquiv._proof_4 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {X : C}
{F : CategoryTheory.Functor Cᵒᵖ (Type (max u_2 u_1))} (x : F.obj (Opposite.op X)),
(fun τ =>
(CategoryTheory.ConcreteCategory.hom (τ.app (Opposite.op X)))
{ down := CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.op X... | null | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.add_factorial_succ_lt_factorial_add_succ._proof_1_3 | Mathlib.Data.Nat.Factorial.Basic | ∀ {i : ℕ} (n : ℕ), 2 ≤ i → i + n ≤ (i + n).factorial → 1 < (i + n).factorial | null | false |
AlgebraicGeometry.Scheme.openCoverOfIsOpenCover | Mathlib.AlgebraicGeometry.Restrict | {s : Type u_1} → (X : AlgebraicGeometry.Scheme) → (U : s → X.Opens) → TopologicalSpace.IsOpenCover U → X.OpenCover | If `U` is a family of open sets that covers `X`, then `X.restrict U` forms an `X.open_cover`. | true |
_private.Mathlib.RingTheory.Polynomial.GaussNorm.0.Polynomial.gaussNorm_zero_right._simp_1_4 | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] {s : Finset β} (H : s.Nonempty) (f : β → α) {a : α},
(s.sup' H f ≤ a) = ∀ b ∈ s, f b ≤ a | null | false |
CategoryTheory.ComposableArrows.homMk_app | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C n}
(app : (i : Fin (n + 1)) → F.obj i ⟶ G.obj i)
(w :
∀ (i : ℕ) (hi : i < n),
CategoryTheory.CategoryStruct.comp (F.map' i (i + 1) ⋯ hi) (app ⟨i + 1, ⋯⟩) =
CategoryTheory.CategoryStruct.... | null | true |
MulActionWithZero.rec | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
[inst : MonoidWithZero M₀] →
[inst_1 : Zero A] →
{motive : MulActionWithZero M₀ A → Sort u} →
([toMulAction : MulAction M₀ A] →
(smul_zero : ∀ (r : M₀), r • 0 = 0) →
(zero_smul : ∀ (m : A), 0 • m = 0) →
moti... | null | false |
AlgebraicGeometry.Scheme.homOfLE | Mathlib.AlgebraicGeometry.Restrict | (X : AlgebraicGeometry.Scheme) → {U V : X.Opens} → U ≤ V → (↑U ⟶ ↑V) | If `U ≤ V`, then `U` is also a subscheme of `V`. | true |
Std.TransCmp.eq_trans | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.eq → cmp a c = Ordering.eq | null | true |
Lean.Compiler.LCNF.LetValue._auto_15 | Lean.Compiler.LCNF.Basic | Lean.Syntax | null | false |
Lean.Parser.Tactic.vcAlt | Std.Tactic.Do.Syntax | Lean.ParserDescr | In induction alternative, which can have 1 or more cases on the left
and `_`, `?_`, or a tactic sequence after the `=>`.
| true |
ProbabilityTheory.uncenteredCovarianceBilinDual._proof_2 | Mathlib.Probability.Moments.CovarianceBilinDual | (1 + 1).AtLeastTwo | null | false |
CompactlySupportedContinuousMap.instAddMonoidOfContinuousAdd | Mathlib.Topology.ContinuousMap.CompactlySupported | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : AddMonoid β] → [ContinuousAdd β] → AddMonoid (CompactlySupportedContinuousMap α β) | null | true |
cfc_nnreal_mem | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Range | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : StarRing A] [inst_2 : Algebra ℝ A] [inst_3 : TopologicalSpace A]
[IsTopologicalRing A] [T2Space A] [inst_6 : PartialOrder A] [inst_7 : NonnegSpectrumClass ℝ A]
[inst_8 : StarOrderedRing A] [ContinuousStar A] [StarModule ℝ A] {𝕜 : Type u_2} [inst_11 : RCLike 𝕜]
[inst_12... | null | true |
Std.ge_refl | Mathlib.Order.RelClasses | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Std.Refl fun x1 x2 => x1 ≥ x2] (a : α), a ≤ a | A version of `Std.le_refl` that works with `Std.Refl (· ≥ ·)`.
This is needed for `to_dual` translations because `Std.le_refl` requires `Std.Refl (· ≤ ·)`,
but after translation `instReflLe` becomes `instReflGe : Std.Refl (· ≥ ·)`. | true |
_private.Mathlib.NumberTheory.Harmonic.ZetaAsymp.0.deriv_riemannZeta_eq_neg_inv_sub_sq_mul_add._simp_1_7 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
_private.Mathlib.Data.Matrix.Mul.0.Matrix.vecMulVec_eq_zero._simp_1_1 | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}, (M = N) = ∀ (i : m) (j : n), M i j = N i j | null | false |
AddMonoidAlgebra.map_mul | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {S : Type u_4} {M : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Add M] (f : R →+* S)
(x y : AddMonoidAlgebra R M),
AddMonoidAlgebra.map (↑f) (x * y) = AddMonoidAlgebra.map (↑f) x * AddMonoidAlgebra.map (↑f) y | null | true |
Std.HashMap.Raw.any_eq_true_iff_exists_mem_getElem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.any p = true ↔ ∃ a, ∃ (h : a ∈ m), p a m[a] = true) | null | true |
FinVec.sum._proof_1 | Mathlib.Data.Fin.Tuple.Reflection | NeZero (0 + 1) | null | false |
MeasureTheory.Measure.instCompleteSemilatticeInf._private_1 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {α : Type u_1} {mα : MeasurableSpace α} (x : Set (MeasureTheory.Measure α)),
sInf x ∈ lowerBounds x ∧ sInf x ∈ upperBounds (lowerBounds x) | null | false |
Asymptotics.isBigOWith_abs_left._simp_1 | Mathlib.Analysis.Asymptotics.Arith | ∀ {α : Type u_1} {F : Type u_3} [inst : Norm F] {c : ℝ} {g : α → F} {l : Filter α} {u : α → ℝ},
Asymptotics.IsBigOWith c l (fun x => |u x|) g = Asymptotics.IsBigOWith c l u g | null | false |
HahnSeries.embDomainRingHom | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : PartialOrder Γ] →
[inst_2 : IsOrderedCancelAddMonoid Γ] →
{Γ' : Type u_6} →
[inst_3 : AddCommMonoid Γ'] →
[inst_4 : PartialOrder Γ'] →
[inst_5 : IsOrderedCancelAddMonoid Γ'] →
... | Extending the domain of Hahn series is a ring homomorphism. | true |
_private.Init.Data.List.ToArray.0.List.zipWithMAux_toArray_succ._proof_1_4 | Init.Data.List.ToArray | ∀ {α : Type u_2} {β : Type u_1} (as : List α) (bs : List β) (i : ℕ), ¬i + 1 < bs.length → i < bs.length - 1 → False | null | false |
Lean.Meta.Grind.InjectiveInfo.mk | Lean.Meta.Tactic.Grind.Types | List Lean.Level → Lean.Expr → Lean.Expr → Lean.Expr → Option (Lean.Expr × Lean.Expr) → Lean.Meta.Grind.InjectiveInfo | null | true |
CategoryTheory.Cat.HasLimits.limitConeLift | Mathlib.CategoryTheory.Category.Cat.Limit | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CategoryTheory.Cat) →
(s : CategoryTheory.Limits.Cone F) → s.pt ⟶ CategoryTheory.Cat.HasLimits.limitConeX F | Auxiliary definition: the universal morphism to the proposed limit cone. | true |
DoubleQuot.quotLeftToQuotSup.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : CommRing R] (I J : Ideal R), DoubleQuot.quotLeftToQuotSup I J = Ideal.Quotient.factor ⋯ | null | true |
Std.ExtTreeMap.self_le_maxKeyD_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α}, (cmp k ((t.insert k v).maxKeyD fallback)).isLE = true | null | true |
eq_zero_of_zpow_eq_zero | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} {n : ℤ}, a ^ n = 0 → a = 0 | null | true |
CategoryTheory.NatIso.ofComponents'.congr_simp | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (app app_1 : (X : C) → F.obj X ≅ G.obj X) (e_app : app = app_1)
(naturality :
∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (... | null | true |
SubgroupClass.instZPow | Mathlib.Algebra.Group.Subgroup.Defs | {M : Type u_5} →
{S : Type u_6} → [inst : DivInvMonoid M] → [inst_1 : SetLike S M] → [SubgroupClass S M] → {H : S} → Pow ↥H ℤ | A subgroup of a group inherits an integer power. | true |
CategoryTheory.CatEnriched.instCategory | Mathlib.CategoryTheory.Bicategory.CatEnriched | {C : Type u_1} →
[CategoryTheory.EnrichedCategory CategoryTheory.Cat C] →
CategoryTheory.Category.{u_2, u_1} (CategoryTheory.CatEnriched C) | The action on objects of the `EnrichedCategory Cat` coherences proves the category axioms. | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop.0.Std.IterM.first?.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] [inst_2 : Std.IteratorLoop α m m]
(it : Std.IterM m β),
it.first? =
Std.IteratorLoop.forIn (fun x x_1 => flip bind) (Option β) (fun b x s => s = ForInStep.done (some b)) it none
fun b x x_1 => pure ⟨ForInStep.done (some... | null | true |
Classical.some_spec₂ | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_2} {p : α → Prop} {h : ∃ a, p a} (q : α → Prop), (∀ (a : α), p a → q a) → q (Classical.choose h) | null | true |
intervalIntegral.integral_lt_integral_of_ae_le_of_measure_setOfPred_lt_ne_zero | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {f g : ℝ → ℝ} {a b : ℝ} {μ : MeasureTheory.Measure ℝ},
a ≤ b →
IntervalIntegrable f μ a b →
IntervalIntegrable g μ a b →
f ≤ᵐ[μ.restrict (Set.Ioc a b)] g →
(μ.restrict (Set.Ioc a b)) {x | f x < g x} ≠ 0 → ∫ (x : ℝ) in a..b, f x ∂μ < ∫ (x : ℝ) in a..b, g x ∂μ | If `f` and `g` are two functions that are interval integrable on `a..b`, `a ≤ b`,
`f x ≤ g x` for a.e. `x ∈ Set.Ioc a b`, and `f x < g x` on a subset of `Set.Ioc a b`
of nonzero measure, then `∫ x in a..b, f x ∂μ < ∫ x in a..b, g x ∂μ`. | true |
_private.Mathlib.SetTheory.Cardinal.Aleph.0.Cardinal.beth_add_one._simp_1_2 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
Mathlib.Meta.NormNum.NormNums.tree._default | Mathlib.Tactic.NormNum.Core | Lean.Meta.DiscrTree Mathlib.Meta.NormNum.NormNumExt | null | false |
PowerSeries.coeff_mul_eq_coeff_trunc_mul_trunc | Mathlib.RingTheory.PowerSeries.Trunc | ∀ {R : Type u_2} [inst : CommSemiring R] {d n : ℕ} (f g : PowerSeries R),
d < n →
(PowerSeries.coeff d) (f * g) = (PowerSeries.coeff d) (↑((PowerSeries.trunc n) f) * ↑((PowerSeries.trunc n) g)) | null | true |
_private.Mathlib.Lean.Meta.CongrTheorems.0.Lean.Meta.mkRichHCongr.trySolveCore | Mathlib.Lean.Meta.CongrTheorems | Lean.MVarId → Lean.MetaM Unit | Given a type that is a bunch of equalities implying a goal (for example, a basic
congruence lemma), prove it if possible. Basic congruence lemmas should be provable by this.
There are some extra tricks for handling arguments to richer congruence lemmas. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling.0.SimpleGraph.EdgeLabeling.labelGraph_adj._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} (x y : V),
G.Adj x y → Quot.mk (Sym2.Rel V) (x, y) ∈ (SimpleGraph.edgeSetEmbedding V) G | null | false |
String.Slice.le_offset_posGE._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : String.Pos.Raw} {h : p ≤ s.rawEndPos}, (p ≤ (s.posGE p h).offset) = True | null | false |
Lean.Meta.Sym.Simp.registerSymSimpAttr | Lean.Meta.Sym.Simp.Attr | Lean.Name →
String → autoParam Lean.Name Lean.Meta.Sym.Simp.registerSymSimpAttr._auto_1 → IO Lean.Meta.Sym.Simp.SymSimpExtension | Registers a named `Sym.Simp` theorem set. Each set gets its own attribute
and its own `SymSimpExtension` (persistent environment extension).
Must be called during initialization.
| true |
String.Pos.offset_sliceTo | Init.Data.String.Basic | ∀ {s : String} {p₀ pos : s.Pos} {h : pos ≤ p₀}, (p₀.sliceTo pos h).offset = pos.offset | null | true |
Finset.card_toRight_le | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {u : Finset (α ⊕ β)}, u.toRight.card ≤ u.card | null | true |
Associated | Mathlib.Algebra.GroupWithZero.Associated | {M : Type u_1} → [Monoid M] → M → M → Prop | Two elements of a `Monoid` are `Associated` if one of them is another one
multiplied by a unit on the right. | true |
_private.Mathlib.FieldTheory.PerfectClosure.0.PerfectClosure.mk_pow._simp_1_1 | Mathlib.FieldTheory.PerfectClosure | ∀ (R : Type u_1) [inst : CommSemiring R] (p n : ℕ) [inst_1 : ExpChar R p],
(⇑(frobenius R p))^[n] = ⇑(iterateFrobenius R p n) | null | false |
FirstOrder.Language.BoundedFormula.mapTermRelEquiv._proof_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u_6} {β : Type u_1}
(ft : (n : ℕ) → L.Term (α ⊕ Fin n) ≃ L'.Term (β ⊕ Fin n)) (fr : (n : ℕ) → L.Relations n ≃ L'.Relations n) {n : ℕ}
(φ : L'.BoundedFormula β n),
FirstOrder.Language.BoundedFormula.mapTermRel (fun n => ⇑(ft n)) (fun n => ⇑(fr n)) (f... | null | false |
CommRingCat.limitCommRing._proof_38 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections],
autoParam
(∀ (a b : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommRingCat))).pt)... | null | false |
DiffeologicalSpace.noConfusionType | Mathlib.Geometry.Diffeology.Basic | Sort u → {X : Type u_1} → DiffeologicalSpace X → {X' : Type u_1} → DiffeologicalSpace X' → Sort u | null | false |
_private.Mathlib.Analysis.Asymptotics.LinearGrowth.0.Monotone.le_linearGrowthSup_comp.match_1_1 | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {v : ℕ → ℕ} (a : EReal) (motive : a ∈ Set.Ioo 0 (LinearGrowth.linearGrowthInf fun n => ↑(v n)) → Prop)
(h : a ∈ Set.Ioo 0 (LinearGrowth.linearGrowthInf fun n => ↑(v n))),
(∀ (a_0 : 0 < a) (a_v : a < LinearGrowth.linearGrowthInf fun n => ↑(v n)), motive ⋯) → motive h | null | false |
Lean.Meta.whnfI | Lean.Meta.Basic | Lean.Expr → Lean.MetaM Lean.Expr | `whnf` with instances transparency. | true |
Lean.PrettyPrinter.Delaborator.SubExpr.withBoundedAppFnArgs._f | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} →
[Monad m] →
[MonadReaderOf Lean.SubExpr m] →
[MonadWithReaderOf Lean.SubExpr m] → m α → (α → m α) → (maxArgs : ℕ) → Nat.below maxArgs → m α | null | false |
_private.Init.Data.Int.Order.0.Int.nonneg_def.match_1_1 | Init.Data.Int.Order | ∀ (motive : (a : ℤ) → a.NonNeg → Prop) (a : ℤ) (x : a.NonNeg), (∀ (n : ℕ), motive (Int.ofNat n) ⋯) → motive a x | null | false |
cfcₙ_integral | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Integral | ∀ {X : Type u_1} {𝕜 : Type u_2} {A : Type u_3} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : MeasurableSpace X]
{μ : MeasureTheory.Measure X} [inst_2 : NonUnitalNormedRing A] [inst_3 : StarRing A] [inst_4 : NormedSpace 𝕜 A]
[inst_5 : IsScalarTower 𝕜 A A] [inst_6 : SMulCommClass 𝕜 A A] [inst_7 : NonUnitalContinuou... | The continuous functional calculus commutes with integration.
This version assumes joint continuity of `f`, see `cfcₙ_integral'` for a statement
with weaker assumptions. | true |
DirectSum.IsInternal.collectedOrthonormalBasis.congr_simp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] {A : ι → Submodule 𝕜 E}
(hV : OrthogonalFamily 𝕜 (fun i => ↥(A i)) fun i => (A i).subtypeₗᵢ) [inst_4 : DecidableEq ι]
(hV_sum : DirectSum.IsInternal fun i => ... | null | true |
SimpleGraph.Walk.exists_adj_adj_not_adj_ne | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} {p : G.Walk v w},
p.length = G.dist v w → 1 < G.dist v w → ∃ x a b, G.Adj x a ∧ G.Adj a b ∧ ¬G.Adj x b ∧ x ≠ b | This bundles and abstracts some facts about the first three vertices of a shortest walk
of length at least two: the first and third nodes are different and not connected. | true |
OrderHom.equivalenceFunctor._proof_2 | Mathlib.CategoryTheory.Category.Preorder | ∀ {X : Type u_1} {Y : Type u_2} [inst : Preorder X] [inst_1 : Preorder Y] (X_1 : X →o Y),
{ app := fun x => CategoryTheory.homOfLE ⋯, naturality := ⋯ } = CategoryTheory.CategoryStruct.id X_1.toFunctor | null | false |
Std.DHashMap.Const.get!_erase_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α}, Std.DHashMap.Const.get! (m.erase k) k = default | null | true |
CategoryTheory.Functor.IsCoverDense.Types.naturality | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {K : CategoryTheory.GrothendieckTopology D}
{G : CategoryTheory.Functor C D} {ℱ : CategoryTheory.Functor Dᵒᵖ (Type v)} {ℱ' : CategoryTheory.Sheaf K (Type v)}
(α : G.op.comp ℱ ⟶ G.op.comp ℱ... | null | true |
CategoryTheory.ShortComplex.RightHomologyData.p_g'_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) {Z : C} (h_1 : S.X₃ ⟶ Z),
CategoryTheory.CategoryStruct.comp h.p (CategoryTheory.CategoryStruct.comp h.g' h_1) =
CategoryTheory.Categor... | null | true |
RootPairing.Base.flip | Mathlib.LinearAlgebra.RootSystem.Base | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{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} → P.Base → P.flip.Base | Interchanging roots and coroots, one still has a base of a root pairing. | true |
CategoryTheory.LaxBraidedFunctor.forget_map | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.MonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D]
{X Y :
Categ... | null | true |
Aesop.Frontend.Feature.phase.sizeOf_spec | Aesop.Frontend.RuleExpr | ∀ (p : Aesop.PhaseName), sizeOf (Aesop.Frontend.Feature.phase p) = 1 + sizeOf p | null | true |
finrank_euclideanSpace | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype ι],
Module.finrank 𝕜 (EuclideanSpace 𝕜 ι) = Fintype.card ι | null | true |
HomotopicalAlgebra.PrepathObject.RightHomotopy.unop | Mathlib.AlgebraicTopology.ModelCategory.RightHomotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : Cᵒᵖ} →
{P : HomotopicalAlgebra.PrepathObject Y} → {f g : X ⟶ Y} → P.RightHomotopy f g → P.unop.LeftHomotopy f.unop g.unop | The left homotopy that is deduced from a right homotopy in the opposite category. | true |
String.Pos.sliceTo_le_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos} {h : q ≤ p₀},
p₀.sliceTo q h ≤ p ↔ q ≤ String.Pos.ofSliceTo p | null | true |
PresheafOfModulesOfCommRing.DifferentialsConstruction.derivation' | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | {D : Type u₂} →
[inst : CategoryTheory.Category.{v₂, u₂} D] →
{S' R : CategoryTheory.Functor Dᵒᵖ CommRingCat} →
(φ' : S' ⟶ R) → (PresheafOfModulesOfCommRing.DifferentialsConstruction.relativeDifferentials' φ').Derivation' φ' | The universal derivation. | true |
_private.Mathlib.MeasureTheory.Measure.CompleteLattice.0.MeasureTheory.Measure.lt_iff._simp_1_4 | Mathlib.MeasureTheory.Measure.CompleteLattice | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
SimpleGraph.Subgraph.neighborSet_sup | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph} (v : V),
(H ⊔ H').neighborSet v = H.neighborSet v ∪ H'.neighborSet v | null | true |
OrderMonoidIso.withZeroUnits | Mathlib.Algebra.Order.Hom.MonoidWithZero | {α : Type u_6} → [inst : LinearOrderedCommGroupWithZero α] → [DecidablePred fun a => a = 0] → WithZero αˣ ≃*o α | Any linearly ordered group with zero is isomorphic to adjoining `0` to the units of itself. | true |
AntivaryOn.add_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f₁ f₂ : ι → α} {g : ι → β},
AntivaryOn f₁ g s → AntivaryOn f₂ g s → AntivaryOn (f₁ + f₂) g s | null | true |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
not_finite_iff_infinite._simp_1 | Mathlib.Basic.Finite.Defs | ∀ {α : Sort u_1}, (¬Finite α) = Infinite α | null | false |
Affine.Simplex.sum_centroidWeightsWithCircumcenter | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {n : ℕ} {fs : Finset (Fin (n + 1))}, fs.Nonempty → ∑ i, Affine.Simplex.centroidWeightsWithCircumcenter fs i = 1 | `centroidWeightsWithCircumcenter` sums to 1, if the `Finset` is nonempty. | true |
Std.DHashMap.Const.getKey!_filterMap | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.DHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] [inst_2 : Inhabited α] {f : α → β → Option γ} {k : α},
(Std.DHashMap.filterMap f m).getKey! k =
((m.getKey? k).pfilter fun x_2 h' => (f x_2 (Std.DHashMap.Const.... | null | true |
Algebra.ofSubsemiring | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[Algebra R A] →
{C : Type u_4} → [inst_3 : SetLike C R] → [inst_4 : SubsemiringClass C R] → (S : C) → Algebra (↥S) A | Algebra over a subsemiring. This builds upon `Subsemiring.module`. | true |
CategoryTheory.Sheaf.ΓNatIsoCoyoneda | Mathlib.CategoryTheory.Sites.GlobalSections | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(X : Type (max u v)) →
[Unique X] →
CategoryTheory.Sheaf.Γ J (Type (max u v)) ≅
CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.constantSheaf J (Type (max u v))).o... | For sheaves of types, the global sections functor is isomorphic to the covariant hom
functor of the terminal sheaf. | true |
NormedField.valuation | Mathlib.Topology.Algebra.Valued.NormedValued | {K : Type u_1} → [hK : NormedField K] → [IsUltrametricDist K] → Valuation K NNReal | The valuation on a nonarchimedean normed field `K` defined as `nnnorm`. | true |
Std.DTreeMap.getKey_union_of_not_mem_right | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α} (not_mem : k ∉ t₂) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).getKey k h' = t₁.getKey k ⋯ | null | true |
CompactlyCoherentSpace.isCoherentWith | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {X : Type u_1} {inst : TopologicalSpace X} [self : CompactlyCoherentSpace X],
Topology.IsCoherentWith {K | IsCompact K} | A space is a compactly coherent space if the topology is generated by the compact sets. | true |
ValuedCSP.Term.mk.sizeOf_spec | Mathlib.Combinatorics.Optimization.ValuedCSP | ∀ {D : Type u_1} {C : Type u_2} [inst : AddCommMonoid C] [inst_1 : PartialOrder C] [inst_2 : IsOrderedAddMonoid C]
{Γ : ValuedCSP D C} {ι : Type u_3} [inst_3 : SizeOf D] [inst_4 : SizeOf C]
[inst_5 : (a : (n : ℕ) × ((Fin n → D) → C)) → SizeOf (Γ a)] [inst_6 : SizeOf ι] (n : ℕ) (f : (Fin n → D) → C)
(inΓ : ⟨n, f⟩ ... | null | true |
CategoryTheory.Functor.CoconeTypes.precompose | Mathlib.CategoryTheory.Limits.Types.ColimitType | {J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] →
{F : CategoryTheory.Functor J (Type w₀)} →
F.CoconeTypes →
{G : CategoryTheory.Functor J (Type w₀')} →
(app : (j : J) → G.obj j → F.obj j) →
(∀ {j j' : J} (f : j ⟶ j'),
app j' ∘ ⇑(CategoryTheory.Concrete... | The cocone for `G : J ⥤ Type w₀'` that is deduced from a cocone for `F : J ⥤ Type w₀`
and a natural map `G.obj j → F.obj j` for all `j : J`. | true |
IsAdjoinRoot.mk.congr_simp | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {f : Polynomial R}
(map map_1 : Polynomial R →ₐ[R] S) (e_map : map = map_1) (map_surjective : Function.Surjective ⇑map)
(ker_map : RingHom.ker map = Ideal.span {f}),
{ map := map, map_surjective := map_surjective, ker... | null | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_sub_succ._simp_1_4 | Init.Data.Nat.Bitwise.Lemmas | ∀ {a b : ℕ}, (a.succ < b.succ) = (a < b) | null | false |
String.Pos.revSkipWhile_bool_eq_self_iff_get | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {p : Char → Bool} {s : String} {pos : s.Pos},
pos.revSkipWhile p = pos ↔ ∀ (h : pos ≠ s.startPos), p ((pos.prev h).get ⋯) = false | null | true |
Ordnode.Valid'.balanceR_aux | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {l : Ordnode α} {x : α} {r : Ordnode α} {o₁ : WithBot α} {o₂ : WithTop α},
Ordnode.Valid' o₁ l ↑x →
Ordnode.Valid' (↑x) r o₂ →
(r.size = 0 → l.size ≤ 1) →
(1 ≤ r.size → 1 ≤ l.size → l.size ≤ Ordnode.delta * r.size) →
2 * r.size ≤ 9 * l.size + 5 ∨ r.size... | null | true |
WeakBilin.instAddCommMonoid._aux_1 | Mathlib.Topology.Algebra.Module.Spaces.WeakBilin | {𝕜 : Type u_2} →
{E : Type u_1} →
{F : Type u_3} →
[inst : CommSemiring 𝕜] →
[inst_1 : AddCommMonoid E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : AddCommMonoid F] → [inst_4 : Module 𝕜 F] → (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) → Zero (WeakBilin B) | null | false |
Std.WP.ReaderT.instWPMonad | Std.WP.Monad.Instances | {m : Type u → Type z} →
{EPred : Type u_1} →
{ρ : Type u} →
{Pred : Type v} →
[inst : Monad m] →
[inst_1 : Std.WP.Assertion Pred] →
[inst_2 : Std.WP.Assertion EPred] →
[Std.WP.WPMonad m Pred EPred] → Std.WP.WPMonad (ReaderT ρ m) (ρ → Pred) EPred | `ReaderT` lifts a `WPMonad` instance by adding a reader argument. | true |
IsPrimitiveRoot.integralPowerBasis.eq_1 | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {n : ℕ} {K : Type u} [inst : Field K] {ζ : K} [inst_1 : NeZero n] [inst_2 : CharZero K]
[inst_3 : IsCyclotomicExtension {n} ℚ K] (hζ : IsPrimitiveRoot ζ n),
hζ.integralPowerBasis = (Algebra.adjoin.powerBasis' ⋯).map hζ.adjoinEquivRingOfIntegers | null | true |
Localization.localAlgHom_apply | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_2} [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {P : Type u_3}
[inst_3 : CommSemiring P] [inst_4 : Algebra R P] (I : Ideal S) [inst_5 : I.IsPrime] (J : Ideal P) [inst_6 : J.IsPrime]
(f : S →ₐ[R] P) (hIJ : I = Ideal.comap f J) (x : Localization.AtPrime I),
(... | null | true |
Aesop.RuleTac.ForwardM.State.ctorIdx | Aesop.RuleTac.Forward | Aesop.RuleTac.ForwardM.State → ℕ | null | false |
CategoryTheory.typeEquiv_functor_obj_obj_map_hom_apply_hom_apply | Mathlib.CategoryTheory.Sites.Types | ∀ (α : Type u) {X Y : Type uᵒᵖ} (f : X ⟶ Y) (g : Opposite.unop X ⟶ α) (a : Opposite.unop Y),
(CategoryTheory.ConcreteCategory.hom
((CategoryTheory.ConcreteCategory.hom ((CategoryTheory.typeEquiv.functor.obj α).obj.map f)) g))
a =
g.hom' (f.unop.hom' a) | null | true |
Polynomial.Chebyshev.T_neg_two | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R], Polynomial.Chebyshev.T R (-2) = 2 * Polynomial.X ^ 2 - 1 | null | true |
SimpleGraph.CompleteEquipartiteSubgraph.card_parts | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (self : G.CompleteEquipartiteSubgraph r t), self.parts.card = r ∨ t = 0 | There are `r` parts or `t = 0`. | true |
Aesop.instReprStrategy | Aesop.Options.Public | Repr Aesop.Strategy | null | true |
Std.DTreeMap.Internal.Impl.Equiv.beq_congr | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] [inst_1 : (k : α) → BEq (β k)] {m₃ m₄ : Std.DTreeMap.Internal.Impl α β},
m₁.WF → m₂.WF → m₃.WF → m₄.WF → m₁.Equiv m₃ → m₂.Equiv m₄ → m₁.beq m₂ = m₃.beq m₄ | null | true |
Lean.IR.Log.toString | Lean.Compiler.IR.CompilerM | Lean.IR.Log → String | null | true |
CategoryTheory.Adjunction.Quadruple._sizeOf_1 | Mathlib.CategoryTheory.Adjunction.Quadruple | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor D C} →
{G : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor D C} ... | null | false |
isBot_toDual_iff | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : LE α] {a : α}, IsBot (OrderDual.toDual a) ↔ IsTop a | null | true |
MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k),
(MvPolynomial.universalFactorizationMapPresentation R n m k hn).jacobiMatrix =
-((Matrix.reindex (finCongr ⋯) (finCongr ⋯))
((Polynomial.map
((MvPolynomial.mapAlgHom (Algebra.ofId R (MvPolynomial (Fin n) R))).comp
... | null | true |
Dist.mk | Mathlib.Topology.MetricSpace.Pseudo.Defs | {α : Type u_3} → (α → α → ℝ) → Dist α | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.