name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Functor.Faithful.of_comp_eq | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {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] {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D E} {H : CategoryTheory.Functor C E} [ℋ : H.Faithful], F.comp G = H → F.Fa... | null | true |
Lean.indentExpr | Lean.Message | Lean.Expr → Lean.MessageData | null | true |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor T D) (Y : D) (X : T)
{X_1 Y_1 : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X} (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.c... | null | false |
CompHausLike.instHasPropSigma | Mathlib.Topology.Category.CompHausLike.SigmaComparison | ∀ {P : TopCat → Prop} [CompHausLike.HasExplicitFiniteCoproducts P] {α : Type u} [Finite α] (σ : α → Type u)
[inst : (a : α) → TopologicalSpace (σ a)] [∀ (a : α), CompactSpace (σ a)] [∀ (a : α), T2Space (σ a)]
[∀ (a : α), CompHausLike.HasProp P (σ a)], CompHausLike.HasProp P ((a : α) × σ a) | null | true |
CategoryTheory.Limits.IsColimit.mono_ι_app_of_isFiltered | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Colim | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} J]
{X : CategoryTheory.Functor J C} [∀ (j j' : J) (φ : j ⟶ j'), CategoryTheory.Mono (X.map φ)]
{c : CategoryTheory.Limits.Cocone X} (hc : CategoryTheory.Limits.IsColimit c) [CategoryTheory.IsFiltered J]... | Assume that a functor `X : J ⥤ C` maps any morphism to a monomorphism,
that `J` is filtered. Then the "inclusion" map `c.ι.app j₀` of a colimit cocone for `X`
is a monomorphism if `colim : (Under j₀ ⥤ C) ⥤ C` preserves monomorphisms
(e.g. when `C` satisfies AB5). | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.synthInstanceCore?.match_3 | Lean.Meta.SynthInstance | (motive : Option (Option Lean.Meta.AbstractMVarsResult) → Sort u_1) →
(x : Option (Option Lean.Meta.AbstractMVarsResult)) →
((abstResult? : Option Lean.Meta.AbstractMVarsResult) → motive (some abstResult?)) → (Unit → motive none) → motive x | null | false |
GaloisInsertion.recOn | Mathlib.Order.GaloisConnection.Defs | {α : Type u_1} →
{β : Type u_2} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
{l : α → β} →
{u : β → α} →
{motive : GaloisInsertion l u → Sort u} →
(t : GaloisInsertion l u) →
((choice : (x : α) → u (l x) ≤ x → β) →
(gc : Galo... | null | false |
_private.Mathlib.MeasureTheory.Function.AEMeasurableSequence.0.aeSeq.measure_compl_aeSeqSet_eq_zero._simp_1_3 | Mathlib.MeasureTheory.Function.AEMeasurableSequence | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {ι : Sort u_4} [Countable ι] {p : α → ι → Prop},
(∀ (i : ι), ∀ᵐ (a : α) ∂μ, p a i) = ∀ᵐ (a : α) ∂μ, ∀ (i : ι), p a i | null | false |
MeasureTheory.NullMeasurableSet.diff._simp_1 | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s t : Set α},
MeasureTheory.NullMeasurableSet s μ →
MeasureTheory.NullMeasurableSet t μ → MeasureTheory.NullMeasurableSet (s \ t) μ = True | null | false |
ProbabilityTheory.condIndepFun_self_right | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {β : Type u_3} {β' : Type u_4} {mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {mβ : MeasurableSpace β}
{mβ' : MeasurableSpace β'} {X : Ω → β} {Z : Ω → β'},
Measurable X → ∀ (hZ : Measurable Z), ProbabilityTheory.Cond... | null | true |
CategoryTheory.PreOneHypercover.map_id | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} (E : CategoryTheory.PreOneHypercover X),
E.map (CategoryTheory.Functor.id C) = E | null | true |
Int.add_one_tdiv_of_pos | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 < b → (a + 1).tdiv b = a.tdiv b + if 0 < a + 1 ∧ b ∣ a + 1 ∨ a < 0 ∧ b ∣ a then 1 else 0 | null | true |
Qq.Impl.stripDollars | Qq.Macro | Lean.Name → Lean.Name | null | true |
AlgEquiv.aut._proof_10 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(ϕ : A₁ ≃ₐ[R] A₁), ϕ.symm * ϕ = 1 | null | false |
_private.Init.Data.List.Find.0.List.findIdx_lt_length_of_exists._simp_1_2 | Init.Data.List.Find | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
CategoryTheory.Enriched.FunctorCategory.homEquiv._proof_7 | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u_6) [inst : CategoryTheory.Category.{u_5, u_6} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{C : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1}
[inst_3 : CategoryTheory.Category.{u_4, u_1} J] [inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C]
{F₁ F₂ : CategoryTheory.F... | null | false |
SummationFilter.tprod_symmetricIcc_eq_tprod_symmetricIco | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ {α : Type u_1} {f : ℤ → α} [inst : CommGroup α] [inst_1 : TopologicalSpace α] [ContinuousMul α] [T2Space α],
Multipliable f (SummationFilter.symmetricIcc ℤ) →
Filter.Tendsto (fun N => (f ↑N)⁻¹) Filter.atTop (nhds 1) →
∏'[SummationFilter.symmetricIco ℤ] (b : ℤ), f b = ∏'[SummationFilter.symmetricIcc ℤ] (b ... | null | true |
Std.DTreeMap.Internal.Impl.minKeyD_insert_le_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k : α} {v : β k} {fallback : α},
(compare ((Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.minKeyD fallback) k).isLE = true | null | true |
eventually_le_nhds | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α] {a b : α},
a < b → ∀ᶠ (x : α) in nhds a, x ≤ b | null | true |
IsArtinianRing.quotNilradicalEquivPi._proof_1 | Mathlib.RingTheory.Artinian.Module | ∀ (R : Type u_1) [inst : CommRing R], (nilradical R).IsTwoSided | null | false |
BoundedGENhdsClass.mk | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_7} [inst : Preorder α] [inst_1 : TopologicalSpace α],
(∀ (a : α), Filter.IsBounded (fun x1 x2 => x1 ≥ x2) (nhds a)) → BoundedGENhdsClass α | null | true |
AlgebraicGeometry.Scheme.instOverXPullbackCoverOverProp' | Mathlib.AlgebraicGeometry.Cover.Over | {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
(S : AlgebraicGeometry.Scheme) →
[inst : P.IsStableUnderBaseChange] →
[inst_1 : AlgebraicGeometry.Scheme.IsJointlySurjectivePreserving P] →
{X W : AlgebraicGeometry.Scheme} →
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeo... | null | true |
_private.Mathlib.Order.WithBot.0.WithBot.le_of_forall_lt_iff_le._simp_1_1 | Mathlib.Order.WithBot | ∀ {α : Type u_3} {inst : LT α} [self : NoMinOrder α] (a : α), (∃ b, b < a) = True | null | false |
AlgebraicGeometry.Scheme.PartialIso.trans_iso | Mathlib.AlgebraicGeometry.Birational.Birational | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X.PartialIso Y) (g : Y.PartialIso Z),
(f.trans g).iso =
(f.symm.restrictSource (f.target ⊓ g.source) ⋯ ⋯).iso.symm ≪≫
Y.isoOfEq ⋯ ≪≫
(AlgebraicGeometry.Scheme.Opens.isoOfLE ⋯).symm ≪≫
AlgebraicGeometry.Scheme.Hom.isoImage g.iso.hom
((... | null | true |
sdiff_sdiff_sdiff_cancel_right | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : GeneralizedBooleanAlgebra α], z ≤ y → (x \ z) \ (y \ z) = x \ y | null | true |
trdeg_add_eq | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ (R : Type u_1) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Nontrivial R]
{A : Type v} [inst_4 : CommRing A] [NoZeroDivisors A] [inst_6 : Algebra R A] [inst_7 : Algebra S A] [FaithfulSMul R S]
[FaithfulSMul S A] [IsScalarTower R S A], Algebra.trdeg R S + Algebra.trdeg S A = Algeb... | [Stacks Tag 030H](https://stacks.math.columbia.edu/tag/030H) | true |
Std.Internal.List.containsKey_filter_not_contains_iff | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ : List ((a : α) × β a)} {l₂ : List α}
{hl₁ : Std.Internal.List.DistinctKeys l₁} {k : α},
Std.Internal.List.containsKey k (List.filter (fun p => !l₂.contains p.fst) l₁) = true ↔
Std.Internal.List.containsKey k l₁ = true ∧ ¬l₂.contains k = true | null | true |
Polynomial.divByMonicHom_apply | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} [inst : CommRing R] (q p : Polynomial R), q.divByMonicHom p = p /ₘ q | null | true |
Lean.Core.CoreM.asTask' | Lean.Elab.Task | {α : Type} → Lean.CoreM α → Lean.CoreM (Task (Lean.CoreM α)) | Given a monadic value in `CoreM`, creates a task that runs it in the current state,
returning a monadic value with the cached result (and subsequent state as it was after running).
| true |
_private.Mathlib.Tactic.Inclusion.ExtensionAPI.Attr.0.Inclusion.validateInclusionParamDecl.match_1 | Mathlib.Tactic.Inclusion.ExtensionAPI.Attr | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → ((value : Lean.Expr) → motive (some value)) → ((x : Option Lean.Expr) → motive x) → motive x | null | false |
Std.Time.Format.parse | Std.Time.Format.Basic | {f : Type} →
{typ : Type → f → Type} →
[self : Std.Time.Format f typ] → {α : Type} → (fmt : f) → typ (Option α) fmt → String → Except String α | Parses a string into a format using the provided format type `f`.
| true |
_private.Mathlib.Data.Fin.Tuple.Basic.0.Fin.sigma_eq_iff_eq_comp_cast.match_1_1 | Mathlib.Data.Fin.Tuple.Basic | ∀ {α : Type u_1} {a b : (ii : ℕ) × (Fin ii → α)} (motive : (∃ (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h) → Prop)
(x : ∃ (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h),
(∀ (w : a.fst = b.fst) (h' : a.snd = b.snd ∘ Fin.cast w), motive ⋯) → motive x | null | false |
Lean.Meta.mkImpCongr | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | null | true |
Lake.BuildTrace.brecOn_1.go | Lake.Build.Trace | {motive_1 : Lake.BuildTrace → Sort u} →
{motive_2 : Array Lake.BuildTrace → Sort u} →
{motive_3 : List Lake.BuildTrace → Sort u} →
(t : Array Lake.BuildTrace) →
((t : Lake.BuildTrace) → t.below → motive_1 t) →
((t : Array Lake.BuildTrace) → Lake.BuildTrace.below_1 t → motive_2 t) →
... | null | true |
Polynomial.instNatCast | Mathlib.Algebra.Polynomial.Basic | {R : Type u} → [inst : Semiring R] → NatCast (Polynomial R) | null | true |
Equiv.symm_bijective | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v}, Function.Bijective Equiv.symm | null | true |
CategoryTheory.Limits.MonoCoprod.isColimitBinaryCofanSum._proof_2 | Mathlib.CategoryTheory.Limits.MonoCoprod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I₁ : Type u_3} {I₂ : Type u_4} {X : I₁ ⊕ I₂ → C}
(c : CategoryTheory.Limits.Cofan X) (c₁ : CategoryTheory.Limits.Cofan (X ∘ Sum.inl))
(c₂ : CategoryTheory.Limits.Cofan (X ∘ Sum.inr)) (hc : CategoryTheory.Limits.IsColimit c)
(hc₁ : CategoryTheory.Limi... | null | false |
String.toList_split_char | Init.Data.String.Lemmas.Pattern.Split.Char | ∀ {s : String} {c : Char},
List.map String.Slice.copy (s.split c).toList = List.map String.ofList (List.splitOn c s.toList) | null | true |
Nat.toList_roc_eq_if | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m<...=n).toList = if m + 1 ≤ n then (m + 1) :: (m + 1<...=n).toList else [] | null | true |
MonoidAlgebra.coeff_mul_mul_of_uniqueMul | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {R : Type u_1} {A : Type u_2} [inst : Semiring R] [inst_1 : Mul A] {f g : MonoidAlgebra R A} {a0 b0 : A},
UniqueMul f.coeff.support g.coeff.support a0 b0 → (f * g).coeff (a0 * b0) = f.coeff a0 * g.coeff b0 | The coefficient of a monomial in a product `f * g` that can be reached in at most one way
as a product of monomials in the supports of `f` and `g` is a product. | true |
AlgebraicGeometry.AffineTargetMorphismProperty.IsLocal.mk._flat_ctor | Mathlib.AlgebraicGeometry.Morphisms.Basic | ∀ {P : AlgebraicGeometry.AffineTargetMorphismProperty},
P.toProperty.RespectsIso →
(∀ {X Y : AlgebraicGeometry.Scheme} [inst : AlgebraicGeometry.IsAffine Y] (f : X ⟶ Y)
(r : ↑(Y.presheaf.obj (Opposite.op ⊤))), P f → P (f ∣_ Y.basicOpen r)) →
(∀ {X Y : AlgebraicGeometry.Scheme} [inst : AlgebraicGeome... | null | false |
FirstOrder.Language.LHom.casesOn | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} →
{L' : FirstOrder.Language} →
{motive : (L →ᴸ L') → Sort u_1} →
(t : L →ᴸ L') →
((onFunction : ⦃n : ℕ⦄ → L.Functions n → L'.Functions n) →
(onRelation : ⦃n : ℕ⦄ → L.Relations n → L'.Relations n) →
motive { onFunction := onFunction, onRelation := o... | null | false |
_private.Mathlib.Order.PropInstances.0.Pi.eq_bot_iff_irrefl_of_subsingleton._simp_1_1 | Mathlib.Order.PropInstances | ∀ {α : Sort u_1} (r : α → α → Prop) [Std.Irrefl r] [Subsingleton α] (x y : α), r x y = False | null | false |
hasFPowerSeriesOnBall_pi_iff | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_9} [inst_3 : Fintype ι] {e : E} {Fm : ι → Type u_10}
[inst_4 : (i : ι) → NormedAddCommGroup (Fm i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (Fm i)] {f : (i : ι) → E → Fm i}
{r : ... | null | true |
Module.comap_annihilator | Mathlib.RingTheory.Ideal.Maps | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {R₀ : Type u_4}
[inst_3 : CommSemiring R₀] [inst_4 : Module R₀ M] [inst_5 : Algebra R₀ R] [IsScalarTower R₀ R M],
Ideal.comap (algebraMap R₀ R) (Module.annihilator R M) = Module.annihilator R₀ M | null | true |
Lean.Elab.Tactic.Doc.TacticDoc.docString | Lean.Elab.Tactic.Doc | Lean.Elab.Tactic.Doc.TacticDoc → Option String | The docstring for the tactic | true |
Set.mul_sInter_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_1} [inst : Mul α] (s : Set α) (T : Set (Set α)), s * ⋂₀ T ⊆ ⋂ t ∈ T, s * t | null | true |
Lean.ConstantKind.ctor.elim | Lean.Environment | {motive : Lean.ConstantKind → Sort u} →
(t : Lean.ConstantKind) → t.ctorIdx = 6 → motive Lean.ConstantKind.ctor → motive t | null | false |
Subgroup.IsSubnormal.brecOn | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {motive : (a : Subgroup G) → a.IsSubnormal → Prop} {a : Subgroup G}
(t : a.IsSubnormal), (∀ (a : Subgroup G) (t : a.IsSubnormal), Subgroup.IsSubnormal.below t → motive a t) → motive a t | null | true |
IsDedekindDomain.HeightOneSpectrum.intValuation_le_pow_iff_dvd | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R)
(n : ℕ), v.intValuation r ≤ WithZero.exp (-↑n) ↔ v.asIdeal ^ n ∣ Ideal.span {r} | The `v`-adic valuation of `r : R` is less than `WithZero.exp (-n)` if and only if
`vⁿ` divides the ideal `(r)`. | true |
Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [inst : BEq α] [Std.LawfulBEqOrd α]
[Std.TransOrd α] [inst_3 : Inhabited α] (h : t.WF) {l : List α} {k : α},
k ∉ t → l.contains k = false → (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)).getKey! k = default | null | true |
MulOpposite.unop_inj | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} {x y : αᵐᵒᵖ}, MulOpposite.unop x = MulOpposite.unop y ↔ x = y | null | true |
SimpleGraph.Walk.IsPath.transfer | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {H : SimpleGraph V} {p : G.Walk u v} (h : ∀ e ∈ p.edges, e ∈ H.edgeSet),
p.IsPath → (p.transfer H h).IsPath | **Alias** of the reverse direction of `SimpleGraph.Walk.isPath_transfer`. | true |
Complex.UnitClosedDisc.instMonoidWithZero._aux_8 | Mathlib.Analysis.Complex.UnitDisc.Basic | ℕ → Complex.UnitClosedDisc → Complex.UnitClosedDisc | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic.0.Mathlib.Meta.Positivity.evalRealPi.match_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(_zα : Q(Zero «$α»)) →
Option Q(PartialOrder «$α») →
(e : Q(«$α»)) →
(val : Q(PartialOrder «$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness _zα e (some val)) →
Lean.MetaM (Mathli... | null | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.LFunction.0.ArithmeticFunction.tendsTo_eulerProduct_ofPowerSeries._proof_1_3 | Mathlib.NumberTheory.ArithmeticFunction.LFunction | ∀ {ι : Type u_1} (q : ι → ℕ) (i : ι) (n : ℕ), n + 1 + 1 + 1 ≤ q i → ∀ (k : ℕ), q i ^ k = n + 1 + 1 → k ≠ 0 → False | null | false |
HahnSeries.instNonUnitalCommSemiring | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : PartialOrder Γ] →
[IsOrderedCancelAddMonoid Γ] → [inst : NonUnitalCommSemiring R] → NonUnitalCommSemiring (HahnSeries Γ R) | null | true |
CategoryTheory.leftAdjointMate | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : C} →
[inst_2 : CategoryTheory.HasLeftDual X] → [inst_3 : CategoryTheory.HasLeftDual Y] → (X ⟶ Y) → (ᘁY ⟶ ᘁX) | The left adjoint mate `ᘁf : ᘁY ⟶ ᘁX` of a morphism `f : X ⟶ Y`. | true |
BitVec.reduceNe | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | Simplification procedure for `≠` on `BitVec`s. | true |
LightCondensed.locallyConstantIsoFinYoneda | Mathlib.Condensed.Discrete.Colimit | (F : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)) →
FintypeCat.toLightProfinite.op.comp
(LightCondensed.locallyConstantPresheaf
(F.obj (FintypeCat.toLightProfinite.op.obj (Opposite.op ↧PUnit.{u + 1})))) ≅
LightCondensed.finYoneda F | `locallyConstantPresheaf` restricted to finite sets is isomorphic to `finYoneda F`. | true |
singleton_mul_sphere | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (δ : ℝ) (x y : E), {x} * Metric.sphere y δ = Metric.sphere (x * y) δ | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Projection.Minimal.0.exists_norm_eq_iInf_of_complete_convex._abel_1_1 | Mathlib.Analysis.InnerProductSpace.Projection.Minimal | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] {K : Set F} (u : F) (w : ℕ → ↑K) (p q : ℕ),
u + u - (↑(w q) + ↑(w p)) = u - ↑(w q) + (u - ↑(w p)) | null | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasSum_sum_support_of_ne_finset_zero._proof_1_4 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_2} {β : Type u_1} {L : SummationFilter β} {f : β → α} {s : Finset β}
[inst : DecidablePred fun x => x ∈ L.support] (t : Finset β), ∀ a ∈ t, a ∈ (↑s ∩ L.support).toFinset → f a = f a | null | false |
QuotientGroup.quotientQuotientIsometryEquivQuotient.eq_1 | Mathlib.Analysis.Normed.Group.Quotient | ∀ {M : Type u_1} [inst : SeminormedCommGroup M] {S T : Subgroup M} (h : S ≤ T),
QuotientGroup.quotientQuotientIsometryEquivQuotient h =
{ toEquiv := (QuotientGroup.quotientQuotientEquivQuotient S T h).toEquiv, isometry_toFun := ⋯ } | null | true |
finAddFlip.eq_1 | Mathlib.Logic.Equiv.Fin.Basic | ∀ {m n : ℕ}, finAddFlip = (finSumFinEquiv.symm.trans (Equiv.sumComm (Fin m) (Fin n))).trans finSumFinEquiv | null | true |
Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (lhs n lhs_1 n_1 : ℕ),
(Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt lhs n = Lean.Meta.Grind.EMatchTheoremConstraint.sizeLt lhs_1 n_1) =
(lhs = lhs_1 ∧ n = n_1) | null | true |
LinearEquiv.conj_exact_iff_exact | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {N' : Type u_5} {P : Type u_6} [inst : Semiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid N'] [inst_4 : AddCommMonoid P]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R N'] [inst_8 : Module R P] (f : M →ₗ[R] N)
(g... | null | true |
_private.Std.Http.Data.URI.Encoding.0.Std.Http.URI.EncodedQueryString.push | Std.Http.Data.URI.Encoding | {r : UInt8 → Bool} →
Std.Http.URI.EncodedQueryString r →
(c : UInt8) → Std.Http.URI.isEncodedQueryChar r c = true → Std.Http.URI.EncodedQueryString r | Appends a single encoded query character to an encoded query string.
| true |
RootPairing.GeckConstruction.equivRootSystem._proof_13 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basis | ∀ {K : Type u_1} [inst : Field K] [inst_1 : CharZero K] {ι : Type u_2} {M : Type u_3} {N : Type u_4}
[inst_2 : Fintype ι] [inst_3 : DecidableEq ι] [inst_4 : AddCommGroup M] [inst_5 : Module K M]
[inst_6 : AddCommGroup N] [inst_7 : Module K N] {P : RootPairing ι K M N} [inst_8 : P.IsReduced]
[inst_9 : P.IsCrystall... | null | false |
AffineMap.lineMap_eq_right_iff | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1]
[inst_3 : AddTorsor V1 P1] [IsDomain k] [Module.IsTorsionFree k V1] {p₀ p₁ : P1} {c : k},
(AffineMap.lineMap p₀ p₁) c = p₁ ↔ p₀ = p₁ ∨ c = 1 | null | true |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.compileToSimpleGroundExpr.compileNonFinalLet._sparseCasesOn_23 | Lean.Compiler.LCNF.SimpleGroundExpr | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.Arg pu → Sort u} →
(t : Lean.Compiler.LCNF.Arg pu) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.List.Basic.0.List.getLast_append_of_right_ne_nil._proof_1_12 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (l₂ : List α) (head : α) (tail : List α),
(head :: tail ++ l₂).length - 1 + 1 ≤ (head :: tail).length → (head :: tail ++ l₂).length - 1 < (head :: tail).length | null | false |
NumberField.FinitePlace.mk._proof_1 | Mathlib.NumberTheory.NumberField.Completion.FinitePlace | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
(v : IsDedekindDomain.HeightOneSpectrum (NumberField.RingOfIntegers K)),
∃ v_1,
NumberField.place (NumberField.FinitePlace.embedding v_1) = NumberField.place (NumberField.FinitePlace.embedding v) | null | false |
_private.Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.LeviCivita.0.CovariantDerivative.leviCivitaAuxOfMDiffAt._proof_9 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.LeviCivita | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
(I : ModelWithCorners ℝ E H) {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[IsManifold I 2 M] [inst_6 : Bundle.RiemannianBundle fun x => TangentSpace I x] {x : M} [Finite... | null | false |
Std.ExtDTreeMap.getKeyD_maxKey? | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{km fallback : α}, t.maxKey? = some km → t.getKeyD km fallback = km | null | true |
interior_inter | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, interior (s ∩ t) = interior s ∩ interior t | null | true |
NumberField.IsCMField.of_forall_isConj | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_2) [inst : Field K] [inst_1 : CharZero K] [Algebra.IsIntegral ℚ K] [NumberField.IsTotallyComplex K]
[IsGalois ℚ K] {σ : Gal(K/ℚ)}, (∀ (φ : K →+* ℂ), NumberField.ComplexEmbedding.IsConj φ σ) → NumberField.IsCMField K | A totally complex field that has a unique complex conjugation is CM.
| true |
SymmetricPower.Rel.recOn | Mathlib.LinearAlgebra.TensorPower.Symmetric | ∀ {R ι : Type u} [inst : CommSemiring R] {M : Type v} [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{motive : (a a_1 : PiTensorProduct R fun x => M) → SymmetricPower.Rel R ι M a a_1 → Prop}
{a a_1 : PiTensorProduct R fun x => M} (t : SymmetricPower.Rel R ι M a a_1),
(∀ (e : Equiv.Perm ι) (f : ι → M),
mot... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Decomp.0.SimpleGraph.Walk.takeUntil.match_1.splitter | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | {V : Type u_1} →
{G : SimpleGraph V} →
{v : V} →
(motive : (w : V) → (x : G.Walk v w) → (x_1 : V) → x_1 ∈ x.support → Sort u_2) →
(w : V) →
(x : G.Walk v w) →
(x_1 : V) →
(x_2 : x_1 ∈ x.support) →
((u : V) → (h : u ∈ SimpleGraph.Walk.nil.support) →... | null | true |
_private.Lean.Parser.Extension.0.Lean.Parser.isParserAlias.match_1 | Lean.Parser.Extension | (motive : Option (Lean.Parser.AliasValue Lean.Parser.Parser) → Sort u_1) →
(__do_lift : Option (Lean.Parser.AliasValue Lean.Parser.Parser)) →
((val : Lean.Parser.AliasValue Lean.Parser.Parser) → motive (some val)) →
((x : Option (Lean.Parser.AliasValue Lean.Parser.Parser)) → motive x) → motive __do_lift | null | false |
CategoryTheory.Bicategory.InducedBicategory.Hom₂.rec | Mathlib.CategoryTheory.Bicategory.InducedBicategory | {B : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Bicategory C] →
{F : B → C} →
{X Y : CategoryTheory.Bicategory.InducedBicategory C F} →
{f g : X ⟶ Y} →
{motive : CategoryTheory.Bicategory.InducedBicategory.Hom₂ f g → Sort u} →
((hom : f.hom ⟶ g.hom) → mot... | null | false |
Std.Packages.LinearOrderOfOrdArgs.max_eq._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | null | false |
IsLocallyConstant.apply_eq_of_preconnectedSpace | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X → Y},
IsLocallyConstant f → ∀ (x y : X), f x = f y | null | true |
_private.Mathlib.Data.ENat.Basic.0.ENat.top_ne_one.match_1_1 | Mathlib.Data.ENat.Basic | ∀ (motive : ⊤ = 1 → Prop) (a : ⊤ = 1), motive a | null | false |
Set.powersetCard.compl.congr_simp | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] [inst_1 : Fintype α] {m : ℕ} (hm : m + n = Fintype.card α),
Set.powersetCard.compl hm = Set.powersetCard.compl hm | null | true |
Module.Relations.Solution.ofπ'._proof_1 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u_2} [inst : Ring A] {relations : Module.Relations A} {M : Type u_1} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (π : (relations.G →₀ A) →ₗ[A] M),
π ∘ₗ relations.map = 0 → ∀ (r : relations.R), π (relations.relation r) = 0 | null | false |
_private.Mathlib.GroupTheory.RegularWreathProduct.0.RegularWreathProduct.instFaithfulSMulProdOfNonempty._simp_5 | Mathlib.GroupTheory.RegularWreathProduct | ∀ {G : Type u_1} [inst : DivInvMonoid G] (x : G), x⁻¹ = x ^ (-1) | null | false |
_private.Mathlib.Algebra.BigOperators.Expect.0.Finset.expect_ite_mem._simp_1_2 | Mathlib.Algebra.BigOperators.Expect | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b / a = a⁻¹ * b | null | false |
Inclusion.IExpr.ctorIdx | Mathlib.Tactic.Inclusion.Core.Types | Inclusion.IExpr → ℕ | null | false |
CategoryTheory.Preadditive.instCategoryRightFreyd._proof_8 | Mathlib.CategoryTheory.Preadditive.FreydCategory.RightFreyd | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V],
autoParam
(∀ {X Y : CategoryTheory.Preadditive.RightFreyd V} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
CategoryTheory.hoFunctor.isIso_prodComparison | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ (X Y : SSet), CategoryTheory.IsIso (CategoryTheory.Limits.prodComparison SSet.hoFunctor X Y) | null | true |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.posFittingComp_map_incl_sup_of_codisjoint._simp_1_2 | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [IsNoetherian R M] [IsArtinian R M],
LieModule.posFittingComp R... | null | false |
LinearMap.isWeak_iff | Mathlib.Topology.Algebra.Module.IsWeak | ∀ {𝕜 : Type u_2} {E : Type u_3} {F : Type u_4} [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜]
[inst_2 : AddCommMonoid E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommMonoid F] [inst_5 : Module 𝕜 F]
[t : TopologicalSpace E] (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜),
B.IsWeak ↔ t = TopologicalSpace.induced (fun x1 x2 => (B ... | null | true |
ValuationSubring.integer_valuation | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] (A : ValuationSubring K), A.valuation.integer = A.toSubring | null | true |
ContinuousLinearMap.precompCompactConvergenceCLM._proof_1 | Mathlib.Topology.Algebra.Module.Spaces.CompactConvergenceCLM | ∀ {𝕜₁ : Type u_3} {𝕜₂ : Type u_4} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_1}
{F : Type u_2} [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜₂ F]
[inst_6 : TopologicalSpace E] [inst_7 : TopologicalSpace F] (L : E →SL[σ] F),
... | null | false |
UsesSetNotationForOrder.ctorIdx | Mathlib.Tactic.SetNotationForOrder | {α : Type u_1} → UsesSetNotationForOrder α → ℕ | null | false |
CategoryTheory.SimplicialObject.Homotopy.h_comp_σ_succ_of_lt_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(self : CategoryTheory.SimplicialObject.Homotopy f g) {n : ℕ} (i j : Fin (n + 1)),
j ≤ i →
∀ {Z : C} (h : Y.obj (Opposite.op { len := n + 1 + 1 }) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self... | null | true |
CircleDeg1Lift.lt_map_of_int_lt_translationNumber | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) {n : ℤ}, ↑n < f.translationNumber → ∀ (x : ℝ), x + ↑n < f x | null | true |
_private.Mathlib.Algebra.Homology.ShortComplex.Preadditive.0.CategoryTheory.ShortComplex.Homotopy.ext.match_1 | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_2} {inst : CategoryTheory.Category.{u_1, u_2} C} {inst_1 : CategoryTheory.Preadditive C}
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (motive : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ → Prop)
(h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
(∀ (h₀ : S₁.X₁ ⟶ S₂.X₁) (h₀_f : CategoryTh... | null | false |
Lean.Order.PartialOrder.noConfusion | Init.Internal.Order.Basic | {P : Sort u_1} →
{α : Sort u} →
{t : Lean.Order.PartialOrder α} →
{α' : Sort u} →
{t' : Lean.Order.PartialOrder α'} → α = α' → t ≍ t' → Lean.Order.PartialOrder.noConfusionType P t t' | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.