name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.List.Pairwise.0.List.Pairwise.imp.match_1_1 | Init.Data.List.Pairwise | ∀ {α : Type u_1} {R : α → α → Prop} (motive : (x : List α) → List.Pairwise R x → Prop) (x : List α)
(x_1 : List.Pairwise R x),
(∀ (_ : Unit), motive [] ⋯) →
(∀ (a : α) (l : List α) (h₁ : ∀ a' ∈ l, R a a') (h₂ : List.Pairwise R l), motive (a :: l) ⋯) → motive x x_1 | null | false |
Lean.Name.MatchUpToIndexSuffix.suffixMatch.elim | Batteries.Lean.Meta.UnusedNames | {motive : Lean.Name.MatchUpToIndexSuffix → Sort u} →
(t : Lean.Name.MatchUpToIndexSuffix) →
t.ctorIdx = 2 → ((i : ℕ) → motive (Lean.Name.MatchUpToIndexSuffix.suffixMatch i)) → motive t | null | false |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.encodingStepAux.match_5 | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) →
((n : Lean.Name) → (i : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj n i struct)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((mvarId : ... | null | false |
Stream'.Seq.update_cons_succ | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (f : α → α) (n : ℕ),
(Stream'.Seq.cons hd tl).update (n + 1) f = Stream'.Seq.cons hd (tl.update n f) | null | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs.0.EisensteinSeries.denom_aux | Mathlib.NumberTheory.ModularForms.EisensteinSeries.E2.Defs | ∀ (A B : Matrix.SpecialLinearGroup (Fin 2) ℤ) (z : UpperHalfPlane),
↑(↑(A * B) 1 0) *
UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) B)) ↑z =
↑(↑A 1 0) * ↑(↑B).det +
↑(↑B 1 0) *
UpperHalfPlane.denom
(Matrix.SpecialLinearGroup... | null | true |
Set.image_sub_const_uIcc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c : α),
(fun x => x - a) '' Set.uIcc b c = Set.uIcc (b - a) (c - a) | null | true |
LibraryNote.continuity_lemma_statement | Mathlib.Topology.Continuous | Batteries.Util.LibraryNote | The library contains many lemmas stating that functions/operations are continuous. There are many
ways to formulate the continuity of operations. Some are more convenient than others.
Note: for the most part this note also applies to other properties
(`Measurable`, `Differentiable`, `ContinuousOn`, ...).
### The tradi... | true |
FaithfulSMul.of_injective | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M' : Type u_1} {X : Type u_5} [inst : SMul M' X] {Y : Type u_6} [inst_1 : SMul M' Y] {F : Type u_8}
[inst_2 : FunLike F X Y] [FaithfulSMul M' X] [MulActionHomClass F M' X Y] (f : F),
Function.Injective ⇑f → FaithfulSMul M' Y | null | true |
szemeredi_regularity | Mathlib.Combinatorics.SimpleGraph.Regularity.Lemma | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] (G : SimpleGraph α) [inst_2 : DecidableRel G.Adj] {ε : ℝ}
{l : ℕ},
0 < ε →
l ≤ Fintype.card α →
∃ P, P.IsEquipartition ∧ l ≤ P.parts.card ∧ P.parts.card ≤ SzemerediRegularity.bound ε l ∧ P.IsUniform G ε | Effective **Szemerédi Regularity Lemma**: For any sufficiently large graph, there is an
`ε`-uniform equipartition of bounded size (where the bound does not depend on the graph). | true |
Vector.finIdxOf?_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} [inst : BEq α] {xs : Array α} (h : xs.size = n) (x : α),
(Vector.mk xs h).finIdxOf? x = Option.map (Fin.cast h) (xs.finIdxOf? x) | null | true |
Finset.toRight | Mathlib.Data.Finset.Sum | {α : Type u_1} → {β : Type u_2} → Finset (α ⊕ β) → Finset β | Given a finset of elements `α ⊕ β`, extract all the elements of the form `β`. This
forms a quasi-inverse to `disjSum`, in that it recovers its right input.
See also `List.partitionMap`.
| true |
AddSubmonoid.isAddCommutative_topologicalClosure | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] [inst_2 : SeparatelyContinuousAdd M] [T2Space M]
(s : AddSubmonoid M) [IsAddCommutative ↥s], IsAddCommutative ↥s.topologicalClosure | If a submonoid of an additive topological monoid is commutative, then so is its
topological closure. | true |
DirectedOn.le_of_minimal | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a b : α},
DirectedOn (fun x y => y ≤ x) s → Minimal (fun x => x ∈ s) a → b ∈ s → a ≤ b | null | true |
WittVector.instIsocrystalStandardOneDimIsocrystal._proof_2 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] [inst_2 : CharP k p]
[inst_3 : PerfectRing k p],
RingHomCompTriple (↑(WittVector.FractionRing.frobenius p k)) (RingHom.id (FractionRing (WittVector p k)))
↑(WittVector.FractionRing.frobenius p k) | null | false |
Sum.instLocallyFiniteOrder._proof_1 | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (a b x : α ⊕ β), x ∈ Finset.sumLift₂ Finset.Icc Finset.Icc a b ↔ a ≤ x ∧ x ≤ b | null | false |
CanonicallyOrderedAddCommMonoid.toAddCancelCommMonoid | Mathlib.Algebra.Order.Sub.Basic | (α : Type u_1) →
[inst : AddCommMonoid α] →
[inst_1 : PartialOrder α] → [inst_2 : Sub α] → [OrderedSub α] → [AddLeftReflectLE α] → AddCancelCommMonoid α | A `CanonicallyOrderedAddCommMonoid` with ordered subtraction and order-reflecting addition is
cancellative. This is not an instance as it would form a typeclass loop.
See note [reducible non-instances]. | true |
Submodule.rank_sup_add_rank_inf_eq | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_1} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_1} R] (s t : Submodule R M),
Module.rank R ↥(s ⊔ t) + Module.rank R ↥(s ⊓ t) = Module.rank R ↥s + Module.rank R ↥t | null | true |
comp_partialSups | Mathlib.Order.PartialSups | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β]
[inst_2 : Preorder ι] [inst_3 : LocallyFiniteOrderBot ι] {F : Type u_4} [inst_4 : FunLike F α β] [SupHomClass F α β]
(f : ι → α) (g : F), ⇑(partialSups (⇑g ∘ f)) = ⇑g ∘ ⇑(partialSups f) | null | true |
Module.End.UnifEigenvalues.val | Mathlib.LinearAlgebra.Eigenspace.Basic | {R : Type v} →
{M : Type w} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (f : Module.End R M) → (k : ℕ∞) → f.UnifEigenvalues k → R | The underlying value of a bundled eigenvalue. | true |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.thickening_eq_empty_iff._simp_1_1 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {ε : ℝ} {s : Set α}, 0 < ε → (Metric.thickening ε s = ∅) = (s = ∅) | null | false |
CategoryTheory.GradedObject.mapBifunctorLeftUnitor_naturality | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {C : Type u_1} {D : Type u_2} {I : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : Zero I] [inst_3 : DecidableEq I]
[inst_4 : CategoryTheory.Limits.HasInitial C] (F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) (X : C)
(... | null | true |
Finset.addConst_neg_left | Mathlib.Combinatorics.Additive.DoublingConst | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : DecidableEq G] (A B : Finset G), (-A).addConst B = A.subConst B | null | true |
AddMonoidAlgebra.coeff_divOf | Mathlib.Algebra.MonoidAlgebra.Division | ∀ {k : Type u_1} {G : Type u_2} [inst : Semiring k] [inst_1 : AddCommMonoid G] [inst_2 : IsCancelAdd G] (g : G)
(x : AddMonoidAlgebra k G) (g' : G), (x.divOf g).coeff g' = x.coeff (g + g') | null | true |
CategoryTheory.MorphismProperty.Over.pullbackMapHomPullback._proof_7 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {P : CategoryTheory.MorphismProperty T} {Y Z : T}
(g : Y ⟶ Z) [CategoryTheory.Limits.HasPullbacks T], P.HasPullbacksAlong g | null | false |
Congr!.Config._sizeOf_1 | Mathlib.Tactic.CongrExclamation | Congr!.Config → ℕ | null | false |
Std.DHashMap.Internal.Raw₀.toList_map | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} (m : Std.DHashMap.Internal.Raw₀ α β) {f : (a : α) → β a → γ a},
(↑(Std.DHashMap.Internal.Raw₀.map f m)).toList.Perm (List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) (↑m).toList) | null | true |
Turing.TM2to1.StAct.rec | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{motive : Turing.TM2to1.StAct K Γ σ k → Sort u} →
((a : σ → Γ k) → motive (Turing.TM2to1.StAct.push a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.peek a)) →
((a : σ → Option (Γ k) →... | null | false |
CategoryTheory.Functor.CoconeTypes.IsColimit.fac_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimit) (c' : F.CoconeTypes) (j : J) (x : F.obj j), hc.desc c' (c.ι j x) = c'.ι j x | null | true |
Lean.Parser.doElemParser | Lean.Parser.Do | optParam ℕ 0 → Lean.Parser.Parser | null | true |
HasDerivAt.comp_sub_const | Mathlib.Analysis.Calculus.Deriv.Shift | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} (x a : 𝕜),
HasDerivAt f f' (x - a) → HasDerivAt (fun x => f (x - a)) f' x | Translation in the domain does not change the derivative. | true |
_private.Mathlib.MeasureTheory.Measure.Prokhorov.0.MeasureTheory.exists_measure_iUnion_gt_of_isCompact_closure._simp_1_5 | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (ν : MeasureTheory.ProbabilityMeasure Ω) (s : Set Ω), ↑ν s = ↑(ν s) | null | false |
NumberField.logHeight₁_eq | Mathlib.NumberTheory.Height.NumberField | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : K),
Height.logHeight₁ x = ∑ v, ↑v.mult * (v x).posLog + ∑ᶠ (v : NumberField.FinitePlace K), (v x).posLog | This is the familiar definition of the logarithmic height on a number field. | true |
Aesop.Script.StepTree.toMessageData | Aesop.Script.UScriptToSScript | Aesop.Script.StepTree → Lean.MessageData | null | true |
_private.Mathlib.Topology.Algebra.ValuativeRel.Completion.0.IsValuativeTopology.isClosedMap_restrict._simp_1_5 | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
IsFiniteLength.of_subsingleton._simp_1 | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Subsingleton M],
IsFiniteLength R M = True | null | false |
MeasureTheory.Measure.MutuallySingular.zero_left | Mathlib.MeasureTheory.Measure.MutuallySingular | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, MeasureTheory.Measure.MutuallySingular 0 μ | null | true |
Module.Basis.extendLe_subset | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s t : Set V}
(hs : LinearIndepOn K id s) (hst : s ⊆ t) (ht : ⊤ ≤ Submodule.span K t),
Set.range ⇑(Module.Basis.extendLe hs hst ht) ⊆ t | null | true |
Lean.HeadIndex.lam.sizeOf_spec | Lean.HeadIndex | sizeOf Lean.HeadIndex.lam = 1 | null | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.nontrivialTopology_iff_exists_nnnorm_ne_zero'._simp_1_2 | Mathlib.Analysis.Normed.Group.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α}, Inseparable x y = (nndist x y = 0) | null | false |
LinearIsometryEquiv.conjStarAlgEquiv._proof_2 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_2} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H],
SMulCommClass 𝕜 𝕜 H | null | false |
Std.Internal.List.minKey?_eq_some_minKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)} {he : l.isEmpty = false},
Std.Internal.List.minKey? l = some (Std.Internal.List.minKey l he) | null | true |
IsOrderedVAdd.vadd_le_vadd_right | Mathlib.Algebra.Order.AddTorsor | ∀ {G : Type u_3} {P : Type u_4} {inst : LE G} {inst_1 : LE P} {inst_2 : VAdd G P} [self : IsOrderedVAdd G P] (c d : G),
c ≤ d → ∀ (a : P), c +ᵥ a ≤ d +ᵥ a | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Different.0.FractionalIdeal.trace_mem_dual_one._simp_1_2 | 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 |
Std.IteratorLoop.WithWF.mk._flat_ctor | Init.Data.Iterators.Consumers.Monadic.Loop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{γ : Type x} →
{PlausibleForInStep : β → γ → ForInStep γ → Prop} →
{hwf : Std.IteratorLoop.WellFounded α m PlausibleForInStep} →
Std.IterM m β → γ → Std.IteratorLoop.WithWF α m Pl... | null | false |
RelIso.eq_iff_eq | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (f : r ≃r s) {a b : α}, f a = f b ↔ a = b | null | true |
CStarModule.innerₛₗ._proof_4 | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [StarModule ℂ A] (z : ℂ) (y : E),
{ toFun := fun y_1 => ... | null | false |
Qq.instBEqQuoted._aux_1 | Qq.Typ | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | null | false |
Fin.insertNth_sub | Mathlib.Algebra.Group.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (j : Fin (n + 1)) → Sub (α j)] (i : Fin (n + 1)) (x y : α i)
(p q : (j : Fin n) → α (i.succAbove j)), i.insertNth (x - y) (p - q) = i.insertNth x p - i.insertNth y q | null | true |
ContIntertwiningMap.toContinuousLinearMap_zero | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Monoid G] [inst_1 : Ring R]
[inst_2 : AddCommGroup V] [inst_3 : TopologicalSpace V] [inst_4 : IsTopologicalAddGroup V] [inst_5 : Module R V]
[inst_6 : AddCommGroup W] [inst_7 : TopologicalSpace W] [inst_8 : IsTopologicalAddGroup W] [inst_9 : Modu... | null | true |
Quaternion.imK_ratCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] (q : ℚ), (↑q).imK = 0 | null | true |
_private.Qq.AssertInstancesCommute.0.Qq.Impl._aux_Qq_AssertInstancesCommute___elabRules_Qq_Impl_termAssertInstancesCommuteImpl__1.match_1 | Qq.AssertInstancesCommute | (motive :
Option (Lean.FVarId × (u : Q(Lean.Level)) × (ty : Q(Q(Sort «$u»))) × Q(Q(«$$ty»)) × Q(Q(«$$ty»))) → Sort u_1) →
(__do_lift : Option (Lean.FVarId × (u : Q(Lean.Level)) × (ty : Q(Q(Sort «$u»))) × Q(Q(«$$ty»)) × Q(Q(«$$ty»)))) →
((fvar : Lean.FVarId) →
(fst : Q(Lean.Level)) →
(fst_1 :... | null | false |
_private.Mathlib.Topology.DiscreteSubset.0.mem_codiscreteWithin._simp_1_5 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
OrderAddMonoidHom.fst_apply | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : AddMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddMonoid β]
[inst_3 : Preorder β] (self : α × β), (OrderAddMonoidHom.fst α β) self = self.1 | null | true |
QuotientAddGroup.homQuotientZSMulOfHom_comp | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {A B : Type u} [inst : AddCommGroup A] [inst_1 : AddCommGroup B] (f : A →+ B) (g : B →+ A) (n : ℤ),
QuotientAddGroup.homQuotientZSMulOfHom (f.comp g) n =
(QuotientAddGroup.homQuotientZSMulOfHom f n).comp (QuotientAddGroup.homQuotientZSMulOfHom g n) | null | true |
CategoryTheory.yonedaJointlyReflectsLimits._proof_1 | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (F : CategoryTheory.Functor J Cᵒᵖ) (c : CategoryTheory.Limits.Cone F)
(hc : (X : C) → CategoryTheory.Limits.IsLimit ((CategoryTheory.yoneda.obj X).mapCone c))
(s : CategoryTheory.Limits.Co... | null | false |
CategoryTheory.Limits.createsLimitsOfShapeOfCreatesEqualizersAndProducts._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{K : CategoryTheory.Functor J C},
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete J) C →
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p... | null | false |
Valuation.IsEquiv.compatible | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : ValuativeRel R] {Γ₁ : Type u_3} {Γ₂ : Type u_4}
[inst_2 : LinearOrderedCommMonoidWithZero Γ₁] [inst_3 : LinearOrderedCommMonoidWithZero Γ₂] {v₁ : Valuation R Γ₁}
{v₂ : Valuation R Γ₂} [v₁.Compatible], v₁.IsEquiv v₂ → v₂.Compatible | null | true |
CommAlgCat.algEquivOfIso_apply | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : CommAlgCat R} (i : A ≅ B) (a : ↑A),
(CommAlgCat.algEquivOfIso i) a = (CategoryTheory.ConcreteCategory.hom i.hom) a | null | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLE.core.match_6 | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
(motive : Lean.LOption Q(Nontrivial «$α») → Sort u_1) →
(__do_lift : Lean.LOption Q(Nontrivial «$α»)) →
((_i : Q(Nontrivial «$α»)) → motive (Lean.LOption.some _i)) →
((x : Lean.LOption Q(Nontrivial «$α»)) → motive x) → motive __do_lift | null | false |
Aesop.TreeRef.rec | Aesop.Tree.Traversal | {motive : Aesop.TreeRef → Sort u} →
((gref : Aesop.GoalRef) → motive (Aesop.TreeRef.goal gref)) →
((rref : Aesop.RappRef) → motive (Aesop.TreeRef.rapp rref)) →
((cref : Aesop.MVarClusterRef) → motive (Aesop.TreeRef.mvarCluster cref)) → (t : Aesop.TreeRef) → motive t | null | false |
div_ne_one | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a / b ≠ 1 ↔ a ≠ b | null | true |
CategoryTheory.Mod.Hom.mk'._auto_1 | Mathlib.CategoryTheory.Monoidal.Mod | Lean.Syntax | null | false |
ENat.instUniqueUnits | Mathlib.Data.ENat.Monoid | Unique ℕ∞ˣ | null | true |
ContinuousMultilinearMap.linearDeriv.congr_simp | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(f f_1 : ContinuousMultili... | null | true |
Subsemigroup.op._proof_1 | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_1} [inst : Mul M] (x : Subsemigroup M) {a b : Mᵐᵒᵖ},
a ∈ MulOpposite.unop ⁻¹' ↑x → b ∈ MulOpposite.unop ⁻¹' ↑x → MulOpposite.unop b * MulOpposite.unop a ∈ x | null | false |
CategoryTheory.Bicategory.Prod.sectL._proof_8 | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u_2) [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C] (c : C)
{a b c_1 : B} {f g : a ⟶ b} (η : f ⟶ g) (h : b ⟶ c_1),
CategoryTheory.Prod.mkHom (CategoryTheory.Bicategory.whiskerRight η h)
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.id ... | null | false |
FirstOrder.Language.presburger.funMap_one | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | ∀ {M : Type u_2} [inst : Zero M] [inst_1 : One M] [inst_2 : Add M] {v : Fin 0 → M},
FirstOrder.Language.Structure.funMap FirstOrder.presburgerFunc.one v = 1 | null | true |
Int.Internal.Linear.Poly.denoteExpr | Lean.Meta.Tactic.Simp.Arith.Int.Basic | (ℕ → Lean.Expr) → Int.Internal.Linear.Poly → Lean.MetaM Lean.Expr | null | true |
_private.Batteries.Data.Array.Merge.0.Array.mergeAdjacentDups.go._unsafe_rec | Batteries.Data.Array.Merge | {α : Type u_1} → [eq : BEq α] → (α → α → α) → Array α → Array α → ℕ → α → α → Array α | null | false |
CategoryTheory.IsoCat | Mathlib.CategoryTheory.IsoCat | (C : Type u_1) →
(D : Type u_2) →
[CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Category.{v_2, u_2} D] → Type (max (max (max u_1 u_2) v_1) v_2) | An isomorphism of categories: a pair of functors whose composites are equal to the
identity functors. | true |
TopologicalSpace.prod_mono | Mathlib.Topology.Constructions.SumProd | ∀ {α : Type u_5} {β : Type u_6} {σ₁ σ₂ : TopologicalSpace α} {τ₁ τ₂ : TopologicalSpace β},
σ₁ ≤ σ₂ → τ₁ ≤ τ₂ → instTopologicalSpaceProd ≤ instTopologicalSpaceProd | null | true |
_private.Batteries.Data.MLList.Basic.0.MLList.Spec.mk.sizeOf_spec | Batteries.Data.MLList.Basic | ∀ {m : Type u → Type u} [inst : (a : Type u) → SizeOf (m a)] (listM : Type u → Type u) (nil : {α : Type u} → listM α)
(cons : {α : Type u} → α → listM α → listM α) (thunk : {α : Type u} → (Unit → listM α) → listM α)
(squash : {α : Type u} → (Unit → m (listM α)) → listM α)
(uncons : {α : Type u} → [Monad m] → list... | null | true |
coe_iterateFrobeniusEquiv | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_1) (p n : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [inst_2 : PerfectRing R p],
⇑(iterateFrobeniusEquiv R p n) = ⇑(iterateFrobenius R p n) | null | true |
Std.Time.Modifier.V.inj | Std.Time.Format.Modifier | ∀ {presentation presentation_1 : Std.Time.ZoneId},
Std.Time.Modifier.V presentation = Std.Time.Modifier.V presentation_1 → presentation = presentation_1 | null | true |
_private.Mathlib.Analysis.Convex.Gauge.0.setOfPred_gauge_lt_eq'._simp_1_1 | Mathlib.Analysis.Convex.Gauge | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | null | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.incMod | Std.Sync.Channel | ℕ → ℕ → ℕ | null | true |
Flow.cont' | Mathlib.Dynamics.Flow | ∀ {τ : Type u_1} {α : Type u_2} [inst : TopologicalSpace τ] [inst_1 : TopologicalSpace α] [inst_2 : AddZero τ]
(self : Flow τ α), Continuous (Function.uncurry self.toFun) | null | true |
Turing.Dir.ofNat_ctorIdx | Mathlib.Computability.TuringMachine.Tape | ∀ (x : Turing.Dir), Turing.Dir.ofNat x.ctorIdx = x | null | true |
Colex.instIsCancelMul | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Mul α] [IsCancelMul α], IsCancelMul (Colex α) | null | true |
_private.Mathlib.FieldTheory.Differential.Basic.0.Differential.logDeriv_div._simp_1_7 | Mathlib.FieldTheory.Differential.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1.else_eq | Lean.Elab.Tactic.Try | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Lean.Elab.Tactic.Try.isAccessible._sparseCasesOn_1✝ t some «else» = «else» h | null | false |
Filter.prod_map_map_eq' | Mathlib.Order.Filter.Prod | ∀ {α₁ : Type u_6} {α₂ : Type u_7} {β₁ : Type u_8} {β₂ : Type u_9} (f : α₁ → α₂) (g : β₁ → β₂) (F : Filter α₁)
(G : Filter β₁), Filter.map f F ×ˢ Filter.map g G = Filter.map (Prod.map f g) (F ×ˢ G) | null | true |
_private.Mathlib.LinearAlgebra.Finsupp.Span.0.Finsupp.iInf_ker_lapply_le_bot._simp_1_4 | Mathlib.LinearAlgebra.Finsupp.Span | ∀ (R : Type u_1) {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x : M},
(x ∈ ⊥) = (x = 0) | null | false |
Submonoid.mk_inv_mul_mk_eq_one | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ} (h : x ∈ S.units),
⟨(Units.coeHom M) x⁻¹, ⋯⟩ * ⟨(Units.coeHom M) x, ⋯⟩ = 1 | null | true |
_aux_Mathlib_Combinatorics_Quiver_Basic___unexpand_Quiver_Hom_1 | Mathlib.Combinatorics.Quiver.Basic | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Analysis.CStarAlgebra.GelfandDuality.0.IsSelfAdjoint.nnnorm_sum_eq_sup._proof_1_2 | Mathlib.Analysis.CStarAlgebra.GelfandDuality | ∀ {ι : Type u_1} (j : ι) (s : Finset ι), j ∉ s → ∀ i ∈ s, ¬j = i | null | false |
AlgebraicGeometry.Scheme.Modules.pushforwardId | Mathlib.AlgebraicGeometry.Modules.Sheaf | (X : AlgebraicGeometry.Scheme) →
AlgebraicGeometry.Scheme.Modules.pushforward (CategoryTheory.CategoryStruct.id X) ≅
CategoryTheory.Functor.id X.Modules | The pushforward of sheaves of modules by the identity morphism identifies
to the identity functor. | true |
Ideal.quotientToQuotientRangePowQuotSucc | Mathlib.NumberTheory.RamificationInertia.Basic | {R : Type u} →
[inst : CommRing R] →
{S : Type v} →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(p : Ideal R) →
(P : Ideal S) →
[hfp : NeZero (p.ramificationIdx' P)] →
{i : ℕ} →
{a : S} →
a ∈ P ^ i →
... | `S ⧸ P` embeds into the quotient by `P^(i+1) ⧸ P^e` as a subspace of `P^i ⧸ P^e`. | true |
CategoryTheory.MonoidalLinear.whiskerLeft_smul | Mathlib.CategoryTheory.Monoidal.Linear | ∀ {R : Type u_1} {inst : Semiring R} {C : Type u_2} {inst_1 : CategoryTheory.Category.{v_1, u_2} C}
{inst_2 : CategoryTheory.Preadditive C} {inst_3 : CategoryTheory.Linear R C}
{inst_4 : CategoryTheory.MonoidalCategory C} {inst_5 : CategoryTheory.MonoidalPreadditive C}
[self : CategoryTheory.MonoidalLinear R C] (... | null | true |
EReal.sub_le_iff_le_add | Mathlib.Data.EReal.Operations | ∀ {a b c : EReal}, b ≠ ⊥ ∨ c ≠ ⊤ → b ≠ ⊤ ∨ c ≠ ⊥ → (a - b ≤ c ↔ a ≤ c + b) | null | true |
CategoryTheory.Subobject.ofMkLE | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{B A : C} →
(f : A ⟶ B) →
[inst_1 : CategoryTheory.Mono f] →
(X : CategoryTheory.Subobject B) →
CategoryTheory.Subobject.mk f ≤ X → (A ⟶ CategoryTheory.Subobject.underlying.obj X) | An inequality of subobjects is witnessed by some morphism between the corresponding objects. | true |
ContinuousAffineMap.const_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] [inst_9 : Topolog... | null | true |
CategoryTheory.ObjectProperty.Is.rec | Mathlib.CategoryTheory.ObjectProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P : CategoryTheory.ObjectProperty C} →
{X : C} → {motive : P.Is X → Sort u_1} → ((prop : P X) → motive ⋯) → (t : P.Is X) → motive t | null | false |
Std.ExtTreeSet.mem_inter_iff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
k ∈ t₁ ∩ t₂ ↔ k ∈ t₁ ∧ k ∈ t₂ | null | true |
HeytAlg.ext_iff | Mathlib.Order.Category.HeytAlg | ∀ {X Y : HeytAlg} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x | null | true |
convexHull_neg | Mathlib.Analysis.Convex.Hull | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) (-s) = -(convexHull 𝕜) s | null | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_i | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | null | true |
Lean.Elab.MonadParentDecl.casesOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadParentDecl m → Sort u} →
(t : Lean.Elab.MonadParentDecl m) →
((getParentDeclName? : m (Option Lean.Name)) → motive { getParentDeclName? := getParentDeclName? }) → motive t | null | false |
_private.Lean.Parser.Basic.0.Lean.Parser.rawStrLitFnAux.errorUnterminated | Lean.Parser.Basic | String.Pos.Raw → Lean.Parser.ParserState → Lean.Parser.ParserState | Gives the "unterminated raw string literal" error.
| true |
RingEquiv.piOptionEquivProd | Mathlib.Algebra.Ring.Equiv | {ι : Type u_7} →
{R : Option ι → Type u_8} →
[inst : (i : Option ι) → NonUnitalNonAssocSemiring (R i)] →
((i : Option ι) → R i) ≃+* R none × ((i : ι) → R (some i)) | This is `Equiv.piOptionEquivProd` as a `RingEquiv`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.