name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Server.RequestCancellation.ctorIdx | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ | false |
IO.Error.instToString | Init.System.IOError | ToString IO.Error | true |
CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKan._proof_1 | Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {u : b ⟶ a}
(adj : CategoryTheory.Bicategory.Adjunction f u) {x : B} (h : a ⟶ x)
(s :
CategoryTheory.Bicategory.LeftExtension f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) h)),
CategoryTheory.Categor... | false |
DerivedCategory.singleFunctorsPostcompQIso | Mathlib.Algebra.Homology.DerivedCategory.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : HasDerivedCategory C] →
DerivedCategory.singleFunctors C ≅ (CochainComplex.singleFunctors C).postcomp DerivedCategory.Q | true |
MonoidWithZeroHom.snd.eq_1 | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ (G₀ : Type u_1) (H₀ : Type u_2) [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀],
MonoidWithZeroHom.snd G₀ H₀ = WithZero.lift' ((Units.coeHom H₀).comp (MonoidHom.snd G₀ˣ H₀ˣ)) | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NNReal.0.ENNReal.rpow_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ⊤ = none | false |
Std.DHashMap.Equiv.casesOn | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} →
{x_1 : Hashable α} →
{m₁ m₂ : Std.DHashMap α β} →
{motive : m₁.Equiv m₂ → Sort u_1} →
(t : m₁.Equiv m₂) → ((inner : m₁.inner.Equiv m₂.inner) → motive ⋯) → motive t | false |
Units.instMul | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → Mul αˣ | true |
CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeTop | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], ⊤.IsStableUnderBaseChange | true |
AlgebraNorm.ctorIdx | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
{inst : SeminormedCommRing R} → {S : Type u_2} → {inst_1 : Ring S} → {inst_2 : Algebra R S} → AlgebraNorm R S → ℕ | false |
CategoryTheory.MorphismProperty.LeftFraction₃.mk.inj | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C} {X Y Y' : C}
{f f' f'' : X ⟶ Y'} {s : Y ⟶ Y'} {hs : W s} {Y'_1 : C} {f_1 f'_1 f''_1 : X ⟶ Y'_1} {s_1 : Y ⟶ Y'_1} {hs_1 : W s_1},
{ Y' := Y', f := f, f' := f', f'' := f'', s := s, hs := hs } =
{ Y' := Y'_1, f... | true |
Set.iUnion_subset_iff._simp_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t | false |
Subalgebra.copy._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (s : Set A) (hs : s = ↑S), 0 ∈ (S.copy s hs).carrier | false |
Lean.Kernel.Diagnostics.mk.noConfusion | Lean.Environment | {P : Sort u} →
{unfoldCounter : Lean.PHashMap Lean.Name ℕ} →
{enabled : Bool} →
{unfoldCounter' : Lean.PHashMap Lean.Name ℕ} →
{enabled' : Bool} →
{ unfoldCounter := unfoldCounter, enabled := enabled } =
{ unfoldCounter := unfoldCounter', enabled := enabled' } →
(... | false |
OrderDual.instNonAssocRing._proof_3 | Mathlib.Algebra.Order.Ring.Synonym | ∀ {R : Type u_1} [h : NonAssocRing R], ↑0 = 0 | false |
Lean.Server.GoToKind.ctorIdx | Lean.Server.GoTo | Lean.Server.GoToKind → ℕ | false |
Matrix.IsAdjMatrix.toGraph_compl_eq | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq V] {A : Matrix V V α}
[inst_2 : MulZeroOneClass α] [inst_3 : Nontrivial α] (h : A.IsAdjMatrix), ⋯.toGraph = h.toGraphᶜ | true |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_9 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | false |
RootPairing.RootPositiveForm.form_apply_root_ne_zero | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing S]
[inst_1 : LinearOrder S] [inst_2 : CommRing R] [inst_3 : Algebra S R] [inst_4 : AddCommGroup M] [inst_5 : Module R M]
[inst_6 : AddCommGroup N] [inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsValuedIn S]
... | true |
Std.IterM.forIn_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type u_1} {γ α β : Type w} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_4 : Std.IteratorLoop α Id m] [Std.LawfulIteratorLoop α Id m] {it : Std.IterM Id β}
{f : β → γ → m (ForInStep γ)} {init : γ}, forIn it.toList.run init f = forIn it init f | true |
Simps.AutomaticProjectionData.recOn | Mathlib.Tactic.Simps.NotationClass | {motive : Simps.AutomaticProjectionData → Sort u} →
(t : Simps.AutomaticProjectionData) →
((className : Lean.Name) →
(isNotation : Bool) →
(findArgs : Lean.Name) → motive { className := className, isNotation := isNotation, findArgs := findArgs }) →
motive t | false |
List.Cursor.pos_at | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {n : ℕ}, n < l.length → (List.Cursor.at l n).pos = n | true |
Lean.getPPPiBinderNamesHygienic | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → Bool | true |
Finset.sum_range_diag_flip | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : AddCommMonoid M] (n : ℕ) (f : ℕ → ℕ → M),
∑ m ∈ Finset.range n, ∑ k ∈ Finset.range (m + 1), f k (m - k) =
∑ m ∈ Finset.range n, ∑ k ∈ Finset.range (n - m), f m k | true |
String.Slice.Pattern.Char.instToForwardSearcherCharDefaultForwardSearcher | Init.Data.String.Pattern.Char | {c : Char} → String.Slice.Pattern.ToForwardSearcher c (String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher c) | true |
Lean.Parser.Term.liftMethod | Lean.Parser.Do | Lean.Parser.Parser | true |
DiscreteUniformity.mk | Mathlib.Topology.UniformSpace.DiscreteUniformity | ∀ {X : Type u_1} [u : UniformSpace X], u = ⊥ → DiscreteUniformity X | true |
Representation.finsupp | Mathlib.RepresentationTheory.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : CommSemiring k] →
[inst_1 : Monoid G] →
{A : Type u_4} →
[inst_2 : AddCommMonoid A] →
[inst_3 : Module k A] → Representation k G A → (α : Type u_6) → Representation k G (α →₀ A) | true |
Std.DTreeMap.minKey?_eq_some_iff_mem_and_forall | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {km : α}, t.minKey? = some km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true | true |
ConditionallyCompletePartialOrderSup.noConfusionType | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | Sort u →
{α : Type u_3} →
ConditionallyCompletePartialOrderSup α → {α' : Type u_3} → ConditionallyCompletePartialOrderSup α' → Sort u | false |
instMonadEIO._aux_11 | Init.System.IO | {ε α β : Type} → EIO ε α → (Unit → EIO ε β) → EIO ε β | false |
ProofWidgets.Penrose.DiagramState.casesOn | ProofWidgets.Component.PenroseDiagram | {motive : ProofWidgets.Penrose.DiagramState → Sort u} →
(t : ProofWidgets.Penrose.DiagramState) →
((sub : String) →
(embeds : Std.HashMap String (String × ProofWidgets.Html)) → motive { sub := sub, embeds := embeds }) →
motive t | false |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.IsSemisimpleModule.sSup_simples_le._simp_1_1 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m : Submodule R M},
IsSimpleModule R ↥m = IsAtom m | false |
Set.finite_iff_finite_of_encard_eq_encard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, s.encard = t.encard → (s.Finite ↔ t.Finite) | true |
LipschitzOnWith.prodMk | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {s : Set α} {f : α → β} {g : α → γ} {Kf Kg : NNReal},
LipschitzOnWith Kf f s → LipschitzOnWith Kg g s → LipschitzOnWith (max Kf Kg) (fun x => (f x, g x)) s | true |
Lean.Meta.Hint.tryThisDiffWidget | Lean.Meta.Hint | Lean.Widget.Module | true |
NonarchAddGroupSeminorm.coe_iSup_apply | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {ι : Type u_6} (f : ι → NonarchAddGroupSeminorm E),
BddAbove (Set.range f) → ∀ {x : E}, (⨆ i, f i) x = ⨆ i, (f i) x | true |
Prod.mk_lt_mk_iff_right._gcongr_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {a : α} {b₁ b₂ : β},
b₁ < b₂ → (a, b₁) < (a, b₂) | false |
instIsSemisimpleModuleOfIsSimpleModule | Mathlib.RingTheory.SimpleModule.Basic | ∀ (R : Type u_2) [inst : Ring R] (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSimpleModule R M],
IsSemisimpleModule R M | true |
_private.Mathlib.Tactic.Ring.Compare.0.Mathlib.Tactic.Ring.proveLE.match_4 | Mathlib.Tactic.Ring.Compare | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((α e₁ e₂ : Lean.Expr) → motive (some (α, e₁, e₂))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | false |
Orientation.kahler._proof_1 | Mathlib.Analysis.InnerProductSpace.TwoDim | SMulCommClass ℝ ℝ ℂ | false |
_private.Mathlib.GroupTheory.DoubleCoset.0.DoubleCoset.mem_doubleCoset_of_not_disjoint._simp_1_1 | Mathlib.GroupTheory.DoubleCoset | ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a b : α},
(b ∈ DoubleCoset.doubleCoset a s t) = ∃ x ∈ s, ∃ y ∈ t, b = x * a * y | false |
Polynomial.modByMonic_eq_of_dvd_sub | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {p₁ p₂ q : Polynomial R}, q.Monic → q ∣ p₁ - p₂ → p₁ %ₘ q = p₂ %ₘ q | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRatAdd_insert._proof_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (i : ℕ), i + 1 ≤ { toList := [] }.size → i < { toList := [] }.size | false |
Char.utf8Size_eq_one_iff | Init.Data.String.Decode | ∀ {c : Char}, c.utf8Size = 1 ↔ c.val ≤ 127 | true |
Lean.Meta.Grind.TopSort.State.mk | Lean.Meta.Tactic.Grind.EqResolution | Std.HashSet Lean.Expr → Std.HashSet Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.TopSort.State | true |
LinearMap.coe_smul | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {R₂ : Type u_3} {S : Type u_5} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_6 : DistribSMul S M₂] [inst_7 : SMulCommClass R₂ S M₂] (a : S)
(f :... | true |
_private.Mathlib.RingTheory.Ideal.Quotient.PowTransition.0.Submodule.factorPow_comp_powSMulQuotInclusion._proof_3 | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {a b c d e : ℕ}, c = b + a → e = d + c → e = b + d + a | false |
SimpleGraph.decidableMemCommonNeighbors._aux_1 | Mathlib.Combinatorics.SimpleGraph.Basic | {V : Type u_1} →
(G : SimpleGraph V) → [DecidableRel G.Adj] → (v w : V) → DecidablePred fun x => x ∈ G.commonNeighbors v w | false |
Module.ringKrullDim_quotient_add_one_of_mem_nonZeroDivisors | Mathlib.RingTheory.KrullDimension.Regular | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] {r : R},
r ∈ nonZeroDivisors R →
∀ {p : Ideal R} [p.IsPrime],
↑p.height = ringKrullDim R → r ∈ p → ringKrullDim (R ⧸ Ideal.span {r}) + 1 = ringKrullDim R | true |
Lean.Server.Test.Runner.RunnerState.method | Lean.Server.Test.Runner | Lean.Server.Test.Runner.RunnerState → String | true |
Aesop.TreeRef.recOn | Aesop.Tree.Traversal | {motive : Aesop.TreeRef → Sort u} →
(t : Aesop.TreeRef) →
((gref : Aesop.GoalRef) → motive (Aesop.TreeRef.goal gref)) →
((rref : Aesop.RappRef) → motive (Aesop.TreeRef.rapp rref)) →
((cref : Aesop.MVarClusterRef) → motive (Aesop.TreeRef.mvarCluster cref)) → motive t | false |
CauSeq.const.congr_simp | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] (abv : β → α) [inst_4 : IsAbsoluteValue abv] (x x_1 : β),
x = x_1 → CauSeq.const abv x = CauSeq.const abv x_1 | true |
HomologicalComplex.mapBifunctor₁₂.ι_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | true |
Std.Net.instDecidableEqIPv4Addr.decEq.match_1 | Std.Net.Addr | (motive : Std.Net.IPv4Addr → Std.Net.IPv4Addr → Sort u_1) →
(x x_1 : Std.Net.IPv4Addr) → ((a b : Vector UInt8 4) → motive { octets := a } { octets := b }) → motive x x_1 | false |
omegaToLiaRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config | true |
CantorScheme.ClosureAntitone | Mathlib.Topology.MetricSpace.CantorScheme | {β : Type u_1} → {α : Type u_2} → (List β → Set α) → [TopologicalSpace α] → Prop | true |
List.foldrM_filterMap | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : α → Option β} {g : β → γ → m γ} {l : List α} {init : γ},
List.foldrM g init (List.filterMap f l) =
List.foldrM
(fun x y =>
match f x with
| some b => g b y
| none => pure ... | true |
Std.HashMap.Raw.getKey!_emptyWithCapacity | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : Inhabited α] {a : α} {c : ℕ},
(Std.HashMap.Raw.emptyWithCapacity c).getKey! a = default | true |
CategoryTheory.Functor.HomObj.comp_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {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} {A : CategoryTheory.Functor C (Type w)} {M : CategoryTheory.Functor C D}
(f : F.HomObj G A) (g : G.HomObj M A) (X : C) (a : A.obj X),
(f.comp g).app X a = Categor... | true |
Vector.exists_of_mem_flatMap | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {n m : ℕ} {b : β} {xs : Vector α n} {f : α → Vector β m},
b ∈ xs.flatMap f → ∃ a ∈ xs, b ∈ f a | true |
NumberField.recOn | Mathlib.NumberTheory.NumberField.Basic | {K : Type u_1} →
[inst : Field K] →
{motive : NumberField K → Sort u} →
(t : NumberField K) →
([to_charZero : CharZero K] → [to_finiteDimensional : FiniteDimensional ℚ K] → motive ⋯) → motive t | false |
nhds_le_nhdsSet | Mathlib.Topology.NhdsSet | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} {x : X}, x ∈ s → nhds x ≤ nhdsSet s | true |
Matroid.spanning_iff_compl_coindep | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {S : Set α},
autoParam (S ⊆ M.E) Matroid.spanning_iff_compl_coindep._auto_1 → (M.Spanning S ↔ M.Coindep (M.E \ S)) | true |
NumberField.Units.dirichletUnitTheorem.mult_log_place_eq_zero | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {K : Type u_1} [inst : Field K] {x : (NumberField.RingOfIntegers K)ˣ} {w : NumberField.InfinitePlace K},
↑w.mult * Real.log (w ((algebraMap (NumberField.RingOfIntegers K) K) ↑x)) = 0 ↔
w ((algebraMap (NumberField.RingOfIntegers K) K) ↑x) = 1 | true |
Array.getElem_shrink._proof_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, j < (xs.shrink i).size → j < xs.size | false |
Module.Presentation.tautological.R.recOn | Mathlib.Algebra.Module.Presentation.Tautological | {A : Type u} →
{M : Type v} →
{motive : Module.Presentation.tautological.R A M → Sort u_1} →
(t : Module.Presentation.tautological.R A M) →
((m₁ m₂ : M) → motive (Module.Presentation.tautological.R.add m₁ m₂)) →
((a : A) → (m : M) → motive (Module.Presentation.tautological.R.smul a m)) → m... | false |
List.Perm.length_eq | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Perm l₂ → l₁.length = l₂.length | true |
CategoryTheory.Limits.ChosenPullback.p₂ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ S : C} →
{f₁ : X₁ ⟶ S} → {f₂ : X₂ ⟶ S} → (self : CategoryTheory.Limits.ChosenPullback f₁ f₂) → self.pullback ⟶ X₂ | true |
CategoryTheory.ObjectProperty.prop_cokernel | Mathlib.CategoryTheory.ObjectProperty.Kernels | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P : CategoryTheory.ObjectProperty C) [P.IsClosedUnderCokernels] {X Y : C} (f : X ⟶ Y)
[inst_3 : CategoryTheory.Limits.HasCokernel f], P X → P Y → P (CategoryTheory.Limits.cokernel f) | true |
_private.Init.Data.List.Attach.0.List.pmap_eq_pmapImpl.match_1_1 | Init.Data.List.Attach | (α : Type u_1) →
(p : α → Prop) →
(motive : Subtype p → Sort u_2) → (x : Subtype p) → ((x : α) → (hx : p x) → motive ⟨x, hx⟩) → motive x | false |
Std.Rxi.Iterator.toList_eq_match | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.Rxi.IsAlwaysFinite α] [Std.PRange.LawfulUpwardEnumerable α]
{it : Std.Iter α},
it.toList =
match it.internalState.next with
| none => []
| some a => a :: { internalState := { next := Std.PRange.succ? a } }.toList | true |
measurable_of_countable | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [Countable α]
[MeasurableSingletonClass α] (f : α → β), Measurable f | true |
_private.Init.Data.List.Impl.0.List.takeWhileTR.go | Init.Data.List.Impl | {α : Type u_1} → (α → Bool) → List α → List α → Array α → List α | true |
Polynomial.X_pow_sub_one_separable_iff | Mathlib.FieldTheory.Separable | ∀ {F : Type u} [inst : Field F] {n : ℕ}, (Polynomial.X ^ n - 1).Separable ↔ ↑n ≠ 0 | true |
Complex.ofReal_comp_pow | Mathlib.Data.Complex.Basic | ∀ {α : Type u_1} (f : α → ℝ) (n : ℕ), Complex.ofReal ∘ (f ^ n) = Complex.ofReal ∘ f ^ n | true |
Matroid.Nonempty.casesOn | Mathlib.Combinatorics.Matroid.Basic | {α : Type u_1} →
{M : Matroid α} →
{motive : M.Nonempty → Sort u} → (t : M.Nonempty) → ((ground_nonempty : M.E.Nonempty) → motive ⋯) → motive t | false |
List.forall_iff_forall_mem | Mathlib.Data.List.Basic | ∀ {α : Type u} {p : α → Prop} {l : List α}, List.Forall p l ↔ ∀ x ∈ l, p x | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.eigenspace_restrict_le_eigenspace._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
PreOpposite.op'.inj | Mathlib.Algebra.Opposites | ∀ {α : Type u_3} {unop' unop'_1 : α}, { unop' := unop' } = { unop' := unop'_1 } → unop' = unop'_1 | true |
LieSubmodule.gi._proof_2 | Mathlib.Algebra.Lie.Submodule | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : Set M),
↑(LieSubmodule.lieSpan R L x) ≤ x → LieSubmodule.lieSpan R L x = LieSubmodule.lieSpan R L x | false |
Std.TreeSet.foldrM_eq_foldrM_toList | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
[LawfulMonad m] {f : α → δ → m δ} {init : δ}, Std.TreeSet.foldrM f init t = List.foldrM f init t.toList | true |
_private.Mathlib.CategoryTheory.Iso.0.CategoryTheory.Iso.cancel_iso_hom_right_assoc._simp_1_2 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Y ⟶ X) [CategoryTheory.Mono f] {g h : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) | false |
CategoryTheory.Abelian.Ext.homEquiv₀_symm_apply | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (a : X ⟶ Y),
CategoryTheory.Abelian.Ext.homEquiv₀.symm a = CategoryTheory.Abelian.Ext.mk₀ a | true |
AddCommute.map | Mathlib.Algebra.Group.Commute.Hom | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : Add N] {x y : M} [inst_2 : FunLike F M N]
[AddHomClass F M N], AddCommute x y → ∀ (f : F), AddCommute (f x) (f y) | true |
PNat.toPNat'_coe | Mathlib.Data.PNat.Defs | ∀ {n : ℕ}, 0 < n → ↑n.toPNat' = n | true |
CategoryTheory.JointlyFaithful | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_4, u_1} C] →
{I : Type u_2} →
{D : I → Type u_3} →
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] →
((i : I) → CategoryTheory.Functor C (D i)) → Prop | true |
WeierstrassCurve.Jacobian.Point.toAffineLift_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F} (hP : W.NonsingularLift ⟦P⟧),
P 2 = 0 → { point := ⟦P⟧, nonsingular := hP }.toAffineLift = 0 | true |
strictConvexOn_of_deriv2_pos | Mathlib.Analysis.Convex.Deriv | ∀ {D : Set ℝ},
Convex ℝ D → ∀ {f : ℝ → ℝ}, ContinuousOn f D → (∀ x ∈ interior D, 0 < deriv^[2] f x) → StrictConvexOn ℝ D f | true |
CategoryTheory.Monad.forgetCreatesColimits | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} →
[CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, v₁, v₁, u₁, u₁} T.toFunctor] →
CategoryTheory.CreatesColimitsOfSize.{v, u, v₁, v₁, max u₁ v₁, u₁} T.forget | true |
Ring.instIsDomainNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S], IsDomain (Ring.NormalClosure R S) | true |
Rat.commRing._proof_11 | Mathlib.Algebra.Ring.Rat | ∀ (a : ℚ), SubNegMonoid.zsmul 0 a = 0 | false |
Lean.Level.PP.Result.maxNode.noConfusion | Lean.Level | {P : Sort u} →
{a a' : List Lean.Level.PP.Result} →
Lean.Level.PP.Result.maxNode a = Lean.Level.PP.Result.maxNode a' → (a = a' → P) → P | false |
HahnEmbedding.Seed.mk.sizeOf_spec | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[ins... | true |
Std.HashMap.Raw.distinct_keys | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → List.Pairwise (fun a b => (a == b) = false) m.keys | true |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_6 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules) (f : (↑R)ᵒᵖ)
(x : ↥(Submonoid.powers (Opposite.unop f))),
IsUnit
((algebraMap (↑R)
(Module.End ↑R
↑((AlgebraicGeometry.modulesSpecToSheaf.obj M).obj.obj
(Opposite.op ((CategoryTheory.inducedFunctor Pri... | false |
Lean.Lsp.TextDocumentSyncOptions.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{t t' : Lean.Lsp.TextDocumentSyncOptions} → t = t' → Lean.Lsp.TextDocumentSyncOptions.noConfusionType P t t' | false |
hasCardinalLT_iff_cardinal_mk_lt | Mathlib.SetTheory.Cardinal.HasCardinalLT | ∀ (X : Type u) (κ : Cardinal.{u}), HasCardinalLT X κ ↔ Cardinal.mk X < κ | true |
FreeLieAlgebra.Rel.smulOfTower | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] {S : Type u_1} [inst_1 : Monoid S] [inst_2 : DistribMulAction S R]
[IsScalarTower S R R] (t : S) (a b : FreeNonUnitalNonAssocAlgebra R X),
FreeLieAlgebra.Rel R X a b → FreeLieAlgebra.Rel R X (t • a) (t • b) | true |
Associates.factors_subsingleton | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [Subsingleton α]
{a : Associates α}, a.factors = ⊤ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.