name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
OrderDual.instModule' | Mathlib.Algebra.Order.Module.Synonym | {α : Type u_1} → {β : Type u_2} → [inst : Semiring α] → [inst_1 : AddCommMonoid β] → [Module α β] → Module α βᵒᵈ | true |
CStarMatrix.instAddCommGroupWithOne._proof_1 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {n : Type u_1} {A : Type u_2} [inst : DecidableEq n] [inst_1 : AddCommGroupWithOne A],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | false |
Nonneg.semiring._proof_16 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : ZeroLEOneClass α] [inst_3 : PosMulMono α]
(x : { x // 0 ≤ x }) (x_1 : ℕ), ↑(x ^ x_1) = ↑(x ^ x_1) | false |
CategoryTheory.ShortComplex.Splitting.unop_r | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex Cᵒᵖ} (h : S.Splitting), h.unop.r = h.s.unop | true |
Std.ExtTreeMap.maxKey?_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {km : α},
t.maxKey? = some km → km ∈ t | true |
Lean.Server.Watchdog.WorkerEvent.crashed.injEq | Lean.Server.Watchdog | ∀ (exitCode exitCode_1 : UInt32),
(Lean.Server.Watchdog.WorkerEvent.crashed exitCode = Lean.Server.Watchdog.WorkerEvent.crashed exitCode_1) =
(exitCode = exitCode_1) | true |
Lean.Doc.Syntax.metadataContents | Lean.DocString.Syntax | Lean.Parser.Parser | true |
Monoid.exponent_multiplicative | Mathlib.GroupTheory.Exponent | ∀ {G : Type u_1} [inst : AddMonoid G], Monoid.exponent (Multiplicative G) = AddMonoid.exponent G | true |
_private.Mathlib.Order.Filter.AtTopBot.Group.0.Filter.tendsto_comp_inv_atTop_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Group | ∀ {α : Sort u_1} {β : Sort u_2} {δ : Sort u_3} (f : β → δ) (g : α → β), (fun x => f (g x)) = f ∘ g | false |
instFieldCyclotomicField._aux_34 | Mathlib.NumberTheory.Cyclotomic.Basic | (n : ℕ) → (K : Type u_1) → [inst : Field K] → CyclotomicField n K → CyclotomicField n K → CyclotomicField n K | false |
Array.forall_mem_ne' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (∀ a' ∈ xs, ¬a' = a) ↔ a ∉ xs | true |
Real.RingHom.unique._proof_2 | Mathlib.Data.Real.Hom | ∀ (f : ℝ →+* ℝ), { toRingHom := f, monotone' := ⋯ }.toRingHom = default.toRingHom | false |
Std.HashMap.keys | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List α | true |
Std.Net.IPAddr.family.match_1 | Std.Net.Addr | (motive : Std.Net.IPAddr → Sort u_1) →
(x : Std.Net.IPAddr) →
((addr : Std.Net.IPv4Addr) → motive (Std.Net.IPAddr.v4 addr)) →
((addr : Std.Net.IPv6Addr) → motive (Std.Net.IPAddr.v6 addr)) → motive x | false |
BitVec.reduceGE._regBuiltin.BitVec.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.776923109._hygCtx._hyg.25 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | false |
DirichletCharacter.convolution_twist_vonMangoldt | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N),
(LSeries.convolution ((fun n => χ ↑n) * fun n => ↑(ArithmeticFunction.vonMangoldt n)) fun n => χ ↑n) =
(fun n => χ ↑n) * fun n => Complex.log ↑n | true |
Lean.Language.Lean.HeaderParsedSnapshot.mk | Lean.Language.Lean.Types | Lean.Language.Snapshot →
Lean.Language.SnapshotTask Lean.Language.SnapshotLeaf →
Lean.Parser.InputContext →
Lean.Syntax → Option Lean.Language.Lean.HeaderParsedState → Lean.Language.Lean.HeaderParsedSnapshot | true |
LocallyFinite.Realizer.recOn | Mathlib.Data.Analysis.Topology | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
{F : Ctop.Realizer α} →
{f : β → Set α} →
{motive : LocallyFinite.Realizer F f → Sort u} →
(t : LocallyFinite.Realizer F f) →
((bas : (a : α) → { s // a ∈ F.F.f s }) →
(sets : (x : α) → Fintype ↑{i | (f i ∩ F.F.f ↑(bas x)).Nonempty}) →
motive { bas := bas, sets := sets }) →
motive t | false |
AlgebraicGeometry.structurePresheafInModuleCat | Mathlib.AlgebraicGeometry.StructureSheaf | (R M : Type u) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [Module R M] → TopCat.Presheaf (ModuleCat R) (AlgebraicGeometry.PrimeSpectrum.Top R) | true |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'.match_1_11 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {R : Type u_2} {S : Type u_1} [inst : Ring R] [inst_1 : StarMul R] [inst_2 : CommRing S] [inst_3 : Algebra S R]
(u v : ↥(unitary R)) (motive : (∃ y, y • 1 = star ↑v * ↑u) → Prop) (x : ∃ y, y • 1 = star ↑v * ↑u),
(∀ (y : S) (h : y • 1 = star ↑v * ↑u), motive ⋯) → motive x | false |
Lean.Parser.Term.inaccessible._regBuiltin.Lean.Parser.Term.inaccessible_1 | Lean.Parser.Term | IO Unit | false |
Monoid.CoprodI.Word.equivPair._proof_1 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] (i : ι) (w : Monoid.CoprodI.Word M),
Monoid.CoprodI.Word.rcons ↑(Monoid.CoprodI.Word.equivPairAux✝ i w) = w | false |
CategoryTheory.Bicategory.rightUnitorNatIsoCat_hom_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (a b : B) (X : a ⟶ b),
(CategoryTheory.Bicategory.rightUnitorNatIsoCat a b).hom.toNatTrans.app X =
(CategoryTheory.Bicategory.rightUnitor X).hom | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.iteratedDerivWithin_tsum_exp_aux_eq._simp_1_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {G : Type u_3} [inst : InvolutiveNeg G] {a b : G}, (-a = -b) = (a = b) | false |
Configuration.Nondegenerate.exists_line | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.Nondegenerate P L] (p : P), ∃ l, p ∉ l | true |
CategoryTheory.Functor.Final.coconesEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_4}
[inst_3 : CategoryTheory.Category.{u_2, u_4} E] (G : CategoryTheory.Functor D E)
{X Y : CategoryTheory.Limits.Cocone (F.comp G)} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (F.comp G))).map f)
((fun c =>
CategoryTheory.Limits.Cocone.ext
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (F.comp G))).obj c).pt)
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun c =>
CategoryTheory.Limits.Cocone.ext
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone (F.comp G))).obj c).pt)
⋯)
X).hom
((CategoryTheory.Functor.Final.extendCocone.comp (CategoryTheory.Limits.Cocone.whiskering F)).map f) | false |
Nat.EqResult.eq.injEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | ∀ (x y p x_1 y_1 p_1 : Lean.Expr), (Nat.EqResult.eq x y p = Nat.EqResult.eq x_1 y_1 p_1) = (x = x_1 ∧ y = y_1 ∧ p = p_1) | true |
ContMDiffMap.restrictMonoidHom._proof_1 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E'] {H : Type u_3}
[inst_5 : TopologicalSpace H] (I : ModelWithCorners 𝕜 E H) {H' : Type u_6} [inst_6 : TopologicalSpace H']
(I' : ModelWithCorners 𝕜 E' H') {N : Type u_4} [inst_7 : TopologicalSpace N] [inst_8 : ChartedSpace H N]
{n : WithTop ℕ∞} (G : Type u_7) [inst_9 : TopologicalSpace G] [inst_10 : ChartedSpace H' G]
{U V : TopologicalSpace.Opens N} (h : U ≤ V) (f : ContMDiffMap I I' (↥V) G n), ContMDiff I I' n (⇑f ∘ Set.inclusion h) | false |
mellinConvergent_of_isBigO_rpow_exp | Mathlib.Analysis.MellinTransform | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {a b : ℝ},
0 < a →
∀ {f : ℝ → E} {s : ℂ},
MeasureTheory.LocallyIntegrableOn f (Set.Ioi 0) MeasureTheory.volume →
(f =O[Filter.atTop] fun t => Real.exp (-a * t)) →
(f =O[nhdsWithin 0 (Set.Ioi 0)] fun x => x ^ (-b)) → b < s.re → MellinConvergent f s | true |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.w_spec | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution✝ hζ),
FermatLastTheoremForThreeGen.Solution'.c✝ (FermatLastTheoremForThreeGen.Solution.toSolution'✝ S) =
(hζ.toInteger - 1) ^ FermatLastTheoremForThreeGen.Solution.multiplicity✝ S *
FermatLastTheoremForThreeGen.Solution.w✝ S | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.Consumer.ctorIdx | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded.Consumer✝ α → ℕ | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.casesExpand.match_19 | Batteries.CodeAction.Misc | (motive : Option (Array (Lean.Name × Array Lean.Name)) → Sort u_1) →
(__discr : Option (Array (Lean.Name × Array Lean.Name))) →
((ctors : Array (Lean.Name × Array Lean.Name)) → motive (some ctors)) →
((x : Option (Array (Lean.Name × Array Lean.Name))) → motive x) → motive __discr | false |
AddAction.stabilizerEquivStabilizer_trans | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] {g h k : G} {a b c : α} (hg : b = g +ᵥ a)
(hh : c = h +ᵥ b) (hk : c = k +ᵥ a),
k = h + g →
(AddAction.stabilizerEquivStabilizer hg).trans (AddAction.stabilizerEquivStabilizer hh) =
AddAction.stabilizerEquivStabilizer hk | true |
Lean.Meta.Grind.SymbolPriorityEntry.mk.noConfusion | Lean.Meta.Tactic.Grind.EMatchTheorem | {P : Sort u} →
{declName : Lean.Name} →
{prio : ℕ} →
{declName' : Lean.Name} →
{prio' : ℕ} →
{ declName := declName, prio := prio } = { declName := declName', prio := prio' } →
(declName = declName' → prio = prio' → P) → P | false |
BoundedOrderHomClass.toBotHomClass | Mathlib.Order.Hom.Bounded | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : LE α] [inst_2 : LE β]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [BoundedOrderHomClass F α β], BotHomClass F α β | true |
_private.Mathlib.Topology.UniformSpace.Defs.0.UniformSpace.hasBasis_nhds._simp_1_2 | Mathlib.Topology.UniformSpace.Defs | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | false |
Std.Iterators.Types.Zip.instFinite₂ | Std.Data.Iterators.Combinators.Monadic.Zip | ∀ {m : Type w → Type w'} {α₁ β₁ : Type w} [inst : Std.Iterator α₁ m β₁] {α₂ β₂ : Type w} [inst_1 : Std.Iterator α₂ m β₂]
[inst_2 : Monad m] [Std.Iterators.Productive α₁ m] [Std.Iterators.Finite α₂ m],
Std.Iterators.Finite (Std.Iterators.Types.Zip α₁ m α₂ β₂) m | true |
Std.TransCmp.lt_of_eq_of_lt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {a b c : α},
cmp a b = Ordering.eq → cmp b c = Ordering.lt → cmp a c = Ordering.lt | true |
List.insert_of_not_mem | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a : α} {l : List α}, a ∉ l → List.insert a l = a :: l | true |
Real.denselyNormedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (x x_1 : ℝ), 0 ≤ x → x < x_1 → ∃ a, x < ‖a‖ ∧ ‖a‖ < x_1 | false |
_private.Mathlib.Data.Seq.Basic.0.Stream'.Seq.at_least_as_long_as_coind._simp_1_8 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s : Stream'.Seq α), (s = Stream'.Seq.nil) = (s.length' = 0) | false |
StrictMonoOn.mapsTo_Ioc | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : PartialOrder α] [inst_1 : Preorder β] {a b : α},
StrictMonoOn f (Set.Icc a b) → Set.MapsTo f (Set.Ioc a b) (Set.Ioc (f a) (f b)) | true |
_private.Init.Data.String.Iterate.0.String.Slice.ByteIterator.finitenessRelation._proof_2 | Init.Data.String.Iterate | ∀ {m : Type → Type u_1},
WellFounded
(InvImage WellFoundedRelation.rel fun it => it.internalState.s.utf8ByteSize - it.internalState.offset.byteIdx) | false |
Std.DTreeMap.Internal.Impl.getKeyD_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKeyD k fallback = fallback | true |
AddSubgroup.card_dvd_of_injective | Mathlib.GroupTheory.Coset.Card | ∀ {α : Type u_1} [inst : AddGroup α] {H : Type u_2} [inst_1 : AddGroup H] (f : α →+ H),
Function.Injective ⇑f → Nat.card α ∣ Nat.card H | true |
OrderHom.apply | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : Preorder α] → [inst_1 : Preorder β] → α → (α →o β) →o β | true |
Manifold.«_aux_Mathlib_Geometry_Manifold_Instances_Real___macroRules_Manifold_term𝓡∂__1» | Mathlib.Geometry.Manifold.Instances.Real | Lean.Macro | false |
CompleteDistribLattice.toHNot | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} → [self : CompleteDistribLattice α] → HNot α | true |
MeasurableEquiv.piFinSuccAbove_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_8) [inst : (i : Fin (n + 1)) → MeasurableSpace (α i)] (i : Fin (n + 1)),
⇑(MeasurableEquiv.piFinSuccAbove α i) = ⇑(Fin.insertNthEquiv α i).symm | true |
LieAlgebra.radical_eq_top_of_isSolvable | Mathlib.Algebra.Lie.Solvable | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[LieAlgebra.IsSolvable L], LieAlgebra.radical R L = ⊤ | true |
String.all_iff | Batteries.Data.String.Lemmas | ∀ (s : String) (p : Char → Bool), String.Legacy.all s p = true ↔ ∀ c ∈ s.toList, p c = true | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_lt._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α} {p : α → Bool} {s : ℕ},
i < (List.findIdxs p xs s).length → 0 < (List.findIdxs p xs s).length | false |
Substring.Raw.toString | Init.Data.String.Substring | Substring.Raw → String | true |
Lean.Parser.antiquotExpr | Lean.Parser.Basic | Lean.Parser.Parser | true |
ZFSet.vonNeumann_subset_vonNeumann_iff | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, ZFSet.vonNeumann a ⊆ ZFSet.vonNeumann b ↔ a ≤ b | true |
Finpartition.ofSubset._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] {a : α} (P : Finpartition a) {parts : Finset α},
parts ⊆ P.parts → ⊥ ∈ parts → False | false |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.asymptoticCone_union._simp_1_2 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] {v : V} {s : Set P},
(v ∈ asymptoticCone k s) = ∃ᶠ (p : P) in AffineSpace.asymptoticNhds k P v, p ∈ s | false |
Finsupp.instNonUnitalRing._proof_4 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalRing β] (g₁ g₂ : α →₀ β), ⇑(g₁ * g₂) = ⇑g₁ * ⇑g₂ | false |
KaehlerDifferential.map_D | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (A : Type u_2)
(B : Type u_3) [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra A B]
[inst_7 : Algebra S B] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTower R S B]
[inst_11 : SMulCommClass S A B] (x : A),
(KaehlerDifferential.map R S A B) ((KaehlerDifferential.D R A) x) = (KaehlerDifferential.D S B) ((algebraMap A B) x) | true |
_private.Mathlib.MeasureTheory.Measure.Haar.OfBasis.0.Module.Basis.parallelepiped._simp_5 | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ (α : Sort u), (∀ (a : α), True) = True | false |
Option.toArray_eq_empty_iff._simp_1 | Init.Data.Option.Array | ∀ {α : Type u_1} {o : Option α}, (o.toArray = #[]) = (o = none) | false |
_private.Lean.Meta.InferType.0.Lean.Meta.typeFormerTypeLevel.go.match_1 | Lean.Meta.InferType | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((l : Lean.Level) → motive (Lean.Expr.sort l)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((x : Lean.Expr) → motive x) → motive type | false |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsEulerian.card_filter_odd_degree._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
CategoryTheory.MorphismProperty.exists_isPushout_of_isFiltered | Mathlib.CategoryTheory.MorphismProperty.Ind | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.MorphismProperty C}
[self : P.PreIndSpreads] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J] [CategoryTheory.IsFiltered J]
{D : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone D} (x : CategoryTheory.Limits.IsColimit c) {T : C}
(f : c.pt ⟶ T), P f → ∃ j T' f' g, CategoryTheory.IsPushout (c.ι.app j) f' f g ∧ P f' | true |
CategoryTheory.Mod_._sizeOf_1 | Mathlib.CategoryTheory.Monoidal.Mod_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{D : Type u₂} →
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} →
{inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D} →
{A : C} → {inst_4 : CategoryTheory.MonObj A} → [SizeOf C] → [SizeOf D] → CategoryTheory.Mod_ D A → ℕ | false |
PseudoMetricSpace.ofDistTopology._proof_3 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} [inst : TopologicalSpace α] (dist : α → α → ℝ) (dist_self : ∀ (x : α), dist x x = 0)
(dist_comm : ∀ (x y : α), dist x y = dist y x) (dist_triangle : ∀ (x y z : α), dist x z ≤ dist x y + dist y z)
(H : ∀ (s : Set α), IsOpen s ↔ ∀ x ∈ s, ∃ ε > 0, ∀ (y : α), dist x y < ε → y ∈ s), uniformity α = uniformity α | false |
Stream'.Seq.set_cons_zero | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (hd : α) (tl : Stream'.Seq α) (hd' : α), (Stream'.Seq.cons hd tl).set 0 hd' = Stream'.Seq.cons hd' tl | true |
Int8.neg_sub | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, -(a - b) = b - a | true |
Matroid.loopyOn_isBasis_iff._simp_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, (Matroid.loopyOn E).IsBasis I X = (I = ∅ ∧ X ⊆ E) | false |
CategoryTheory.NatTrans.IsMonoidal.instHomFunctorAssociator | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D] {E : Type u₃}
[inst_4 : CategoryTheory.Category.{v₃, u₃} E] [inst_5 : CategoryTheory.MonoidalCategory E] {E' : Type u₄}
[inst_6 : CategoryTheory.Category.{v₄, u₄} E'] [inst_7 : CategoryTheory.MonoidalCategory E']
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) (H : CategoryTheory.Functor E E')
[inst_8 : F.LaxMonoidal] [inst_9 : G.LaxMonoidal] [inst_10 : H.LaxMonoidal],
CategoryTheory.NatTrans.IsMonoidal (F.associator G H).hom | true |
AlgebraicGeometry.Scheme.Pullback.base_affine_hasPullback | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {C : CommRingCat} {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ AlgebraicGeometry.Spec C)
(g : Y ⟶ AlgebraicGeometry.Spec C), CategoryTheory.Limits.HasPullback f g | true |
_private.Mathlib.Data.Option.NAry.0.Option.map₂_assoc._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_4} {β : Type u_5} {γ : Type u_3} {δ : Type u_2} {a : Option α} {b : Option β} {c : Option γ}
{ε : Type u_1} {ε' : Type u_6} {f : δ → γ → ε} {g : α → β → δ} {f' : α → ε' → ε} {g' : β → γ → ε'},
(∀ (a : α) (b : β) (c : γ), f (g a b) c = f' a (g' b c)) →
Option.map₂ f (Option.map₂ g a b) c = Option.map₂ f' a (Option.map₂ g' b c) | false |
ZFSet.Subset | Mathlib.SetTheory.ZFC.Basic | ZFSet.{u} → ZFSet.{u} → Prop | true |
CategoryTheory.Limits.sigmaConst_obj_map | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C] (X : C)
{X_1 Y : Type w} (f : X_1 ⟶ Y),
(CategoryTheory.Limits.sigmaConst.obj X).map f =
CategoryTheory.Limits.Sigma.map' f fun x => CategoryTheory.CategoryStruct.id X | true |
Std.ExtDTreeMap.Const.get_insertMany_list_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l →
∀ {h' : k' ∈ Std.ExtDTreeMap.Const.insertMany t l},
Std.ExtDTreeMap.Const.get (Std.ExtDTreeMap.Const.insertMany t l) k' h' = v | true |
_private.Mathlib.Topology.Algebra.Constructions.0.Units.isOpenMap_map.match_1_9 | Mathlib.Topology.Algebra.Constructions | ∀ {M : Type u_1} {N : Type u_2} [inst : Monoid M] [inst_1 : Monoid N] {f : M →* N} (U : Set (M × Mᵐᵒᵖ)) (y : Nˣ)
(motive : (∃ x, (↑x, MulOpposite.op ↑x⁻¹) ∈ U ∧ (Units.map f) x = y) → Prop)
(x : ∃ x, (↑x, MulOpposite.op ↑x⁻¹) ∈ U ∧ (Units.map f) x = y),
(∀ (x : Mˣ) (hxV : (↑x, MulOpposite.op ↑x⁻¹) ∈ U) (hx : (Units.map f) x = y), motive ⋯) → motive x | false |
KaehlerDifferential.linearCombination_surjective | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u) (S : Type v) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Function.Surjective ⇑(Finsupp.linearCombination S ⇑(KaehlerDifferential.D R S)) | true |
UniformEquiv.refl_symm | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} [inst : UniformSpace α], (UniformEquiv.refl α).symm = UniformEquiv.refl α | true |
_private.Init.Data.List.Nat.TakeDrop.0.List.mem_drop_iff_getElem._proof_1_2 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i : ℕ} {l : List α} (i_1 : ℕ), i_1 + i < l.length → ¬i_1 < l.length - i → False | false |
Lean.Widget.RpcEncodablePacket._sizeOf_1._@.Lean.Widget.InteractiveDiagnostic.1765450820._hygCtx._hyg.1 | Lean.Widget.InteractiveDiagnostic | Lean.Widget.RpcEncodablePacket✝ → ℕ | false |
Turing.TM0.Stmt.move.elim | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{motive : Turing.TM0.Stmt Γ → Sort u} →
(t : Turing.TM0.Stmt Γ) → t.ctorIdx = 0 → ((a : Turing.Dir) → motive (Turing.TM0.Stmt.move a)) → motive t | false |
MulOneClass.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {M : Type u} → (one : M) → (mul : M → M → M) → (∀ (a : M), 1 * a = a) → (∀ (a : M), a * 1 = a) → MulOneClass M | false |
List.Nodup.count | Init.Data.List.Pairwise | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {l : List α},
l.Nodup → List.count a l = if a ∈ l then 1 else 0 | true |
Fin.coe_castPred | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 1)) (h : i ≠ Fin.last n), ↑(i.castPred h) = ↑i | true |
Std.TreeMap.alter | Std.Data.TreeMap.Basic | {α : Type u} →
{β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → α → (Option β → Option β) → Std.TreeMap α β cmp | true |
CategoryTheory.Oplax.StrongTrans.isoMk_inv_as_app | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} (app : (a : B) → η.app a ≅ θ.app a)
(naturality :
autoParam
(∀ {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (app b).hom)
(θ.naturality f).hom =
CategoryTheory.CategoryStruct.comp (η.naturality f).hom
(CategoryTheory.Bicategory.whiskerRight (app a).hom (G.map f)))
CategoryTheory.Oplax.StrongTrans.isoMk._auto_1)
(a : B), (CategoryTheory.Oplax.StrongTrans.isoMk app naturality).inv.as.app a = (app a).inv | true |
UniformSpace.hausdorff.isClosed_setOf_totallyBounded | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], IsClosed {s | TotallyBounded s} | true |
Bornology.IsVonNBounded.image_multilinear | Mathlib.Topology.Algebra.Module.Multilinear.Bounded | ∀ {ι : Type u_1} {𝕜 : Type u_2} {F : Type u_3} {E : ι → Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → AddCommGroup (E i)] [inst_2 : (i : ι) → Module 𝕜 (E i)]
[inst_3 : (i : ι) → TopologicalSpace (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] [ContinuousSMul 𝕜 F] {s : Set ((i : ι) → E i)},
Bornology.IsVonNBounded 𝕜 s → ∀ (f : ContinuousMultilinearMap 𝕜 E F), Bornology.IsVonNBounded 𝕜 (⇑f '' s) | true |
UInt64.toUInt16_lt._simp_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a.toUInt16 < b.toUInt16) = (a % 65536 < b % 65536) | false |
CategoryTheory.Functor.leftOpRightOpEquiv._proof_1 | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_4, u_2} C] (D : Type u_1)
[inst_1 : CategoryTheory.Category.{u_3, u_1} D] (X : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ),
CategoryTheory.NatTrans.rightOp (CategoryTheory.CategoryStruct.id X).unop =
CategoryTheory.CategoryStruct.id (Opposite.unop X).rightOp | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.Internal.List.insertEntry.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (k : α) (v : β k) (l : List ((a : α) × β a)),
Std.Internal.List.insertEntry k v l =
bif Std.Internal.List.containsKey k l then Std.Internal.List.replaceEntry k v l else ⟨k, v⟩ :: l | true |
curveIntegral_symm | Mathlib.MeasureTheory.Integral.CurveIntegral.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {a b : E} (ω : E → E →L[𝕜] F)
(γ : Path a b), ∫ᶜ (x : E) in γ.symm, ω x = -∫ᶜ (x : E) in γ, ω x | true |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.addContent_iUnion_eq_tsum_of_disjoint_of_addContent_iUnion_le._simp_1_5 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : α → Prop} {q : β → Prop},
(∀ (b : β) (a : α), p a → f a = b → q b) = ∀ (a : α), p a → q (f a) | false |
smul_mem_asymptoticCone_iff | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] [inst_6 : TopologicalSpace k]
[OrderTopology k] [IsStrictOrderedRing k] [IsTopologicalAddGroup V] [ContinuousSMul k V] {s : Set P} {c : k} {v : V},
0 < c → (c • v ∈ asymptoticCone k s ↔ v ∈ asymptoticCone k s) | true |
Matrix.transposeInvertibleEquivInvertible._proof_1 | Mathlib.Data.Matrix.Invertible | ∀ {n : Type u_1} {α : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring α] (A : Matrix n n α)
(x : Invertible A.transpose), A.invertibleTranspose = x | false |
Std.Tactic.BVDecide.BVUnOp.eval_not | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ}, Std.Tactic.BVDecide.BVUnOp.not.eval = fun x => ~~~x | true |
CategoryTheory.PreGaloisCategory.autMapHom_apply | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C] {A B : C}
[inst_2 : CategoryTheory.PreGaloisCategory.IsConnected A] [inst_3 : CategoryTheory.PreGaloisCategory.IsGalois B]
(f : A ⟶ B) (σ : CategoryTheory.Aut A),
(CategoryTheory.PreGaloisCategory.autMapHom f) σ = CategoryTheory.PreGaloisCategory.autMap f σ | true |
List.consecutivePairs | Mathlib.Data.List.Defs | {α : Type u_1} → List α → List (α × α) | true |
Std.DHashMap.Raw.Equiv.mem_iff | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {k : α}, m₁.WF → m₂.WF → m₁.Equiv m₂ → (k ∈ m₁ ↔ k ∈ m₂) | true |
Set.BijOn.union | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Set α} {t₁ t₂ : Set β} {f : α → β},
Set.BijOn f s₁ t₁ → Set.BijOn f s₂ t₂ → Set.InjOn f (s₁ ∪ s₂) → Set.BijOn f (s₁ ∪ s₂) (t₁ ∪ t₂) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.