name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceGT._regBuiltin.Int32.reduceGT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.232 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
ONote.fastGrowing_zero' | Mathlib.SetTheory.Ordinal.Notation | ∀ (o : ONote), o.fundamentalSequence = Sum.inl none → o.fastGrowing = Nat.succ | null | true |
CategoryTheory.pi.coneOfConeEvalIsLimit | Mathlib.CategoryTheory.Limits.Pi | {I : Type v₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
{J : Type v₁} →
[inst_1 : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J ((i : I) → C i)} →
{c : (i : I) → CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Pi.eval... | Given a family of limit cones over the `F ⋙ Pi.eval C i`,
assembling them together as a `Cone F` produces a limit cone.
| true |
AddSubmonoid.op_eq_top | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : AddZeroClass M] {S : AddSubmonoid M}, S.op = ⊤ ↔ S = ⊤ | null | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.ctorIdx | Mathlib.CategoryTheory.Galois.Prorepresentability | {C : Type u₁} →
{inst : CategoryTheory.Category.{u₂, u₁} C} →
{inst_1 : CategoryTheory.GaloisCategory C} →
{F : CategoryTheory.Functor C FintypeCat} → CategoryTheory.PreGaloisCategory.PointedGaloisObject F → ℕ | null | false |
Matroid.mapEmbedding_isLoop_iff._simp_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {β : Type u_2} {M : Matroid α} {e : α} {f : α ↪ β}, (M.mapEmbedding f).IsLoop (f e) = M.IsLoop e | null | false |
Std.Do.Spec.run_ExceptT | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {ε α : Type u} {Q : Std.Do.PostCond (Except ε α) ps}
[inst : Std.Do.WP m ps] (x : ExceptT ε m α),
⦃(Std.Do.wp x).apply (fun a => Q.1 (Except.ok a), fun e => Q.1 (Except.error e), Q.2)⦄ x.run ⦃Q⦄ | null | true |
CategoryTheory.Functor.mapCochainComplexShiftIso._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u_2}
[inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.Preadditive D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive] (n : ℤ) {X Y : HomologicalComplex C (ComplexShape.up ℤ)... | null | false |
pow_mul_pow_sub | Mathlib.Algebra.Group.Basic | ∀ {M : Type u_4} [inst : Monoid M] {m n : ℕ} (a : M), m ≤ n → a ^ m * a ^ (n - m) = a ^ n | null | true |
List.pairwise_iff_forall_infix._proof_2 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} (l' : List α), 1 < l'.length → l' ≠ [] | null | false |
_private.Mathlib.FieldTheory.PurelyInseparable.Basic.0.IsPurelyInseparable.exists_pow_pow_mem_range_tensorProduct_of_expChar._simp_1_1 | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {f : R →+* S} {y : S},
(y ∈ f.range) = ∃ x, f x = y | null | false |
Batteries.DList.instAppend | Batteries.Data.DList.Basic | {α : Type u} → Append (Batteries.DList α) | null | true |
HopfAlgCat.Hom._sizeOf_1 | Mathlib.Algebra.Category.HopfAlgCat.Basic | {R : Type u} → {inst : CommRing R} → {V W : HopfAlgCat R} → [SizeOf R] → V.Hom W → ℕ | null | false |
IsDedekindDomain.HeightOneSpectrum.mem_adicCompletionIntegers | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
{x : IsDedekindDomain.HeightOneSpectrum.adicCompletion K v},
x ∈ IsDedekindDomain.HeightOneSpectrum.adicCompletionInt... | null | true |
CategoryTheory.Functor.essImage.liftFunctor._proof_4 | Mathlib.CategoryTheory.EssentialImage | ∀ {J : Type u_2} {C : Type u_4} {D : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
(G : CategoryTheory.Functor J D) (F : CategoryTheory.Functor C D) [inst_3 : F.Full] [F.Faithful]
(hG : ∀ (j : J), F.essImage ... | null | false |
Action.Hom.noConfusion | Mathlib.CategoryTheory.Action.Basic | {P : Sort u} →
{V : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} V} →
{G : Type u_2} →
{inst_1 : Monoid G} →
{M N : Action V G} →
{t : M.Hom N} →
{V' : Type u_1} →
{inst' : CategoryTheory.Category.{v_1, u_1} V'} →
{G' : ... | null | false |
AddConstEquiv.toEquiv | Mathlib.Algebra.AddConstMap.Equiv | {G : Type u_1} → {H : Type u_2} → [inst : Add G] → [inst_1 : Add H] → {a : G} → {b : H} → AddConstEquiv G H a b → G ≃ H | Interpret an `AddConstEquiv` as an `Equiv`. | true |
Asymptotics.isLittleO_norm_norm | Mathlib.Analysis.Asymptotics.Basic | ∀ {α : Type u_1} {E' : Type u_6} {F' : Type u_7} [inst : SeminormedAddCommGroup E'] [inst_1 : SeminormedAddCommGroup F']
{f' : α → E'} {g' : α → F'} {l : Filter α}, ((fun x => ‖f' x‖) =o[l] fun x => ‖g' x‖) ↔ f' =o[l] g' | null | true |
FunLike.mulAction._proof_1 | Mathlib.Algebra.Module.FunLike | ∀ {M : Type u_4} {F : Type u_3} {α : Type u_1} {β : Type u_2} [i : FunLike F α β] [inst : SMul M F] [inst_1 : Monoid M]
[inst_2 : MulAction M β] [IsSMulApply M F α β] (n : M) (f : F), ⇑(n • f) = n • ⇑f | null | false |
CategoryTheory.Abelian.SpectralObject.HasSpectralSequence.isZero_H_obj_mk₁_i₀_le | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {C : Type u_1} {ι : Type u_2} {κ : Type u_3} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Abelian C} {inst_2 : Preorder ι} {c : ℤ → ComplexShape κ} {r₀ : ℤ}
{X : CategoryTheory.Abelian.SpectralObject C ι}
{data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀} [s... | null | true |
Batteries.CodeAction.TacticCodeActionEntry.noConfusionType | Batteries.CodeAction.Attr | Sort u → Batteries.CodeAction.TacticCodeActionEntry → Batteries.CodeAction.TacticCodeActionEntry → Sort u | null | false |
Unitization.unitsFstOne_mulEquiv_quasiregular._proof_9 | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (x : (PreQuasiregular A)ˣ),
↑((fun x =>
{ val := PreQuasiregular.equiv (↑↑x).toProd.2, inv := PreQuasiregular.equiv (↑↑x⁻¹).toProd.2, v... | null | false |
SimpleGraph.Walk.IsCircuit.rec | Mathlib.Combinatorics.SimpleGraph.Paths | {V : Type u} →
{G : SimpleGraph V} →
{u : V} →
{p : G.Walk u u} →
{motive : p.IsCircuit → Sort u_1} →
((isTrail : p.IsTrail) → (ne_nil : p ≠ SimpleGraph.Walk.nil) → motive ⋯) → (t : p.IsCircuit) → motive t | null | false |
FreeAbelianGroup.map_id_apply | Mathlib.GroupTheory.FreeAbelianGroup | ∀ {α : Type u} (x : FreeAbelianGroup α), (FreeAbelianGroup.map id) x = x | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData.diseqs | Lean.Meta.Tactic.Grind.Types | ℕ →
Lean.Meta.Grind.ParentSet →
Lean.Meta.Grind.PendingSolverPropagationsData✝ → Lean.Meta.Grind.PendingSolverPropagationsData✝ | null | true |
QuotientAddGroup.instCoeQuotientAddSubgroup | Mathlib.GroupTheory.Coset.Defs | {α : Type u_1} → [inst : AddGroup α] → {s : AddSubgroup α} → Coe α (α ⧸ s) | null | true |
Metric.unitClosedBall.instSemigroup._proof_3 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NonUnitalSeminormedRing 𝕜] (a b c : ↑(Metric.closedBall 0 1)), a * b * c = a * (b * c) | null | false |
Std.DTreeMap.Internal.Impl.doubleR.eq_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (lk : α) (lv : β lk) (ll : Std.DTreeMap.Internal.Impl α β) (lrk : α)
(lrv : β lrk) (lrl lrr r : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.doubleR k v lk lv ll lrk lrv lrl lrr r =
Std.DTreeMap.Internal.Impl.bin lrk lrv (Std.DTreeMap.Internal.Imp... | null | true |
SmoothBumpFunction.eventuallyEq_one_of_dist_lt | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M}
(f : SmoothBumpFunction I c) {x : M} [inst_5 : FiniteDimensional ℝ E],
x ∈ (chartAt H c)... | null | true |
Module.Dual.extendRCLikeₗ._proof_7 | Mathlib.Analysis.RCLike.Extend | RingHomCompTriple (RingHom.id ℝ) (RingHom.id ℝ) (RingHom.id ℝ) | null | false |
Delone.DeloneSet.mk.congr_simp | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_3} [inst : MetricSpace X] (carrier carrier_1 : Set X) (e_carrier : carrier = carrier_1)
(packingRadius packingRadius_1 : NNReal) (e_packingRadius : packingRadius = packingRadius_1)
(packingRadius_pos : 0 < packingRadius) (isSeparated_packingRadius : Metric.IsSeparated (↑packingRadius) carrier)
(cove... | null | true |
Finsupp.optionElim_ne_zero_of_left | Mathlib.Data.Finsupp.Option | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (y : M) (f : α →₀ M), y ≠ 0 → Finsupp.optionElim y f ≠ 0 | null | true |
_private.Mathlib.Order.LiminfLimsup.0.Filter.blimsup_eq_iInf_biSup_of_nat._simp_1_1 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ici b) = (b ≤ x) | null | false |
_private.Lean.Meta.Tactic.Grind.Proof.0.Lean.Meta.Grind.mkProofTo._unsafe_rec | Lean.Meta.Tactic.Grind.Proof | Lean.Expr → Lean.Expr → Option Lean.Expr → Bool → Lean.Meta.Grind.GoalM (Option Lean.Expr) | null | false |
NormedAddGroupHom.toAddCommGroup._proof_6 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_1} {V₂ : Type u_2} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(x : NormedAddGroupHom V₁ V₂) (x_1 : ℤ), (x_1 • x).toFun = (x_1 • x).toFun | null | false |
_private.Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric.0.Complex.radius_regularizedHGFunSeries_eq_top._proof_1_1 | Mathlib.Analysis.SpecialFunctions.RegularizedHypergeometric | ∀ {a b : Multiset ℂ}, a.card ≤ b.card → ¬b.card + 1 - a.card = 0 | null | false |
Asymptotics.isTheta_inv._simp_1 | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {𝕜 : Type u_11} {𝕜' : Type u_12} [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜'] {l : Filter α}
{f : α → 𝕜} {g : α → 𝕜'}, ((fun x => (f x)⁻¹) =Θ[l] fun x => (g x)⁻¹) = f =Θ[l] g | null | false |
Order.IsPredLimit.isPredPrelimit | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Order.IsPredLimit a → Order.IsPredPrelimit a | Predecessor limits aren't covered by any other elements. | true |
_private.Mathlib.NumberTheory.Padics.RingHoms.0.PadicInt.toZModHom._simp_1 | Mathlib.NumberTheory.Padics.RingHoms | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M),
(0 ∈ p) = True | null | false |
IsIntegralClosure.isTorsionFree | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ (R : Type u_1) {A : Type u_2} (B : Type u_3) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [IsIntegralClosure A R B] [inst_6 : Module R A] [IsScalarTower R A B]
[Module.IsTorsionFree R B], Module.IsTorsionFree R A | null | true |
Std.ExtDTreeMap.Const.getKey_modify | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp}
[Inhabited α] {k k' : α} {f : β → β} {hc : k' ∈ Std.ExtDTreeMap.Const.modify t k f},
(Std.ExtDTreeMap.Const.modify t k f).getKey k' hc = if cmp k k' = Ordering.eq then k else t.getKey k' ⋯ | null | true |
EuclideanGeometry.Sphere.center_mem_affineSpan_pair_iff_isDiameter | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → p₂ ∈ s → (s.center ∈ line[ℝ, p₁, p₂] ↔ s.IsDiameter p₁ p₂) | The center lies on the line through two points of a sphere if and only if those
points are the endpoints of a diameter. | true |
_private.Mathlib.MeasureTheory.Integral.MeanInequalities.0.ENNReal.funMulInvSnorm_rpow | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {p : ℝ},
0 < p → ∀ {f : α → ENNReal} {a : α}, ENNReal.funMulInvSnorm✝ f p μ a ^ p = f a ^ p * (∫⁻ (c : α), f c ^ p ∂μ)⁻¹ | null | true |
Flag.symm_map | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β),
(Flag.map e).symm = Flag.map e.symm | null | true |
Flag.instUnique._proof_2 | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Set α), IsChain (fun x1 x2 => x1 ≤ x2) s → Set.univ ⊆ s → Set.univ = s | null | false |
Std.Slice.mk.inj | Init.Data.Slice.Basic | ∀ {γ : Type u} {internalRepresentation internalRepresentation_1 : γ},
{ internalRepresentation := internalRepresentation } = { internalRepresentation := internalRepresentation_1 } →
internalRepresentation = internalRepresentation_1 | null | true |
Lean.Elab.Term.registerCustomErrorIfMVar | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Syntax → Lean.MessageData → Lean.Elab.TermElabM Unit | null | true |
Nat.not_lt_of_gt | Init.Data.Nat.Basic | ∀ {a b : ℕ}, a < b → ¬b < a | Alias for `Nat.lt_asymm`. | true |
UInt8.isUTF8FirstByte_getElem_utf8EncodeChar._simp_1 | Init.Data.String.Decode | ∀ {c : Char} {i : ℕ} {hi : i < (String.utf8EncodeChar c).length}, (String.utf8EncodeChar c)[i].IsUTF8FirstByte = (i = 0) | null | false |
SimpleGraph.Subgraph.induce_mono_left | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {G' G'' : G.Subgraph} {s : Set V}, G' ≤ G'' → G'.induce s ≤ G''.induce s | null | true |
Lean.Meta.InjectionResultCore.subgoal.noConfusion | Lean.Meta.Tactic.Injection | {P : Sort u} →
{mvarId : Lean.MVarId} →
{numNewEqs : ℕ} →
{mvarId' : Lean.MVarId} →
{numNewEqs' : ℕ} →
Lean.Meta.InjectionResultCore.subgoal mvarId numNewEqs =
Lean.Meta.InjectionResultCore.subgoal mvarId' numNewEqs' →
(mvarId = mvarId' → numNewEqs = numNewEqs' → ... | null | false |
Std.DTreeMap.Internal.Impl.isEmpty_insertMany_empty_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} [Std.TransOrd α] {l : List ((a : α) × β a)},
(↑(Std.DTreeMap.Internal.Impl.empty.insertMany l ⋯)).isEmpty = l.isEmpty | null | true |
BddLat.instConcreteCategoryBoundedLatticeHomCarrier._proof_3 | Mathlib.Order.Category.BddLat | ∀ {X : BddLat} (x : ↑X.toLat), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
IsArtinian.exists_pow_succ_smul_dvd | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[IsArtinian R M] (r : R) (x : M), ∃ n y, r ^ n.succ • y = r ^ n • x | null | true |
Std.DTreeMap.Internal.Impl.maxKey?_erase!_eq_of_not_compare_eq_maxKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k : α},
(∀ {km : α}, t.maxKey? = some km → ¬compare k km = Ordering.eq) →
(Std.DTreeMap.Internal.Impl.erase! k t).maxKey? = t.maxKey? | null | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.containsBadMax | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Level → Bool | null | true |
CategoryTheory.ChosenPullbacksAlong.Over.lift_left | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.ChosenPullbacks C] {X : C}
{W Y Z : CategoryTheory.Over X} (f : W ⟶ Y) (g : W ⟶ Z),
CategoryTheory.Over.Hom.left (CategoryTheory.CartesianMonoidalCategory.lift f g) =
CategoryTheory.ChosenPullbacksAlong.lift (CategoryTheory.Ove... | null | true |
Algebra.IsEtaleAt.exists_isStandardEtale | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (Q : Ideal S)
[inst_3 : Q.IsPrime] [Algebra.FinitePresentation R S] [Algebra.IsEtaleAt R Q],
∃ f ∉ Q, Algebra.IsStandardEtale R (Localization.Away f) | [Stacks Tag 00UE](https://stacks.math.columbia.edu/tag/00UE) | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.A_subset_aH | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {A : Finset G}, ∀ a ∈ A, A ⊆ a • (A⁻¹ * A) | null | true |
Lean.Parser.ParserContextCore.mk.sizeOf_spec | Lean.Parser.Types | ∀ (toInputContext : Lean.Parser.InputContext) (toParserModuleContext : Lean.Parser.ParserModuleContext)
(toCacheableParserContext : Lean.Parser.CacheableParserContext) (tokens : Lean.Parser.TokenTable),
sizeOf
{ toInputContext := toInputContext, toParserModuleContext := toParserModuleContext,
toCachea... | null | true |
CategoryTheory.regularTopology.equalizerConditionMap_iff_nonempty_isLimit | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (P : CategoryTheory.Functor Cᵒᵖ D) ⦃X B : C⦄ (π : X ⟶ B)
[CategoryTheory.Limits.HasPullback π π],
CategoryTheory.regularTopology.SingleEqualizerCondition P π ↔
Nonempty
(Category... | null | true |
CategoryTheory.StructuredArrow.map₂Iso._proof_4 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] {A : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} A]
{B : Type u_8} [inst_3 : CategoryTheory.Category.{u_7, u_8} B] {R : CategoryTheory.Functor C D}
{R' : CategoryTheory.Functor ... | null | false |
Rat.cast_lt_zero | Mathlib.Data.Rat.Cast.Order | ∀ {q : ℚ} {K : Type u_2} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K], ↑q < 0 ↔ q < 0 | null | true |
Lean.Parser.Term.Doc.RecommendedSpelling.mk.noConfusion | Lean.Parser.Term.Doc | {P : Sort u} →
{«notation» recommendedSpelling : String} →
{additionalInformation? : Option String} →
{notation' recommendedSpelling' : String} →
{additionalInformation?' : Option String} →
{ «notation» := «notation», recommendedSpelling := recommendedSpelling,
additionalIn... | null | false |
MvPolynomial.renameSymmetricSubalgebra_symm_apply_coe | Mathlib.RingTheory.MvPolynomial.Symmetric.Defs | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [inst : CommSemiring R] (e : σ ≃ τ)
(a : ↥(MvPolynomial.symmetricSubalgebra τ R)),
↑((MvPolynomial.renameSymmetricSubalgebra e).symm a) = (MvPolynomial.rename ⇑e.symm) ↑a | null | true |
LieIdeal.comap_bracket_le | Mathlib.Algebra.Lie.IdealOperations | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (f : L →ₗ⁅R⁆ L') {J₁ J₂ : LieIdeal R L'},
⁅LieIdeal.comap f J₁, LieIdeal.comap f J₂⁆ ≤ LieIdeal.comap f ⁅J₁, J₂⁆ | null | true |
ImportGraph.Shake.Needs.LowToHigh.mk.noConfusion | ImportGraph.Shake.Basic | {P : Sort u} →
{toNeeds toNeeds' : ImportGraph.Shake.Needs} →
{ toNeeds := toNeeds } = { toNeeds := toNeeds' } → (toNeeds = toNeeds' → P) → P | null | false |
Module.Basis.toBasis_toOrthonormalBasis | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (v : Module.Basis ι 𝕜 E) (hv : Orthonormal 𝕜 ⇑v),
(v.toOrthonormalBasis hv).toBasis = v | null | true |
AddSubmonoid.LocalizationMap.instAddCancelCommMonoidLocalization.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_3} [inst : AddCancelCommMonoid M] (S : AddSubmonoid M),
AddSubmonoid.LocalizationMap.instAddCancelCommMonoidLocalization S =
(AddLocalization.addMonoidOf S).addCancelCommMonoid | null | true |
PowerBasis.equivOfRoot_gen | Mathlib.RingTheory.PowerBasis | ∀ {S : Type u_2} [inst : Ring S] {A : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra A S] {S' : Type u_6}
[inst_3 : Ring S'] [inst_4 : Algebra A S'] (pb : PowerBasis A S) (pb' : PowerBasis A S')
(h₁ : (Polynomial.aeval pb.gen) (minpoly A pb'.gen) = 0) (h₂ : (Polynomial.aeval pb'.gen) (minpoly A pb.gen) = 0),
(... | null | true |
Std.Net.SocketAddressV6.mk.injEq | Std.Net.Addr | ∀ (addr : Std.Net.IPv6Addr) (port : UInt16) (addr_1 : Std.Net.IPv6Addr) (port_1 : UInt16),
({ addr := addr, port := port } = { addr := addr_1, port := port_1 }) = (addr = addr_1 ∧ port = port_1) | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go_le_size._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ}
(_x : (aig : Std.Sat.AIG α) ×' (_ : ℕ) ×' (_ : aig.RefVec w) ×' (_ : aig.RefVec w) ×' aig.RefVec w),
_x.1.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.go _x.1 _x.2.2.2.1 _x.2.2.2.2 _x.2.1 _x.2.2.1).aig.decls.size | null | false |
_private.Mathlib.Data.List.Pairwise.0.List.tfae_cons._simp_1_1 | Mathlib.Data.List.Pairwise | ∀ {l : List Prop}, l.TFAE = List.Pairwise (fun x1 x2 => x1 ↔ x2) l | null | false |
CategoryTheory.Abelian.SpectralObject.opcyclesIsoH._proof_3 | 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₀ i₁ : ι} (f : i₀ ⟶ i₁) (n₀ n₁ : ℤ) (hn₁ : n₀ + 1 = n₁),
(X.shortComplex (CategoryTheory.CategoryStruc... | null | false |
Finpartition.card_filter_atomise_le_two_pow | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {F : Finset (Finset α)},
t ∈ F → {u ∈ (Finpartition.atomise s F).parts | u ⊆ t ∧ u.Nonempty}.card ≤ 2 ^ (F.card - 1) | null | true |
CategoryTheory.ObjectProperty.instHasZeroMorphismsFullSubcategory._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P : CategoryTheory.ObjectProperty C) (X : P.FullSubcategory) {Y Z : P.FullSubcategory} (f : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp 0 f = 0 | null | false |
Matrix.adjp.congr_simp | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] {inst_1 : DecidableEq n} [inst_2 : DecidableEq n]
[inst_3 : CommSemiring R] (s s_1 : ℤˣ),
s = s_1 →
∀ (A A_1 : Matrix n n R),
A = A_1 →
∀ (a a_1 : n), a = a_1 → ∀ (a_2 a_3 : n), a_2 = a_3 → Matrix.adjp s A a a_2 = Matrix.adjp s_1 A_1 a_1 a_3 | null | true |
Finset.Ioc_map_sectL | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : PartialOrder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] [inst_4 : DecidableLE (α × β)] (a b : α) (c : β),
Finset.map (Function.Embedding.sectL α c) (Finset.Ioc a b) = Finset.Ioc (a, c) (b, c) | null | true |
Nat.instTransLeLt | Init.Data.Nat.Basic | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 < x2) fun x1 x2 => x1 < x2 | null | true |
Polynomial.Sequence.recOn | Mathlib.Algebra.Polynomial.Sequence | {R : Type u_1} →
[inst : Semiring R] →
{motive : Polynomial.Sequence R → Sort u} →
(t : Polynomial.Sequence R) →
((elems' : ℕ → Polynomial R) →
(degree_eq' : ∀ (i : ℕ), (elems' i).degree = ↑i) → motive { elems' := elems', degree_eq' := degree_eq' }) →
motive t | null | false |
DFinsupp.lmk_apply | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {M : ι → Type u_5} [inst : Semiring R] [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] [inst_3 : DecidableEq ι] (s : Finset ι) (x : (i : ↑↑s) → M ↑i),
(DFinsupp.lmk s) x = DFinsupp.mk s x | null | true |
IsLocalization.AtPrime.equivQuotMaximalIdeal._proof_1 | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommRing R] (p : Ideal R), (p ^ 1).IsTwoSided | null | false |
CategoryTheory.Limits.Cofan.op | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{α : Type u_1} → {Z : α → C} → CategoryTheory.Limits.Cofan Z → CategoryTheory.Limits.Fan fun x => Opposite.op (Z x) | A `Cofan` gives a `Fan` in the opposite category. | true |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_21 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (res : Lean.Name) (acc : String) (ucount : ℕ) (q : s.Pos) (v : ℕ),
p₀ < q →
(invImage
(fun x =>
PSum.casesOn x (fun _x => PSigma.casesOn _x fun p res => PSigma.casesOn res fun res n => p) fun _x =>
PSum.casesOn _x (fun _x => PSigma.casesOn _x fun p r... | null | false |
zpow_lt_zpow_iff_left | Mathlib.Algebra.Order.Group.Basic | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : LinearOrder α] [IsOrderedMonoid α] {n : ℤ} {a b : α},
0 < n → (a ^ n < b ^ n ↔ a < b) | null | true |
MeasureTheory.OuterMeasure.trim_smul | Mathlib.MeasureTheory.OuterMeasure.Induced | ∀ {α : Type u_1} [inst : MeasurableSpace α] {R : Type u_2} [inst_1 : SMul R ENNReal]
[inst_2 : IsScalarTower R ENNReal ENNReal] (c : R) (m : MeasureTheory.OuterMeasure α), (c • m).trim = c • m.trim | `trim` respects scalar multiplication. | true |
Nat.maxPrimeFac_mul | Mathlib.Data.Nat.MaxPrimeFac | ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → (m * n).maxPrimeFac = max m.maxPrimeFac n.maxPrimeFac | The greatest prime factor of a product of nonzero natural numbers is the maximum of their
greatest prime factors. | true |
lipschitzOnWith_inv_iff._simp_2 | Mathlib.Analysis.Normed.Group.Uniform | ∀ {α : Type u_4} {E : Type u_5} [inst : SeminormedCommGroup E] [inst_1 : PseudoEMetricSpace α] {K : NNReal} {f : α → E}
{s : Set α}, LipschitzOnWith K f⁻¹ s = LipschitzOnWith K f s | null | false |
_private.Lean.Parser.Extension.0.Lean.Parser.parserAttributeHooks._proof_1 | Lean.Parser.Extension | Nonempty (ST.Ref IO.RealWorld (List Lean.Parser.ParserAttributeHook)) | null | false |
_private.Batteries.CodeAction.Misc.0.Batteries.CodeAction.instanceStub.collectFields.match_1 | Batteries.CodeAction.Misc | (motive : Option Lean.Name → Sort u_1) →
(x : Option Lean.Name) →
((substructName : Lean.Name) → motive (some substructName)) → ((x : Option Lean.Name) → motive x) → motive x | null | false |
_private.Mathlib.Algebra.Quaternion.0.QuaternionAlgebra.star_eq_neg._simp_1_2 | Mathlib.Algebra.Quaternion | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a = -b) = (a + b = 0) | null | false |
Mathlib.Tactic.BicategoryLike.Normalize.Result.noConfusionType | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | Sort u → Mathlib.Tactic.BicategoryLike.Normalize.Result → Mathlib.Tactic.BicategoryLike.Normalize.Result → Sort u | null | false |
CategoryTheory.Span.SpanBicat.instBicategory | Mathlib.CategoryTheory.Bicategory.Span.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{Wₗ Wᵣ : CategoryTheory.MorphismProperty C} →
[Wₗ.ContainsIdentities] →
[Wᵣ.ContainsIdentities] →
[Wₗ.HasPullbacksAgainst Wᵣ] →
[Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] →
[Wᵣ.IsStableUnderBaseChangeAga... | null | true |
Matroid.ofIsBaseOfFinite_E | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} {E : Set α} (hE : E.Finite) (IsBase : Set α → Prop) (exists_isBase : ∃ B, IsBase B)
(isBase_exchange : Matroid.ExchangeProperty IsBase) (subset_ground : ∀ (B : Set α), IsBase B → B ⊆ E),
(Matroid.ofIsBaseOfFinite hE IsBase exists_isBase isBase_exchange subset_ground).E = E | null | true |
Subalgebra.pointwise_smul_toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Pointwise | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {R' : Type u_3}
[inst_3 : Semiring R'] [inst_4 : MulSemiringAction R' A] [inst_5 : SMulCommClass R' R A] (m : R')
(S : Subalgebra R A), Subalgebra.toSubmodule (m • S) = m • Subalgebra.toSubmodule S | null | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._proof_6 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ),
table.size ≤ pat.utf8ByteSize → ¬table.size < pat.utf8ByteSize → table.size = pat.utf8ByteSize | null | false |
Pi.divInvMonoid._proof_4 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → DivInvMonoid (f i)] (n : ℕ) (a : (i : I) → f i),
a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹ | null | false |
CategoryTheory.MonoidalCategory.selfLeftAction._proof_1 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{c c' d d' : C} (f : c ⟶ c') (g : d ⟶ d'),
CategoryTheory.MonoidalCategoryStruct.tensorHom f g =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight f d)
(Category... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsPath.isCycle_append._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u v : V} {p : G.Walk u v} {q : G.Walk v u},
1 < p.length ∨ 1 < q.length → ¬p.append q = SimpleGraph.Walk.nil | null | false |
ProbabilityTheory.bayesRisk_const | Mathlib.Probability.Decision.Risk.Basic | ∀ {Θ : Type u_1} {𝓧 : Type u_2} {𝓨 : Type u_4} {mΘ : MeasurableSpace Θ} {m𝓧 : MeasurableSpace 𝓧}
{m𝓨 : MeasurableSpace 𝓨} {ℓ : Θ → 𝓨 → ENNReal},
Measurable (Function.uncurry ℓ) →
∀ (μ : MeasureTheory.Measure 𝓧) [MeasureTheory.IsProbabilityMeasure μ] (π : MeasureTheory.Measure Θ)
[MeasureTheory.SFi... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.