name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.CatCospanTransformMorphism.noConfusionType | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | Sort u →
{A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{A' : Type u₄} →
{B' : Type u₅} →
{C' : Type u₆} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} A'] →
[inst_4 : CategoryTheory.Category.{v₅, u₅} B'] →
[inst_5 : CategoryTheory.Category.{v₆, u₆} C'] →
{F' : CategoryTheory.Functor A' B'} →
{G' : CategoryTheory.Functor C' B'} →
{ψ ψ' : CategoryTheory.Limits.CatCospanTransform F G F' G'} →
CategoryTheory.Limits.CatCospanTransformMorphism ψ ψ' →
{A' : Type u₁} →
{B' : Type u₂} →
{C' : Type u₃} →
{A'' : Type u₄} →
{B'' : Type u₅} →
{C'' : Type u₆} →
[inst' : CategoryTheory.Category.{v₁, u₁} A'] →
[inst'_1 : CategoryTheory.Category.{v₂, u₂} B'] →
[inst'_2 : CategoryTheory.Category.{v₃, u₃} C'] →
{F' : CategoryTheory.Functor A' B'} →
{G' : CategoryTheory.Functor C' B'} →
[inst'_3 : CategoryTheory.Category.{v₄, u₄} A''] →
[inst'_4 : CategoryTheory.Category.{v₅, u₅} B''] →
[inst'_5 : CategoryTheory.Category.{v₆, u₆} C''] →
{F'' : CategoryTheory.Functor A'' B''} →
{G'' : CategoryTheory.Functor C'' B''} →
{ψ' ψ'' :
CategoryTheory.Limits.CatCospanTransform F' G'
F'' G''} →
CategoryTheory.Limits.CatCospanTransformMorphism
ψ' ψ'' →
Sort u | false |
ENNReal.canLift | Mathlib.Data.ENNReal.Basic | CanLift ENNReal NNReal ENNReal.ofNNReal fun x => x ≠ ⊤ | true |
Lean.IR.VarId.mk._flat_ctor | Lean.Compiler.IR.Basic | Lean.IR.Index → Lean.IR.VarId | false |
Set.Ico_eq_Ioc_same_iff | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico b a = Set.Ioc b a ↔ ¬b < a | true |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.IsReduced.nodup_rightInvSeq._simp_1_7 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), (a ^ m) ^ n = a ^ (m * n) | false |
_private.Mathlib.Order.UpperLower.Closure.0.upperClosure_min.match_1_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} (_a : α) (motive : _a ∈ ↑(upperClosure s) → Prop)
(x : _a ∈ ↑(upperClosure s)), (∀ (_b : α) (hb : _b ∈ s) (hba : _b ≤ _a), motive ⋯) → motive x | false |
AddMonoidAlgebra.ring._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] (a b : AddMonoidAlgebra R M), a - b = a + -b | false |
Matroid.uniqueBaseOn_inter_isBasis | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, X ⊆ E → (Matroid.uniqueBaseOn I E).IsBasis (X ∩ I) X | true |
ShareCommon.Object.ptrEq | Init.ShareCommon | ShareCommon.Object → ShareCommon.Object → Bool | true |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandFirstPrefixRapp._unsafe_rec | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.RappRef → Aesop.SafeExpansionM Q Unit | false |
NumberField.mixedEmbedding.fundamentalCone.equivFinRank._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K],
Fintype.card (Fin (NumberField.Units.rank K)) = Fintype.card { w // w ≠ NumberField.Units.dirichletUnitTheorem.w₀ } | false |
Std.Time.Internal.Bounded.LE.ofNatWrapping._proof_7 | Std.Time.Internal.Bounded | ∀ {lo hi : ℤ} (val : ℤ),
lo ≤ lo + (val - lo) % (hi - lo + 1) →
(val - lo) % (hi - lo + 1) < hi - lo + 1 →
lo ≤ ((val - lo) % (hi - lo + 1) + (hi - lo + 1)) % (hi - lo + 1) + lo ∧
((val - lo) % (hi - lo + 1) + (hi - lo + 1)) % (hi - lo + 1) + lo ≤ hi | false |
AddSubmonoid.comap_map_eq_of_injective | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ (S : AddSubmonoid M), AddSubmonoid.comap f (AddSubmonoid.map f S) = S | true |
AddSubmonoid.IsSpanning.of_le | Mathlib.Algebra.Group.Submonoid.Support | ∀ {G : Type u_1} [inst : AddGroup G] {M N : AddSubmonoid G}, M.IsSpanning → M ≤ N → N.IsSpanning | true |
CategoryTheory.MonoidalCategory.whiskerLeft_rightUnitor | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C),
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X Y (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).inv
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y)).hom | true |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_of_lt_base | Init.Data.Nat.ToString | ∀ {b n fuel : ℕ} {cs : List Char}, n < b → n < fuel → b.toDigitsCore fuel n cs = n.digitChar :: cs | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.withBVExprCache.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | (motive : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) → Sort u_1) →
(x : Option (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr)) →
((hit : Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr) → motive (some hit)) →
(Unit → motive none) → motive x | false |
ContinuousMapZero.instAddCommMonoid._proof_2 | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace R]
[inst_3 : AddCommMonoid R] [inst_4 : ContinuousAdd R] (a : ContinuousMapZero X R), 0 + a = a | false |
CategoryTheory.ProjectiveResolution.liftCompHomotopy._proof_2 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) (P : CategoryTheory.ProjectiveResolution X) (Q : CategoryTheory.ProjectiveResolution Y)
(R : CategoryTheory.ProjectiveResolution Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.ProjectiveResolution.lift f P Q)
(CategoryTheory.ProjectiveResolution.lift g Q R))
R.π =
CategoryTheory.CategoryStruct.comp P.π ((ChainComplex.single₀ C).map (CategoryTheory.CategoryStruct.comp f g)) | false |
TemperedDistribution.fourierMultiplierCLM.congr_simp | Mathlib.Analysis.Distribution.FourierMultiplier | ∀ {E : Type u_3} (F : Type u_4) [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F]
[inst_2 : InnerProductSpace ℝ E] [inst_3 : NormedSpace ℂ F] [inst_4 : FiniteDimensional ℝ E]
[inst_5 : MeasurableSpace E] [inst_6 : BorelSpace E] (g g_1 : E → ℂ),
g = g_1 → TemperedDistribution.fourierMultiplierCLM F g = TemperedDistribution.fourierMultiplierCLM F g_1 | true |
derivWithin_congr | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f f₁ : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
Set.EqOn f₁ f s → f₁ x = f x → derivWithin f₁ s x = derivWithin f s x | true |
NNReal.enorm_eq | Mathlib.Analysis.Normed.Ring.Basic | ∀ (x : NNReal), ‖↑x‖ₑ = ↑x | true |
_private.Mathlib.Topology.UniformSpace.HeineCantor.0.Continuous.tendstoUniformly.match_1_1 | Mathlib.Topology.UniformSpace.HeineCantor | ∀ {α : Type u_1} [inst : UniformSpace α] (x : α) (motive : (∃ s, IsCompact s ∧ s ∈ nhds x) → Prop)
(x_1 : ∃ s, IsCompact s ∧ s ∈ nhds x), (∀ (K : Set α) (hK : IsCompact K) (hxK : K ∈ nhds x), motive ⋯) → motive x_1 | false |
Lean.Grind.CommRing.Power.denote_eq | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (p : Lean.Grind.CommRing.Power),
Lean.Grind.CommRing.Power.denote ctx p = Lean.Grind.CommRing.Var.denote ctx p.x ^ p.k | true |
ProbabilityTheory.Kernel.prodMkLeft_apply' | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (ca : γ × α) (s : Set β),
((ProbabilityTheory.Kernel.prodMkLeft γ κ) ca) s = (κ ca.2) s | true |
List.le_minIdxOn_of_apply_getElem_lt_apply_getElem._proof_2 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {xs : List α} {i : ℕ}, i < xs.length → ∀ j < i, j < xs.length | false |
_private.Mathlib.Algebra.Order.Algebra.0.Mathlib.Meta.Positivity.evalAlgebraMap._proof_5 | Mathlib.Algebra.Order.Algebra | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | false |
LinearIsometry.one_def | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {E : Type u_5} [inst : Semiring R] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module R E],
1 = LinearIsometry.id | true |
BitVec.reduceShiftLeftShiftLeft | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | true |
UpperSet.mem_Ioi_iff._simp_2 | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (b ∈ UpperSet.Ioi a) = (a < b) | false |
HomologicalComplex.extend.X.eq_2 | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_1} {c : ComplexShape ι} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : HomologicalComplex C c), HomologicalComplex.extend.X K none = 0 | true |
Std.DHashMap.Raw.Const.getD_eq_getD | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : LawfulBEq α], m.WF → ∀ {a : α} {fallback : β}, Std.DHashMap.Raw.Const.getD m a fallback = m.getD a fallback | true |
CategoryTheory.Limits.isColimitMapCoconeCoforkEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Equalizers | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (G : CategoryTheory.Functor C D) {X Y Z : C} {f g : X ⟶ Y} {h : Y ⟶ Z}
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g h),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Cofork.π
((CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.Limits.diagramIsoParallelPair ((CategoryTheory.Limits.parallelPair f g).comp G)).inv).obj
(G.mapCocone (CategoryTheory.Limits.Cofork.ofπ h w))))
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.Limits.diagramIsoParallelPair
((CategoryTheory.Limits.parallelPair f g).comp G)).inv).obj
(G.mapCocone (CategoryTheory.Limits.Cofork.ofπ h w))).pt).hom =
(CategoryTheory.Limits.Cofork.ofπ (G.map h) ⋯).π | false |
LinearMap.exact_zero_iff_injective._simp_1 | Mathlib.Algebra.Exact | ∀ {R : Type u_8} [inst : Ring R] {M : Type u_12} {N : Type u_13} (P : Type u_14) [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommMonoid P] [inst_4 : Module R N] [inst_5 : Module R M] [inst_6 : Module R P]
(f : M →ₗ[R] N), Function.Exact ⇑0 ⇑f = Function.Injective ⇑f | false |
Lean.Meta.Grind.Arith.Cutsat.State.dvds._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.PersistentArray (Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) | false |
AlgebraicGeometry.IsReduced.component_reduced | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme} [self : AlgebraicGeometry.IsReduced X] (U : X.Opens),
IsReduced ↑(X.presheaf.obj (Opposite.op U)) | true |
LieHom.quotKerEquivRange_invFun | Mathlib.Algebra.Lie.Quotient | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [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') (a : ↥(↑f).range),
f.quotKerEquivRange.invFun a = (↑f).quotKerEquivRange.invFun a | true |
Batteries.Tactic.Lint.checkAllSimpTheoremInfos | Batteries.Tactic.Lint.Simp | Lean.Expr →
(Batteries.Tactic.Lint.SimpTheoremInfo → Lean.MetaM (Option Lean.MessageData)) → Lean.MetaM (Option Lean.MessageData) | true |
Lean.Meta.Grind.Order.Cnstr | Lean.Meta.Tactic.Grind.Order.Types | Type → Type | true |
ULift.up_compare | Mathlib.Order.ULift | ∀ {α : Type u} [inst : Ord α] (a b : α), compare { down := a } { down := b } = compare a b | true |
FreeGroup.Red.decidableRel._proof_1 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1}, FreeGroup.Red [] [] | false |
CategoryTheory.ComposableArrows.homMkSucc_app_zero | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} {F G : CategoryTheory.ComposableArrows C (n + 1)}
(α : F.obj' 0 ⋯ ⟶ G.obj' 0 ⋯) (β : F.δ₀ ⟶ G.δ₀)
(w :
autoParam
(CategoryTheory.CategoryStruct.comp (F.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯)
(CategoryTheory.ComposableArrows.app' β 0 ⋯) =
CategoryTheory.CategoryStruct.comp α (G.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 ⋯))
_auto_212✝),
(CategoryTheory.ComposableArrows.homMkSucc α β w).app 0 = α | true |
CategoryTheory.Limits.BinaryFan.associatorOfLimitCone | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(L : (X Y : C) → CategoryTheory.Limits.LimitCone (CategoryTheory.Limits.pair X Y)) →
(X Y Z : C) → (L (L X Y).cone.pt Z).cone.pt ≅ (L X (L Y Z).cone.pt).cone.pt | true |
Int.fdiv_add_fmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.fdiv b + a.fmod b = a | true |
SimpleGraph.Walk.IsPath.mk' | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, p.support.Nodup → p.IsPath | true |
CategoryTheory.Functor.CommShift.ofComp | Mathlib.CategoryTheory.Shift.CommShift | {C : Type u_1} →
{D : Type u_2} →
{E : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
{F : CategoryTheory.Functor C D} →
{G : CategoryTheory.Functor D E} →
{H : CategoryTheory.Functor C E} →
(F.comp G ≅ H) →
[G.Full] →
[G.Faithful] →
(A : Type u_5) →
[inst_5 : AddMonoid A] →
[inst_6 : CategoryTheory.HasShift C A] →
[inst_7 : CategoryTheory.HasShift D A] →
[inst_8 : CategoryTheory.HasShift E A] →
[G.CommShift A] → [H.CommShift A] → F.CommShift A | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceEIntProdNatCoreE₂CohomologicalNat._proof_10 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r : ℤ) (p q p' q' : ℕ), ↑q - 1 + r = ↑q' → ↑(p', q').2 + (r, 1 - r).2 = ↑(p, q).2 | false |
SimpleGraph.between.eq_1 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} (s t : Set V) (G : SimpleGraph V),
SimpleGraph.between s t G =
{ Adj := fun v w => G.Adj v w ∧ (v ∈ s ∧ w ∈ t ∨ v ∈ t ∧ w ∈ s), symm := ⋯, loopless := ⋯ } | true |
CategoryTheory.Limits.ChosenPullback.LiftStruct.f_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}
{h : CategoryTheory.Limits.ChosenPullback f₁ f₂} {Y : C} {g₁ : Y ⟶ X₁} {g₂ : Y ⟶ X₂} {b : Y ⟶ S}
(self : h.LiftStruct g₁ g₂ b), CategoryTheory.CategoryStruct.comp self.f h.p₁ = g₁ | true |
QuadraticMap.toMatrix'._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_1} {n : Type u_2} [inst : CommRing R], SMulCommClass R R ((n → R) →ₗ[R] R) | false |
StarAlgEquiv.ofInjective._proof_3 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : StarRing A] [inst_4 : Semiring B] [inst_5 : Algebra R B] [inst_6 : StarRing B] (f : A →⋆ₐ[R] B)
(hf : Function.Injective ⇑f),
Function.RightInverse (AlgEquiv.ofInjective (↑f) hf).invFun (AlgEquiv.ofInjective (↑f) hf).toFun | false |
Nat.multinomial_pos | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} (s : Finset α) (f : α → ℕ), 0 < Nat.multinomial s f | true |
WithLp.fstₗ._proof_2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_3) (α : Type u_2) (β : Type u_1) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : 𝕜) (x_1 : WithLp p (α × β)),
(x • x_1).fst = (x • x_1).fst | false |
Lean.Elab.Tactic.Do.State.invariants | Lean.Elab.Tactic.Do.VCGen.Basic | Lean.Elab.Tactic.Do.State → Array Lean.MVarId | true |
CategoryTheory.NatTrans.Equifibered.op | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Equifibered | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_3} C] {F G : CategoryTheory.Functor J C} {α : F ⟶ G},
CategoryTheory.NatTrans.Equifibered α → CategoryTheory.NatTrans.Coequifibered (CategoryTheory.NatTrans.op α) | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_44 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls : ℕ) (ll lr : Std.DTreeMap.Internal.Impl α β) (ls : ℕ)
(ll_1 lr_1 : Std.DTreeMap.Internal.Impl α β),
ll_1.Balanced ∧
lr_1.Balanced ∧
(ll_1.size + lr_1.size ≤ 1 ∨ ll_1.size ≤ 3 * lr_1.size ∧ lr_1.size ≤ 3 * ll_1.size) ∧
ls = ll_1.size + 1 + lr_1.size →
¬3 * (ll.size + 1 + lr.size) < ll_1.size + 1 + lr_1.size →
ll.size + 1 + lr.size + (ll_1.size + 1 + lr_1.size) ≤ 1 → False | false |
Lean.SimpleScopedEnvExtension.Descr.mk.inj | Lean.ScopedEnvExtension | ∀ {α σ : Type} {name : autoParam Lean.Name Lean.SimpleScopedEnvExtension.Descr.name._autoParam} {addEntry : σ → α → σ}
{initial : σ} {finalizeImport : σ → σ} {exportEntry? : Lean.OLeanLevel → α → Option α}
{name_1 : autoParam Lean.Name Lean.SimpleScopedEnvExtension.Descr.name._autoParam} {addEntry_1 : σ → α → σ}
{initial_1 : σ} {finalizeImport_1 : σ → σ} {exportEntry?_1 : Lean.OLeanLevel → α → Option α},
{ name := name, addEntry := addEntry, initial := initial, finalizeImport := finalizeImport,
exportEntry? := exportEntry? } =
{ name := name_1, addEntry := addEntry_1, initial := initial_1, finalizeImport := finalizeImport_1,
exportEntry? := exportEntry?_1 } →
name = name_1 ∧
addEntry = addEntry_1 ∧ initial = initial_1 ∧ finalizeImport = finalizeImport_1 ∧ exportEntry? = exportEntry?_1 | true |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.exists_cons_of_mem.match_1_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a : α} (l : List α) (motive : (∃ s t, l = s ++ a :: t) → Prop) (x : ∃ s t, l = s ++ a :: t),
(∀ (l₁ l₂ : List α) (e : l = l₁ ++ a :: l₂), motive ⋯) → motive x | false |
CategoryTheory.Lax.OplaxTrans.Hom.ext | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} {x y : CategoryTheory.Lax.OplaxTrans.Hom η θ}, x.as = y.as → x = y | true |
CategoryTheory.Limits.colimitLimitIso.congr_simp | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasLimitsOfShape J C]
[inst_4 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_5 : CategoryTheory.Limits.PreservesLimitsOfShape J CategoryTheory.Limits.colim]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)),
CategoryTheory.Limits.colimitLimitIso F = CategoryTheory.Limits.colimitLimitIso F | true |
and_or_left._simp_2 | Mathlib.Tactic.Push | ∀ {a b c : Prop}, (a ∧ b ∨ a ∧ c) = (a ∧ (b ∨ c)) | false |
IsTopologicalGroup.tendstoUniformlyOn_iff | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Group G] [u : UniformSpace G] [inst_1 : IsTopologicalGroup G]
(F : ι → α → G) (f : α → G) (p : Filter ι) (s : Set α),
IsTopologicalGroup.rightUniformSpace G = u →
(TendstoUniformlyOn F f p s ↔ ∀ u_1 ∈ nhds 1, ∀ᶠ (i : ι) in p, ∀ a ∈ s, F i a / f a ∈ u_1) | true |
BooleanSubalgebra.map_le_iff_le_comap | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_3} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] {L : BooleanSubalgebra α}
{f : BoundedLatticeHom α β} {M : BooleanSubalgebra β}, BooleanSubalgebra.map f L ≤ M ↔ L ≤ BooleanSubalgebra.comap f M | true |
Lean.Server.FileWorker.queueRequest | Lean.Server.FileWorker | Lean.JsonRpc.RequestID → Lean.Server.FileWorker.PendingRequest → Lean.Server.FileWorker.WorkerM Unit | true |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_39 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | false |
Lean.OLeanLevel.exported | Lean.Environment | Lean.OLeanLevel | true |
Finset.singletonAddMonoidHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : AddZeroClass α] → α →+ Finset α | true |
FP.ofPosRatDn | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → ℕ+ → ℕ+ → FP.Float × Bool | true |
FreeAddGroup.freeAddGroupEmptyEquivAddUnit | Mathlib.GroupTheory.FreeGroup.Basic | FreeAddGroup Empty ≃ Unit | true |
Set.inter_singleton_eq_empty._simp_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ∩ {a} = ∅) = (a ∉ s) | false |
IsRelUpperSet.sInter | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {P : α → Prop} [inst : LE α] {S : Set (Set α)},
S.Nonempty → (∀ s ∈ S, IsRelUpperSet s P) → IsRelUpperSet (⋂₀ S) P | true |
Lean.Doc.Data.Syntax.stx | Lean.Elab.DocString.Builtin | Lean.Doc.Data.Syntax → Lean.Syntax | true |
Lean.mkFreshId | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadNameGenerator m] → m Lean.Name | true |
CategoryTheory.IsKernelPair.lift'._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C}
(k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X)
(w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f),
CategoryTheory.CategoryStruct.comp (k.lift p q w) a = p ∧ CategoryTheory.CategoryStruct.comp (k.lift p q w) b = q | false |
CategoryTheory.SplitEpi.mk.congr_simp | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y} (section_ section__1 : Y ⟶ X)
(e_section_ : section_ = section__1)
(id : CategoryTheory.CategoryStruct.comp section_ f = CategoryTheory.CategoryStruct.id Y),
{ section_ := section_, id := id } = { section_ := section__1, id := ⋯ } | true |
UniformFun.instPseudoMetricSpaceOfBoundedSpace._proof_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace β] (x x_1 : UniformFun α β),
0 ≤ ⨆ i, dist (UniformFun.toFun x i) (UniformFun.toFun x_1 i) | false |
instCoeTCSpectralMapOfSpectralMapClass | Mathlib.Topology.Spectral.Hom | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : FunLike F α β] → [SpectralMapClass F α β] → CoeTC F (SpectralMap α β) | true |
eq_rec_inj | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {a a' : α} (h : a = a') {C : α → Type u_3} (x y : C a), h ▸ x = h ▸ y ↔ x = y | true |
Lean.Parser.Command.initialize._regBuiltin.Lean.Parser.Command.initialize.formatter_11 | Lean.Parser.Command | IO Unit | false |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.isOffsetPattern?.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Lean.Expr → Sort u_1) →
(k : Lean.Expr) → ((k : ℕ) → motive (Lean.Expr.lit (Lean.Literal.natVal k))) → ((x : Lean.Expr) → motive x) → motive k | false |
USize.lt_irrefl | Init.Data.UInt.Lemmas | ∀ (a : USize), ¬a < a | true |
CategoryTheory.GrothendieckTopology.yonedaEquiv_symm_naturality_right | Mathlib.CategoryTheory.Sites.Subcanonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C)
[inst_1 : J.Subcanonical] (X : C) {F F' : CategoryTheory.Sheaf J (Type v)} (f : F ⟶ F')
(x : F.obj.obj (Opposite.op X)),
CategoryTheory.CategoryStruct.comp (J.yonedaEquiv.symm x) f = J.yonedaEquiv.symm (f.hom.app (Opposite.op X) x) | true |
Polynomial.quo_add_sum_rem_mul_pow_inverse_unique | Mathlib.Algebra.Polynomial.PartialFractions | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_2} [inst_1 : CommRing K] [inst_2 : Algebra (Polynomial R) K]
[FaithfulSMul (Polynomial R) K] {ι : Type u_3} {s : Finset ι} {g : ι → Polynomial R},
(∀ i ∈ s, (g i).Monic) →
((↑s).Pairwise fun i j => IsCoprime (g i) (g j)) →
∀ {n : ι → ℕ} {gi : ι → K},
(∀ i ∈ s, gi i * (algebraMap (Polynomial R) K) (g i) = 1) →
∀ {q₁ q₂ : Polynomial R} {r₁ r₂ : (i : ι) → Fin (n i) → Polynomial R},
(∀ i ∈ s, ∀ (j : Fin (n i)), (r₁ i j).degree < (g i).degree) →
(∀ i ∈ s, ∀ (j : Fin (n i)), (r₂ i j).degree < (g i).degree) →
(algebraMap (Polynomial R) K) q₁ +
∑ i ∈ s, ∑ j, (algebraMap (Polynomial R) K) (r₁ i j) * gi i ^ (↑j + 1) =
(algebraMap (Polynomial R) K) q₂ +
∑ i ∈ s, ∑ j, (algebraMap (Polynomial R) K) (r₂ i j) * gi i ^ (↑j + 1) →
q₁ = q₂ ∧ ∀ i ∈ s, r₁ i = r₂ i | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify.0.Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr.of.go.match_6 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr)) →
((lhsProof rhsProof : Lean.Expr) → motive (some (lhsProof, rhsProof))) →
((x : Option (Lean.Expr × Lean.Expr)) → motive x) → motive x | false |
MeasureTheory.Measure.ae_sum_eq | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} [Countable ι] (μ : ι → MeasureTheory.Measure α),
MeasureTheory.ae (MeasureTheory.Measure.sum μ) = ⨆ i, MeasureTheory.ae (μ i) | true |
CategoryTheory.Functor.isContinuous_id | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C),
(CategoryTheory.Functor.id C).IsContinuous J J | true |
_private.Mathlib.Analysis.Seminorm.0.Seminorm.preimage_metric_ball._simp_1_3 | Mathlib.Analysis.Seminorm | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) | false |
SimpleGraph.eq_singletonSubgraph_iff_verts_eq | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (H : G.Subgraph) {v : V}, H = G.singletonSubgraph v ↔ H.verts = {v} | true |
CategoryTheory.MorphismProperty.Comma.mapLeftId._proof_5 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} A] {B : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} B] {T : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} T]
(L : CategoryTheory.Functor A T) (R : CategoryTheory.Functor B T) {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory.MorphismProperty A} {W : CategoryTheory.MorphismProperty B} [inst_3 : Q.IsMultiplicative]
[inst_4 : W.IsMultiplicative] [inst_5 : Q.RespectsIso] [inst_6 : W.RespectsIso]
{X Y : CategoryTheory.MorphismProperty.Comma L R P Q W} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MorphismProperty.Comma.mapLeft R (CategoryTheory.CategoryStruct.id L) ⋯).map f)
((fun X =>
CategoryTheory.MorphismProperty.Comma.isoMk
(CategoryTheory.Iso.refl
((CategoryTheory.MorphismProperty.Comma.mapLeft R (CategoryTheory.CategoryStruct.id L) ⋯).obj X).left)
(CategoryTheory.Iso.refl
((CategoryTheory.MorphismProperty.Comma.mapLeft R (CategoryTheory.CategoryStruct.id L) ⋯).obj X).right)
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X =>
CategoryTheory.MorphismProperty.Comma.isoMk
(CategoryTheory.Iso.refl
((CategoryTheory.MorphismProperty.Comma.mapLeft R (CategoryTheory.CategoryStruct.id L) ⋯).obj X).left)
(CategoryTheory.Iso.refl
((CategoryTheory.MorphismProperty.Comma.mapLeft R (CategoryTheory.CategoryStruct.id L) ⋯).obj X).right)
⋯)
X).hom
((CategoryTheory.Functor.id (CategoryTheory.MorphismProperty.Comma L R P Q W)).map f) | false |
UInt8.instNonUnitalCommRing | Mathlib.Data.UInt | NonUnitalCommRing UInt8 | true |
IsRightRegular.subsingleton | Mathlib.Algebra.GroupWithZero.Regular | ∀ {R : Type u_1} [inst : MulZeroClass R], IsRightRegular 0 → Subsingleton R | true |
LinearMap.compl₁₂ | Mathlib.LinearAlgebra.BilinearMap | {R₁ : Type u_2} →
{R₂ : Type u_3} →
[inst : Semiring R₁] →
[inst_1 : Semiring R₂] →
{N : Type u_7} →
{Mₗ : Type u_10} →
{Pₗ : Type u_12} →
{Qₗ : Type u_13} →
{Qₗ' : Type u_14} →
[inst_2 : AddCommMonoid N] →
[inst_3 : AddCommMonoid Mₗ] →
[inst_4 : AddCommMonoid Pₗ] →
[inst_5 : AddCommMonoid Qₗ] →
[inst_6 : AddCommMonoid Qₗ'] →
[inst_7 : Module R₁ Mₗ] →
[inst_8 : Module R₂ N] →
[inst_9 : Module R₁ Pₗ] →
[inst_10 : Module R₁ Qₗ] →
[inst_11 : Module R₂ Pₗ] →
[inst_12 : Module R₂ Qₗ'] →
[inst_13 : SMulCommClass R₂ R₁ Pₗ] →
(Mₗ →ₗ[R₁] N →ₗ[R₂] Pₗ) →
(Qₗ →ₗ[R₁] Mₗ) → (Qₗ' →ₗ[R₂] N) → Qₗ →ₗ[R₁] Qₗ' →ₗ[R₂] Pₗ | true |
AddSubmonoid.center.addCommMonoid'._proof_3 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : AddZeroClass M] (a b c : ↥(AddSubsemigroup.center M)), a + b + c = a + (b + c) | false |
CategoryTheory.Limits.Bicone.toCoconeFunctor._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {F : J → C} {x x_1 : CategoryTheory.Limits.Bicone F}
(F_1 : x ⟶ x_1) (x_2 : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (x.ι x_2.as) F_1.hom = x_1.ι x_2.as | false |
CategoryTheory.SimplicialObject.δ_comp_σ_of_gt'._proof_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {n : ℕ} {i : Fin (n + 3)} {j : Fin (n + 2)}, j.succ < i → i = 0 → False | false |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.withProtectedMCtx.main | Lean.Meta.Tactic.Grind.Main | {m : Type → Type} →
{α : Type} →
[Monad m] →
[MonadControlT Lean.MetaM m] →
[MonadLiftT Lean.MetaM m] → Lean.Grind.Config → (Lean.MVarId → m α) → Lean.MVarId → m α | true |
NumberField.RingOfIntegers.instAlgebra_1._proof_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ (K : Type u_1) [inst : Field K] (r : NumberField.RingOfIntegers K) (x : K),
(NumberField.RingOfIntegers.instAlgebra._aux_3 K) r * x = x * (NumberField.RingOfIntegers.instAlgebra._aux_3 K) r | false |
Std.DTreeMap.Internal.Impl.Const.minKey_alter_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α] (h : t.WF)
{k : α} {f : Option β → Option β} {he : (Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.isEmpty = false},
(Std.DTreeMap.Internal.Impl.Const.alter k f t ⋯).impl.minKey he = k ↔
(f (Std.DTreeMap.Internal.Impl.Const.get? t k)).isSome = true ∧ ∀ k' ∈ t, (compare k k').isLE = true | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_not._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, ¬2 ^ w - 1 - x.toNat < 2 ^ w → False | false |
AlgebraicGeometry.Scheme.AffineCover.mk.inj | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {S : AlgebraicGeometry.Scheme} {I₀ : Type v}
{X : I₀ → CommRingCat} {f : (j : I₀) → AlgebraicGeometry.Spec (X j) ⟶ S} {idx : ↥S → I₀}
{covers : ∀ (x : ↥S), x ∈ Set.range ⇑(f (idx x))}
{map_prop : autoParam (∀ (j : I₀), P (f j)) AlgebraicGeometry.Scheme.AffineCover.map_prop._autoParam} {I₀_1 : Type v}
{X_1 : I₀_1 → CommRingCat} {f_1 : (j : I₀_1) → AlgebraicGeometry.Spec (X_1 j) ⟶ S} {idx_1 : ↥S → I₀_1}
{covers_1 : ∀ (x : ↥S), x ∈ Set.range ⇑(f_1 (idx_1 x))}
{map_prop_1 : autoParam (∀ (j : I₀_1), P (f_1 j)) AlgebraicGeometry.Scheme.AffineCover.map_prop._autoParam},
{ I₀ := I₀, X := X, f := f, idx := idx, covers := covers, map_prop := map_prop } =
{ I₀ := I₀_1, X := X_1, f := f_1, idx := idx_1, covers := covers_1, map_prop := map_prop_1 } →
I₀ = I₀_1 ∧ X ≍ X_1 ∧ f ≍ f_1 ∧ idx ≍ idx_1 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.