name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BitVec.toFin_signExtend | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ} (x : BitVec w),
(BitVec.signExtend v x).toFin = Fin.ofNat (2 ^ v) (x.toNat + if x.msb = true then 2 ^ v - 2 ^ w else 0) | null | true |
RCLike.copy_of_normedField._proof_18 | Mathlib.Analysis.RCLike.Basic | ∀ {𝕜 : Type u_1} (h : RCLike 𝕜) (hk : NormedField 𝕜) (h'' : hk = h.toNormedField) (z w : 𝕜),
(⋯ ▸
let __spread.0 := h.toNormedField;
RCLike.re)
(z * w) =
(⋯ ▸
let __spread.0 := h.toNormedField;
RCLike.re)
z *
(⋯ ▸
let __spread.0 := h.... | null | false |
PosNum.one.sizeOf_spec | Mathlib.Data.Num.Basic | sizeOf PosNum.one = 1 | null | true |
SimpleGraph.ConnectedComponent.mem_supp_of_adj_mem_supp | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent) {u v : V}, u ∈ C.supp → G.Adj u v → v ∈ C.supp | null | true |
List.takeWhile._f | Init.Data.List.Basic | {α : Type u} → (α → Bool) → (x : List α) → List.below x → List α | null | false |
String.Pos.prev | Init.Data.String.FindPos | {s : String} → (pos : s.Pos) → pos ≠ s.startPos → s.Pos | Returns the previous valid position before the given position, given a proof that the position
is not the start position, which guarantees that such a position exists. | true |
Lean.Widget.TaggedText.appendText | Lean.Widget.TaggedText | {α : Type u_1} → String → Lean.Widget.TaggedText α → Lean.Widget.TaggedText α | null | true |
_private.Mathlib.Probability.Process.Predictable.0.MeasureTheory.measurable_inclusion_predictable._simp_1_1 | Mathlib.Probability.Process.Predictable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {f : α → β} {s : Set β},
MeasurableSet s = MeasurableSet (f ⁻¹' s) | null | false |
CategoryTheory.Pseudofunctor.Grothendieck.map_comp_eq | Mathlib.CategoryTheory.Bicategory.Grothendieck | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮]
{F G H : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} (α : F ⟶ G) (β : G ⟶ H),
CategoryTheory.Pseudofunctor.Grothendieck.map (CategoryTheory.CategoryStruct.comp α β) =
(CategoryTheory.Pseudofunctor.Grothendieck... | null | true |
Lean.Meta.Canonicalizer.State.keyToExprs._default | Lean.Meta.Canonicalizer | Std.HashMap UInt64 (List Lean.Expr) | null | false |
Lean.Elab.Term.Do.Code.decl.injEq | Lean.Elab.Do.Legacy | ∀ (xs : Array Lean.Elab.Term.Do.Var) (doElem : Lean.Syntax) (k : Lean.Elab.Term.Do.Code)
(xs_1 : Array Lean.Elab.Term.Do.Var) (doElem_1 : Lean.Syntax) (k_1 : Lean.Elab.Term.Do.Code),
(Lean.Elab.Term.Do.Code.decl xs doElem k = Lean.Elab.Term.Do.Code.decl xs_1 doElem_1 k_1) =
(xs = xs_1 ∧ doElem = doElem_1 ∧ k = ... | null | true |
IsPiSystem.tendsto_measureReal_biUnion._auto_3 | Mathlib.MeasureTheory.Measure.Portmanteau | Lean.Syntax | null | false |
Std.HashMap.Equiv.filter | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β} (f : α → β → Bool),
m₁.Equiv m₂ → (Std.HashMap.filter f m₁).Equiv (Std.HashMap.filter f m₂) | null | true |
isBinaryCoproductOfIsInitialIsPushout._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C) {X : C}
(hX : CategoryTheory.Limits.IsInitial X) (f : X ⟶ F.obj { as := CategoryTheory.Limits.WalkingPair.left })
(g : X ⟶ F.obj { as := CategoryTheory.Limits.W... | null | false |
Std.Internal.List.getValueCastD_filter_containsKey_of_containsKey_right | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α}
{fallback : β k},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₂ = true →
Std.Internal.List.getValueCastD k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁... | null | true |
Algebra.Presentation.comp_relation_inr | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{ι' : Type u_1} {σ' : Type u_2} {T : Type u_3} [inst_3 : CommRing T] [inst_4 : Algebra S T]
(Q : Algebra.Presentation S T ι' σ') (P : Algebra.Presentation R S ι σ) [inst_5 : Algebra R T]
[inst_6 ... | null | true |
Complex.continuous_ofReal | Mathlib.Analysis.Complex.Basic | Continuous Complex.ofReal | null | true |
Lean.Elab.Command.withViewTypeRef | Lean.Elab.MutualInductive | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.MonadRef m] → Array Lean.Elab.Command.InductiveView → m α → m α | null | true |
_private.Mathlib.FieldTheory.IsAlgClosed.Basic.0.IsAlgClosure.of_splits.match_1_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {R : Type u_1} {K : Type u_2} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K] (_p : Polynomial K)
(motive : (∃ g, g.Monic ∧ Irreducible g ∧ _p ∣ Polynomial.map (algebraMap R K) g) → Prop)
(x : ∃ g, g.Monic ∧ Irreducible g ∧ _p ∣ Polynomial.map (algebraMap R K) g),
(∀ (g : Polynomial R) (monic : g.... | null | false |
Asymptotics.isLittleO_bot._simp_1 | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] (f : α → E) (g : α → F),
f =o[⊥] g = True | null | false |
List.getElem_dropLast._f | Init.Data.List.Lemmas | ∀ {α : Type u_1} (x : List α)
(f : List.below (motive := fun x => ∀ (x_1 : ℕ) (x_2 : x_1 < x.dropLast.length), x.dropLast[x_1] = x[x_1]) x)
(x_1 : ℕ) (x_2 : x_1 < x.dropLast.length), x.dropLast[x_1] = x[x_1] | null | false |
deriv_bernoulliFun | Mathlib.NumberTheory.ZetaValues | ∀ (k : ℕ), deriv (bernoulliFun k) = fun x => ↑k * bernoulliFun (k - 1) x | null | true |
_private.Mathlib.Data.Stream.Init.0.Stream'.mem_map.match_1_1 | Mathlib.Data.Stream.Init | ∀ {α : Type u_1} {a : α} {s : Stream' α} (motive : a ∈ s → Prop) (x : a ∈ s),
(∀ (n : ℕ) (h : a = s.get n), motive ⋯) → motive x | null | false |
MeasureTheory.Measure.isMulLeftInvariant_eq_smul_of_innerRegular | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsHaarMeasure] [inst_7 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsMulLeftInvaria... | **Uniqueness of left-invariant measures**:
Given two left-invariant measures which are finite
on compacts and inner regular, they coincide up to a multiplicative constant. | true |
RegularSpace.casesOn | Mathlib.Topology.Separation.Regular | {X : Type u} →
[inst : TopologicalSpace X] →
{motive : RegularSpace X → Sort u_1} →
(t : RegularSpace X) →
((regular : ∀ {s : Set X} {a : X}, IsClosed s → a ∉ s → Disjoint (nhdsSet s) (nhds a)) → motive ⋯) → motive t | null | false |
Lean.Elab.WF.GuessLex.instToStringGuessLexRel.match_1 | Lean.Elab.PreDefinition.WF.GuessLex | (motive : Lean.Elab.WF.GuessLex.GuessLexRel → Sort u_1) →
(x : Lean.Elab.WF.GuessLex.GuessLexRel) →
(Unit → motive Lean.Elab.WF.GuessLex.GuessLexRel.lt) →
(Unit → motive Lean.Elab.WF.GuessLex.GuessLexRel.eq) →
(Unit → motive Lean.Elab.WF.GuessLex.GuessLexRel.le) →
(Unit → motive Lean.Elab.... | null | false |
CategoryTheory.Limits.Multifork.isoOfι_hom_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
{I : CategoryTheory.Limits.MulticospanIndex J C} (t : CategoryTheory.Limits.Multifork I),
t.isoOfι.hom.hom = CategoryTheory.CategoryStruct.id t.pt | null | true |
FreeAlgebra.Pre.mul.injEq | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} (a a_1 a_2 a_3 : FreeAlgebra.Pre R X), (a.mul a_1 = a_2.mul a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
DFinsupp.prod_of_support_subset | Mathlib.Data.DFinsupp.BigOperators | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] [inst_3 : CommMonoid γ] {f : Π₀ (i : ι), β i}
{g : (i : ι) → β i → γ} {s : Finset ι}, f.support ⊆ s → (∀ i ∈ s, g i 0 = 1) → f.prod g = ∏ i ∈ s, g i (f i) | null | true |
Turing.TM2.Stmt.load.inj | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4} {a : σ → σ} {a_1 : Turing.TM2.Stmt Γ Λ σ}
{a_2 : σ → σ} {a_3 : Turing.TM2.Stmt Γ Λ σ},
Turing.TM2.Stmt.load a a_1 = Turing.TM2.Stmt.load a_2 a_3 → a = a_2 ∧ a_1 = a_3 | null | true |
toMul_eq_one._simp_1 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {α : Type u_1} [inst : One α] {x : Additive α}, (Additive.toMul x = 1) = (x = 0) | null | false |
NormedAddGroupHom.SurjectiveOnWith.exists_pos | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
{f : NormedAddGroupHom V₁ V₂} {K : AddSubgroup V₂} {C : ℝ}, f.SurjectiveOnWith K C → ∃ C' > 0, f.SurjectiveOnWith K C' | null | true |
CategoryTheory.Limits.binaryFanZeroRightIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C) (s : CategoryTheory.Limits.BinaryFan X 0),
CategoryTheory.CategoryStruct.comp s.fst 0 = s.snd | null | false |
ConditionallyCompleteLinearOrderedField.inducedAddHom.eq_1 | Mathlib.Algebra.Order.CompleteField | ∀ (α : Type u_1) (β : Type u_2) [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Field β] [inst_4 : ConditionallyCompleteLinearOrder β] [inst_5 : IsStrictOrderedRing β]
[inst_6 : Archimedean α],
ConditionallyCompleteLinearOrderedField.inducedAddHom α β =
{ toFun := Conditio... | null | true |
AlgebraicGeometry.IsOpenImmersion.affineOpensEquiv._proof_8 | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [H : AlgebraicGeometry.IsOpenImmersion f]
(U : { U // ↑U ≤ AlgebraicGeometry.Scheme.Hom.opensRange f }),
⟨⟨(AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj ↑⟨(TopologicalSpace.Opens.map f.base).obj ↑↑U, ⋯⟩, ⋯⟩, ⋯⟩ = U | null | false |
Ideal.IsTwoSided.pow_add | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I : Ideal R} [I.IsTwoSided] (m n : ℕ), I ^ (m + n) = I ^ m * I ^ n | null | true |
Nat.comap_cast_atTop | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {R : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] [Archimedean R],
Filter.comap Nat.cast Filter.atTop = Filter.atTop | null | true |
_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.evalFinsetIccNat._proof_2 | Mathlib.Tactic.Simproc.FinsetInterval | ∀ (em em' : Q(ℕ)), «$em'» =Q «$em» + 1 | null | false |
_private.Mathlib.Topology.UniformSpace.ProdApproximation.0.ContinuousMap.prodMul._proof_7 | Mathlib.Topology.UniformSpace.ProdApproximation | ∀ {X : Type u_1} {Y : Type u_3} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : CommRing R] [inst_3 : TopologicalSpace R] [inst_4 : IsTopologicalRing R] (r : R) (f : C(X, R))
(g : C(Y, R)),
f.comp ContinuousMap.fst * (r • g).comp ContinuousMap.snd = r • (f.comp ContinuousMap.fst... | null | false |
LinearOrder.ctorIdx | Mathlib.Order.Defs.LinearOrder | {α : Type u_2} → LinearOrder α → ℕ | null | false |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.cooper | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.LeCnstr →
Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Lean.Meta.Grind.Arith.Cutsat.UnsatProof | null | true |
_private.Batteries.Data.PairingHeap.0.Batteries.PairingHeapImp.Heap.combine.match_1.splitter | Batteries.Data.PairingHeap | {α : Type u_1} →
(motive : Batteries.PairingHeapImp.Heap α → Sort u_2) →
(x : Batteries.PairingHeapImp.Heap α) →
((a : α) →
(child : Batteries.PairingHeapImp.Heap α) →
(a_1 : α) →
(child_1 s : Batteries.PairingHeapImp.Heap α) →
motive
(Ba... | null | true |
ApplicativeTransformation.mk.noConfusion | Mathlib.Control.Traversable.Basic | {F : Type u → Type v} →
{inst : Applicative F} →
{G : Type u → Type w} →
{inst_1 : Applicative G} →
{P : Sort u_1} →
{app : (α : Type u) → F α → G α} →
{preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x} →
{preserves_seq' :
∀ {α β... | null | false |
Matrix.instL2OpMetricSpace._proof_14 | Mathlib.Analysis.CStarAlgebra.Matrix | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], RingHomCompTriple (RingHom.id 𝕜) (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
OrderRingHom.ctorIdx | Mathlib.Algebra.Order.Hom.Ring | {α : Type u_6} →
{β : Type u_7} →
{inst : NonAssocSemiring α} →
{inst_1 : Preorder α} → {inst_2 : NonAssocSemiring β} → {inst_3 : Preorder β} → α →+*o β → ℕ | null | false |
Dilation.ratio.congr_simp | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {F : Type u_4} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : FunLike F α β] [inst_3 : DilationClass F α β] (f f_1 : F), f = f_1 → Dilation.ratio f = Dilation.ratio f_1 | null | true |
CategoryTheory.Pretriangulated.Triangle.functorIsoMk'_inv_app_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} J] {obj₁ obj₂ obj₃ : CategoryTheory.Functor J C} {mor₁ : obj₁ ⟶ obj₂}
{mor₂ : obj₂ ⟶ obj₃} {mor₃ : obj₃ ⟶ obj₁.comp (CategoryTheory.shiftFunctor C 1)}
{obj₁' ... | null | true |
Topology.IsQuotientMap.homeomorph | Mathlib.Topology.ContinuousMap.Basic | {X : Type u_1} →
{Y : Type u_2} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] → {f : C(X, Y)} → Topology.IsQuotientMap ⇑f → Quotient (Setoid.ker ⇑f) ≃ₜ Y | The homeomorphism from the quotient of a quotient map to its codomain. This is
`Setoid.quotientKerEquivOfSurjective` as a homeomorphism.
| true |
Nat.clog.go._unsafe_rec | Mathlib.Data.Nat.Log | ℕ → ℕ → ℕ → ℕ × ℕ | null | false |
FiniteArchimedeanClass.ball | Mathlib.Algebra.Order.Module.Archimedean | {M : Type u_1} →
[inst : AddCommGroup M] →
[inst_1 : LinearOrder M] →
[inst_2 : IsOrderedAddMonoid M] →
(K : Type u_2) →
[inst_3 : Ring K] →
[inst_4 : LinearOrder K] →
[IsOrderedRing K] →
[Archimedean K] → [inst_7 : Module K M] → [PosSMulMono K M] ... | An open ball defined by `ArchimedeanClass.submodule` of `UpperSet.Ioi c`.
For `c = ⊤`, we assign the junk value `⊥`.
This has the same carrier as `ArchimedeanClass.ballAddSubgroup`'s. | true |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.isProbabilityMeasure_join._simp_1_2 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.Basic.0.CategoryTheory.Abelian.SpectralObject._proof_3 | Mathlib.Algebra.Homology.SpectralObject.Basic | 2 ≤ 2 | null | false |
Setoid.comap_comp | Mathlib.Order.Setoid.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (c : Setoid γ) (g : β → γ) (f : α → β),
Setoid.comap (g ∘ f) c = Setoid.comap f (Setoid.comap g c) | null | true |
BitVec.instAssociativeHAnd | Init.Data.BitVec.Lemmas | ∀ {n : ℕ}, Std.Associative fun x1 x2 => x1 &&& x2 | null | true |
_private.Lean.Elab.Parallel.0.Std.Iterators.Types.Internal.TaskIterator.mk.injEq | Lean.Elab.Parallel | ∀ {α : Type w} (tasks tasks_1 : List (Task α)), ({ tasks := tasks } = { tasks := tasks_1 }) = (tasks = tasks_1) | null | true |
Order.isIntent_upperPolar._simp_1 | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} {r : α → β → Prop} {s : Set α}, Order.IsIntent r (upperPolar r s) = True | null | false |
CategoryTheory.Triangulated.Octahedron.triangleMorphism₁_hom₁ | Mathlib.CategoryTheory.Triangulated.Triangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{X₁ X₂ X₃ Z₁₂ ... | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point.0.WeierstrassCurve.Affine.Point.X_eq_iff._proof_1_5 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} {x₂ y₂ : F} {h₂ : W.Nonsingular x₂ y₂},
W.Nonsingular x₂ (W.negY x₂ (W.negY x₂ (W.negY x₂ (W.negY x₂ (W.negY x₂ y₂))))) | null | false |
iInf_eq_iInf_finset' | Mathlib.Order.CompleteLattice.Finset | ∀ {α : Type u_1} {ι' : Sort u_5} [inst : CompleteLattice α] (s : ι' → α), ⨅ i, s i = ⨅ t, ⨅ i ∈ t, s i.down | Infimum of `s i`, `i : ι`, is equal to the infimum over `t : Finset ι` of infima
`⨅ i ∈ t, s i`. This version works for `ι : Sort*`. See `iInf_eq_iInf_finset` for a version
that assumes `ι : Type*` but has no `PLift`s. | true |
CategoryTheory.MorphismProperty.Under.mapComp_hom_app_left | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] {X Y Z : T}
[inst_2 : P.IsStableUnderComposition] {f : X ⟶ Y} (hf : P f) {g : Y ⟶ Z} (hg : P g) [inst_3 : Q.RespectsIso]
(fg : optParam (X ⟶ ... | null | true |
_private.Init.Data.Nat.Fold.0.Nat.allTR.loop._sunfold | Init.Data.Nat.Fold | (n : ℕ) → ((i : ℕ) → i < n → Bool) → (i : ℕ) → i ≤ n → Bool | null | false |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.printInduct | Mathlib.Util.WhatsNew | Lean.Name → List Lean.Name → ℕ → ℕ → Lean.Expr → List Lean.Name → Bool → Lean.CoreM Lean.MessageData | null | true |
StarAddMonoid.toStarModuleNNRat | Mathlib.Algebra.Star.Module | ∀ {R : Type u_1} [inst : AddCommMonoid R] [inst_1 : Module ℚ≥0 R] [inst_2 : StarAddMonoid R], StarModule ℚ≥0 R | null | true |
Order.IsSuccPrelimit.iSup_lt_iff | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {ι : Sort u_1} {α : Type u_2} [inst : CompleteLinearOrder α] {f : ι → α} {x : α},
Order.IsSuccPrelimit x → (⨆ i, f i < x ↔ ∃ a < x, ∀ (i : ι), f i < a) | Similar to `iSup_lt_iff` but with a stronger RHS, as it requires a strict inequality. | true |
Std.TreeMap.Raw.size_ofList_le | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List (α × β)},
(Std.TreeMap.Raw.ofList l cmp).size ≤ l.length | null | true |
instCommGroupUniformOnFun._proof_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : CommGroup β] (a b : UniformOnFun α β 𝔖), a * b = b * a | null | false |
CategoryTheory.Limits.Cofork.IsColimit.ofExistsUnique | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
{X Y : C} →
[inst : CategoryTheory.Category.{v, u} C] →
{f g : Y ⟶ X} →
{t : CategoryTheory.Limits.Cofork f g} →
(∀ (s : CategoryTheory.Limits.Cofork f g), ∃! l, CategoryTheory.CategoryStruct.comp t.π l = s.π) →
CategoryTheory.Limits.IsColimit t | Noncomputably make a colimit cocone from the existence of unique factorizations. | true |
meromorphicOrderAt_id | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], meromorphicOrderAt id 0 = 1 | null | true |
String.Pos.prevn_le | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos} {n : ℕ}, p.prevn n ≤ p | null | true |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeAddGroup.toWord_mk_add_eq._proof_1_2 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (b : Bool) (head : α × Bool) (tail : List (α × Bool)),
(if a = head.1 ∧ b = !head.2 then tail else (a, b) :: head :: tail) =
if head.1 = a ∧ head.2 = !b then tail else (a, b) :: head :: tail | null | false |
Order.Ico_pred_right_eq_insert | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] {a b : α} [NoMinOrder α],
b ≤ a → Set.Ioc (Order.pred b) a = insert b (Set.Ioc b a) | **Alias** of `Order.Ioc_pred_left_eq_insert`. | true |
Matrix.compLinearEquiv._proof_3 | Mathlib.Data.Matrix.Composition | ∀ (I : Type u_5) (J : Type u_4) (K : Type u_3) (L : Type u_2) (R : Type u_1) [inst : AddCommMonoid R],
Function.LeftInverse (Matrix.compAddEquiv I J K L R).invFun (Matrix.compAddEquiv I J K L R).toFun | null | false |
ENNReal.tsum_toNNReal_eq | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → ENNReal}, (∀ (a : α), f a ≠ ⊤) → (∑' (a : α), f a).toNNReal = ∑' (a : α), (f a).toNNReal | null | true |
AdicCompletion.pi._proof_2 | Mathlib.RingTheory.AdicCompletion.Functoriality | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_3} (M : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (M i)]
[inst_2 : (i : ι) → Module R (M i)] (j : ι), IsScalarTower R R (M j) | null | false |
Set.piecewise.congr_simp | Mathlib.Data.Set.Piecewise | ∀ {α : Type u} {β : α → Sort v} (s s_1 : Set α),
s = s_1 →
∀ (f f_1 : (i : α) → β i),
f = f_1 →
∀ (g g_1 : (i : α) → β i),
g = g_1 →
∀ {inst : (j : α) → Decidable (j ∈ s)} [inst_1 : (j : α) → Decidable (j ∈ s_1)] (i : α),
s.piecewise f g i = s_1.piecewise f_1 g_1 ... | null | true |
Lean.Grind.Ring.OfSemiring.toQ_pow | Init.Grind.Ring.Envelope | ∀ {α : Type u} [inst : Lean.Grind.Semiring α] (a : α) (n : ℕ), ↑(a ^ n) = ↑a ^ n | null | true |
_private.Lean.Elab.Command.0.Lean.Elab.Command.withoutCommandIncrementality.match_1 | Lean.Elab.Command | (motive : Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Language.DynamicSnapshot)) → Sort u_1) →
(x : Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Language.DynamicSnapshot))) →
((old : Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Language.DynamicSnaps... | null | false |
TopCat.isSection | Mathlib.Topology.Sheaves.LocalPredicate | {X : TopCat} → {T : Type u_3} → (T → ↑X) → TopCat.LocalPredicate fun x => T | The local predicate of being a partial section of a function. | true |
SimpleGraph.structure | Mathlib.ModelTheory.Graph | {V : Type u} → SimpleGraph V → FirstOrder.Language.graph.Structure V | Any simple graph can be thought of as a structure in the language of graphs. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.sum_density_div_card_le_density_add_eps | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P : Finpartition Finset.univ} {hP : P.IsEquipartition}
{G : SimpleGraph α} [inst_2 : DecidableRel G.Adj] {ε : ℝ} {U V : Finset α} [Nonempty α],
P.parts.card * 16 ^ P.parts.card ≤ Fintype.card α →
100 ≤ 4 ^ P.parts.card * ε ^ 5 →
ε ≤ 1 →
... | null | true |
Associated.dvdNotUnit_right_iff | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {p q r : M}, Associated q r → (DvdNotUnit p q ↔ DvdNotUnit p r) | null | true |
Lean.Lsp.instToJsonPosition | Lean.Data.Lsp.BasicAux | Lean.ToJson Lean.Lsp.Position | null | true |
_private.Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc.0.CategoryTheory.SmallObject.SuccStruct.extendToSucc.map_id._simp_1_1 | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, (Order.succ a ≤ a) = IsMax a | null | false |
Algebra.IsStandardSmoothOfRelativeDimension.subsingleton_kaehlerDifferential | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.IsStandardSmoothOfRelativeDimension 0 R S], Subsingleton Ω[S⁄R] | null | true |
String.getUTF8Byte.eq_1 | Init.Data.String.Basic | ∀ (s : String) (p : String.Pos.Raw) (h : p < s.rawEndPos), s.getUTF8Byte p h = s.toByteArray[p.byteIdx] | null | true |
CochainComplex.HomComplex.Cochain.leftUnshift._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {n' a : ℤ} (n : ℤ), n + a = n' → ∀ (p q : ℤ), p + n = q → p - a + n' = q | null | false |
Lean.Order.chain_iterates | Init.Internal.Order.Basic | ∀ {α : Sort u} [inst : Lean.Order.CCPO α] {f : α → α}, Lean.Order.monotone f → Lean.Order.chain (Lean.Order.iterates f) | null | true |
_private.Mathlib.FieldTheory.Minpoly.MinpolyDiv.0.eval₂_minpolyDiv_of_eval₂_eq_zero._simp_1_1 | Mathlib.FieldTheory.Minpoly.MinpolyDiv | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
CategoryTheory.Abelian.SpectralObject.map_comp._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
_private.Mathlib.RingTheory.Coprime.Basic.0.Semifield.isCoprime_iff._simp_1_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x : R}, IsCoprime x 0 = IsUnit x | null | false |
Finset.Colex.le_iff_sdiff_subset_lowerClosure | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : Colex (Finset α)},
s ≤ t ↔ ↑(ofColex s) \ ↑(ofColex t) ⊆ ↑(lowerClosure (↑(ofColex t) \ ↑(ofColex s))) | null | true |
Sublattice.prod_right_mono | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] {L : Sublattice α}, Monotone fun M => L.prod M | null | true |
UInt32.ofInt_one | Init.Data.UInt.Lemmas | UInt32.ofInt 1 = 1 | null | true |
Lean.Lsp.instToJsonApplyWorkspaceEditParams | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.ApplyWorkspaceEditParams | null | true |
IsChain.eq_1 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} (r : α → α → Prop) (s : Set α), IsChain r s = s.Pairwise fun x y => r x y ∨ r y x | null | true |
NumberField.IsCMField.complexConj_torsion | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [inst_2 : NumberField.IsCMField K] [inst_3 : NumberField K]
(ζ : ↥(NumberField.Units.torsion K)),
(NumberField.IsCMField.complexConj K) ((algebraMap (NumberField.RingOfIntegers K) K) ↑↑ζ) =
((algebraMap (NumberField.RingOfIntegers K) K) ↑↑ζ)⁻¹ | The image of a root of unity by the complex conjugation is its inverse.
This is the version of `Complex.conj_rootsOfUnity` for CM-fields.
| true |
MulActionHom.instMonoid._proof_7 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} {N : Type u_2} {X : Type u_3} {Y : Type u_4} {σ : M → N} [inst : SMul M X] [inst_1 : Monoid N]
[inst_2 : Monoid Y] [inst_3 : MulDistribMulAction N Y] (x : X →ₑ[σ] Y), x * 1 = x | null | false |
Lean.Parser.Term.precheckedQuot.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
HahnSeries.ofPowerSeries_apply | Mathlib.RingTheory.HahnSeries.PowerSeries | ∀ {Γ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : Semiring Γ] [inst_2 : PartialOrder Γ]
[inst_3 : IsStrictOrderedRing Γ] (x : PowerSeries R),
(HahnSeries.ofPowerSeries Γ R) x = HahnSeries.embDomain Nat.castOrderEmbedding (HahnSeries.toPowerSeries.symm x) | null | true |
AdjoinRoot.isDomain_of_prime | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {f : Polynomial R}, Prime f → IsDomain (AdjoinRoot f) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.