name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.instCreatesFiniteLimitsIndFunctorOppositeTypeInclusionOfHasFiniteLimits | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteLimits C] →
CategoryTheory.Limits.CreatesFiniteLimits (CategoryTheory.Ind.inclusion C) | true |
WithBot.instCommSemiring._proof_12 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : NoZeroDivisors α] [inst_3 : Nontrivial α],
autoParam (∀ (x : WithBot α), WithBot.instCommSemiring._aux_10 0 x = 1) Monoid.npow_zero._autoParam | false |
Std.TreeMap.Raw.get?_diff | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, (t₁ \ t₂).get? k = if k ∈ t₂ then none else t₁.get? k | true |
Matroid.finitary_iff_forall_isCircuit_finite | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α}, M.Finitary ↔ ∀ (C : Set α), M.IsCircuit C → C.Finite | true |
CategoryTheory.Limits.Multicoequalizer.condition | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasMulticoequalizer I] (a : J.L),
CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicoequalizer.π I (J.fst a)) =
CategoryTheory.CategoryStruct.comp (I.snd a) (CategoryTheory.Limits.Multicoequalizer.π I (J.snd a)) | true |
Std.HashMap.Raw._sizeOf_inst | Std.Data.HashMap.Raw | (α : Type u) → (β : Type v) → [SizeOf α] → [SizeOf β] → SizeOf (Std.HashMap.Raw α β) | false |
_private.Mathlib.Topology.Bases.0.TopologicalSpace.isSeparable_union._simp_1_1 | Mathlib.Topology.Bases | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
CategoryTheory.Abelian.SpectralObject.shortComplexMap_comp._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.toInt_umod_neg_add._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ (w : ℕ) {x : BitVec (w + 1)} {y : BitVec (w + 1)}, 0 < y.toNat → ¬2 ^ (w + 1) - y.toNat < 2 ^ (w + 1) → False | false |
Set.zero_subset | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, 0 ⊆ s ↔ 0 ∈ s | true |
Lean.Server.FileWorker.NamespaceEntry.selection | Lean.Server.FileWorker.RequestHandling | Lean.Server.FileWorker.NamespaceEntry → Lean.Syntax | true |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.completedLFunction_one_sub_of_one_lt_even | Mathlib.NumberTheory.LSeries.ZMod | ∀ {N : ℕ} [inst : NeZero N] {Φ : ZMod N → ℂ},
Function.Even Φ →
∀ {s : ℂ}, 1 < s.re → ZMod.completedLFunction Φ (1 - s) = ↑N ^ (s - 1) * ZMod.completedLFunction (ZMod.dft Φ) s | true |
Nat.exists_add_one_eq._simp_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ}, (∃ n, n + 1 = a) = (0 < a) | false |
initFn._@.Mathlib.Tactic.Continuity.Init.3906107317._hygCtx._hyg.3 | Mathlib.Tactic.Continuity.Init | IO Unit | false |
CategoryTheory.Abelian.SpectralObject.d_map_fourδ₄Toδ₃ | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₃₄ : i₂ ⟶ i₄)
(h₃₄ : CategoryTheory.CategoryStruct.comp f₃ f₄ = f₃₄) (n₀ n₁ n₂ n₃ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.d_map_fourδ₄Toδ₃._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.d_map_fourδ₄Toδ₃._auto_3)
(hn₃ : autoParam (n₂ + 1 = n₃) CategoryTheory.Abelian.SpectralObject.d_map_fourδ₄Toδ₃._auto_5),
CategoryTheory.CategoryStruct.comp (X.d f₁ f₂ f₃ f₄ f₅ n₀ n₁ n₂ n₃ hn₁ hn₂ hn₃)
(X.map f₁ f₂ f₃ f₁ f₂ f₃₄ (CategoryTheory.ComposableArrows.fourδ₄Toδ₃ f₁ f₂ f₃ f₄ f₃₄ h₃₄) n₁ n₂ n₃ hn₂ hn₃) =
0 | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_649 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
List.idxOfNth w [g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.filter (fun x => decide (x = w)) [a, g a, g (g a)]).length →
List.idxOfNth w [g (g a)] (List.idxOfNth w [g (g a)] 1) <
(List.findIdxs (fun x => decide (x = w)) [a, g a, g (g a)]).length | false |
Lean.Doc.Part._sizeOf_inst | Lean.DocString.Types | (i : Type u) → (b : Type v) → (p : Type w) → [SizeOf i] → [SizeOf b] → [SizeOf p] → SizeOf (Lean.Doc.Part i b p) | false |
Std.ExtDHashMap.eq_empty_iff_forall_not_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m = ∅ ↔ ∀ (a : α), a ∉ m | true |
MeasureTheory.Integrable.aemeasurable | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] [inst_2 : MeasurableSpace ε] [BorelSpace ε] [TopologicalSpace.PseudoMetrizableSpace ε]
{f : α → ε}, MeasureTheory.Integrable f μ → AEMeasurable f μ | true |
_private.Mathlib.Data.Sym.Sym2.0.Sym2.fromRel_irrefl.match_1_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} (motive : Std.Irrefl r → Prop) (h : Std.Irrefl r),
(∀ (h : ∀ (a : α), ¬r a a), motive ⋯) → motive h | false |
_private.Lean.Level.0.Lean.Level.isMVar._sparseCasesOn_1 | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a : Lean.LMVarId) → motive (Lean.Level.mvar a)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | false |
LinearIndependent.of_isLocalized_maximal | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(Rₚ : (P : Ideal R) → [P.IsMaximal] → Type u_5) [inst_3 : (P : Ideal R) → [inst : P.IsMaximal] → CommSemiring (Rₚ P)]
[inst_4 : (P : Ideal R) → [inst_4 : P.IsMaximal] → Algebra R (Rₚ P)]
[∀ (P : Ideal R) [inst_5 : P.IsMaximal], IsLocalization.AtPrime (Rₚ P) P]
(Mₚ : (P : Ideal R) → [P.IsMaximal] → Type u_6) [inst_6 : (P : Ideal R) → [inst : P.IsMaximal] → AddCommMonoid (Mₚ P)]
[inst_7 : (P : Ideal R) → [inst_7 : P.IsMaximal] → Module R (Mₚ P)]
[inst_8 : (P : Ideal R) → [inst : P.IsMaximal] → Module (Rₚ P) (Mₚ P)]
[∀ (P : Ideal R) [inst_9 : P.IsMaximal], IsScalarTower R (Rₚ P) (Mₚ P)]
(f : (P : Ideal R) → [inst_10 : P.IsMaximal] → M →ₗ[R] Mₚ P)
[∀ (P : Ideal R) [inst_10 : P.IsMaximal], IsLocalizedModule.AtPrime P (f P)] {ι : Type u_9} (v : ι → M),
(∀ (P : Ideal R) [inst_11 : P.IsMaximal], LinearIndependent (Rₚ P) (⇑(f P) ∘ v)) → LinearIndependent R v | true |
PowerSeries.coeff_X | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (PowerSeries.coeff n) PowerSeries.X = if n = 1 then 1 else 0 | true |
Finset.union_union_distrib_right | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t u : Finset α), s ∪ t ∪ u = s ∪ u ∪ (t ∪ u) | true |
CategoryTheory.ShortComplex.instModuleHom._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_3} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(x y : R) (b : S₁ ⟶ S₂), (x * y) • b = x • y • b | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.isNextOutParamOfLocalInstanceAndResult.hasLocalInstanceWithOutParams._unsafe_rec | Lean.Elab.App | Lean.Expr → Lean.CoreM Bool | false |
Finset.map_truncatedSup | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] [inst_2 : BoundedOrder β]
[inst_3 : DecidableLE α] [inst_4 : OrderTop α] [inst_5 : DecidableLE β] (e : α ≃o β) (s : Finset α) (a : α),
e (s.truncatedSup a) = (Finset.map e.toEmbedding s).truncatedSup (e a) | true |
retractionKerCotangentToTensorEquivSection._proof_16 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_3} {P : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
KaehlerDifferential.kerCotangentToTensor R P S =
↑(LinearEquiv.restrictScalars P (tensorKaehlerQuotKerSqEquiv R P S)) ∘ₗ
↑P (KaehlerDifferential.kerToTensor R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S) ∘ₗ
↑((RingHom.ker (algebraMap P S)).cotangentEquivIdeal.trans
(LinearEquiv.restrictScalars P
(LinearEquiv.ofEq (RingHom.ker (IsScalarTower.toAlgHom R P S).toRingHom).cotangentIdeal
(RingHom.ker (IsScalarTower.toAlgHom R P S).kerSquareLift.toRingHom) ⋯))) →
∀ (l : TensorProduct P S Ω[P⁄R] →ₗ[P] (RingHom.ker (algebraMap P S)).Cotangent),
l ∘ₗ KaehlerDifferential.kerCotangentToTensor R P S = LinearMap.id →
{
toAddHom :=
↑(↑((RingHom.ker (algebraMap P S)).cotangentEquivIdeal.trans
(LinearEquiv.restrictScalars P
(LinearEquiv.ofEq (RingHom.ker (IsScalarTower.toAlgHom R P S).toRingHom).cotangentIdeal
(RingHom.ker (IsScalarTower.toAlgHom R P S).kerSquareLift.toRingHom) ⋯))) ∘ₗ
l ∘ₗ ↑(LinearEquiv.restrictScalars P (tensorKaehlerQuotKerSqEquiv R P S))),
map_smul' := ⋯ } ∘ₗ
KaehlerDifferential.kerToTensor R (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S =
LinearMap.id | false |
Cardinal.zero_toNat | Mathlib.SetTheory.Cardinal.ToNat | Cardinal.toNat 0 = 0 | true |
MvPolynomial.finSuccEquiv_X_zero | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u} [inst : CommSemiring R] {n : ℕ}, (MvPolynomial.finSuccEquiv R n) (MvPolynomial.X 0) = Polynomial.X | true |
LaurentPolynomial.leval | Mathlib.Algebra.Polynomial.Laurent | (R : Type u_1) →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid S] → [inst_2 : Module R S] → [inst_3 : Monoid S] → Sˣ → LaurentPolynomial R →ₗ[R] S | true |
MulAction.aestabilizer_empty | Mathlib.MeasureTheory.Group.AEStabilizer | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {x : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_2 : MeasureTheory.SMulInvariantMeasure G α μ], MulAction.aestabilizer G μ ∅ = ⊤ | true |
_private.Lean.Parser.Types.0.Lean.Parser.FirstTokens.seq._sparseCasesOn_1 | Lean.Parser.Types | {motive : Lean.Parser.FirstTokens → Sort u} →
(t : Lean.Parser.FirstTokens) →
motive Lean.Parser.FirstTokens.epsilon →
((a : List Lean.Parser.Token) → motive (Lean.Parser.FirstTokens.optTokens a)) →
(Nat.hasNotBit 9 t.ctorIdx → motive t) → motive t | false |
List.Pairwise.insertionSort_eq | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] {l : List α}, List.Pairwise r l → List.insertionSort r l = l | true |
riemannZeta_one | Mathlib.NumberTheory.Harmonic.ZetaAsymp | riemannZeta 1 = (↑Real.eulerMascheroniConstant - Complex.log (4 * ↑Real.pi)) / 2 | true |
_private.Mathlib.Analysis.Calculus.Deriv.MeanValue.0.not_differentiableWithinAt_of_deriv_tendsto_atTop_Ioi._simp_1_1 | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (s ∈ nhds x) = (x ∈ interior s) | false |
Std.Sat.CNF.mk._flat_ctor | Std.Sat.CNF.Basic | {α : Type u} → Array (Std.Sat.CNF.Clause α) → Std.Sat.CNF α | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeSyntheticMVars.loop._unsafe_rec | Lean.Elab.SyntheticMVars | Lean.Elab.Term.PostponeBehavior → Bool → Unit → Lean.Elab.TermElabM Unit | false |
HomotopicalAlgebra.Cylinder.LeftHomotopy.refl | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] →
(P : HomotopicalAlgebra.Cylinder X) → (f : X ⟶ Y) → P.LeftHomotopy f f | true |
_private.Mathlib.InformationTheory.KullbackLeibler.ChainRule.0.InformationTheory.integral_llr_compProd_eq_add._simp_1_6 | Mathlib.InformationTheory.KullbackLeibler.ChainRule | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] [MeasureTheory.IsFiniteMeasure μ] {c : ε},
‖c‖ₑ ≠ ⊤ → MeasureTheory.Integrable (fun x => c) μ = True | false |
groupCohomology.cocycles₂_ρ_map_inv_sub_map_inv | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u_1, u, u} k G} (f : ↥(groupCohomology.cocycles₂ A))
(g : G), (A.ρ g) (f (g⁻¹, g)) - f (g, g⁻¹) = f (1, 1) - f (g, 1) | true |
NumberField.mixedEmbedding.volume_negAt_plusPart | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] {s : Set { w // w.IsReal }} {A : Set (NumberField.mixedEmbedding.mixedSpace K)}
[inst_1 : NumberField K],
MeasurableSet A →
MeasureTheory.volume (⇑(NumberField.mixedEmbedding.negAt s) '' NumberField.mixedEmbedding.plusPart A) =
MeasureTheory.volume (NumberField.mixedEmbedding.plusPart A) | true |
maximal_gt_iff._simp_1 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {x y : α} [inst : Preorder α], Maximal (fun x => y < x) x = (y < x ∧ IsMax x) | false |
_private.Aesop.Tree.TreeM.0.Aesop.mkInitialTree.match_1 | Aesop.Tree.TreeM | (motive : Aesop.ForwardState × Array Aesop.ForwardRuleMatch → Sort u_1) →
(__discr : Aesop.ForwardState × Array Aesop.ForwardRuleMatch) →
((forwardState : Aesop.ForwardState) → (ms : Array Aesop.ForwardRuleMatch) → motive (forwardState, ms)) →
motive __discr | false |
AlgebraicGeometry.StructureSheaf.comap._proof_5 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] (f : R →+* S)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))
(V : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top S))
(hUV : V.carrier ⊆ PrimeSpectrum.comap f ⁻¹' U.carrier)
(r s : ↑((AlgebraicGeometry.Spec.structureSheaf R).obj.obj (Opposite.op U))),
(AlgebraicGeometry.StructureSheaf.comapₗ f.toSemilinearMap U V hUV).toFun (r * s) =
(AlgebraicGeometry.StructureSheaf.comapₗ f.toSemilinearMap U V hUV).toFun r *
(AlgebraicGeometry.StructureSheaf.comapₗ f.toSemilinearMap U V hUV).toFun s | false |
Pi.involutiveNeg.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → InvolutiveNeg (f i)],
Pi.involutiveNeg = { toNeg := Pi.instNeg, neg_neg := ⋯ } | true |
Lean.Meta.Simp.ConfigCtx.mk._flat_ctor | Init.MetaTypes | ℕ →
ℕ →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Lean.Meta.EtaStructMode →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool → Bool → Option ℕ → Bool → Bool → Lean.Meta.Simp.ConfigCtx | false |
Lean.Grind.CommRing.Poly.pow | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly | true |
MeasureTheory.Measure.prod_sum | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {ι : Type u_4} {ι' : Type u_5}
[Countable ι'] (m : ι → MeasureTheory.Measure α) (m' : ι' → MeasureTheory.Measure β)
[∀ (n : ι'), MeasureTheory.SFinite (m' n)],
(MeasureTheory.Measure.sum m).prod (MeasureTheory.Measure.sum m') =
MeasureTheory.Measure.sum fun p => (m p.1).prod (m' p.2) | true |
instAlgebraCliffordAlgebra._proof_6 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (r : R) (x : CliffordAlgebra Q), r • x = (instAlgebraCliffordAlgebra._aux_3 Q) r * x | false |
Module.toCentroidHom_apply_toFun | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] {R : Type u_6} [inst_1 : CommSemiring R] [inst_2 : Module R α]
[inst_3 : SMulCommClass R α α] [inst_4 : IsScalarTower R α α] (x : R) (a : α), (Module.toCentroidHom x) a = x • a | true |
CommGrpCat.Forget₂.createsLimit._proof_8 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J CommGrpCat)
(s : CategoryTheory.Limits.Cone F)
(x y : ↑(((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat)).mapCone s).1)
{j j' : J} (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget MonCat).mapCone
(((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat)).mapCone
s)).π.app
j)
(((F.comp ((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat))).comp
(CategoryTheory.forget MonCat)).map
f)
(x * y) =
((CategoryTheory.forget MonCat).mapCone
(((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat)).mapCone s)).π.app
j' (x * y) | false |
Submodule.IsOrtho.map | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F] (f : E →ₗᵢ[𝕜] F)
{U V : Submodule 𝕜 E}, U ⟂ V → Submodule.map (↑f) U ⟂ Submodule.map (↑f) V | true |
Sublattice.map_bot | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] (f : LatticeHom α β), Sublattice.map f ⊥ = ⊥ | true |
Std.Internal.List.getKey!_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] [inst_2 : Inhabited α] {k : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKey! k (Std.Internal.List.modifyKey k f l) =
if Std.Internal.List.containsKey k l = true then k else default | true |
Matroid.IsNonloop.removeLoops_isNonloop | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsNonloop e → M.removeLoops.IsNonloop e | true |
Lean.Meta.Simp.UsedSimps.contains | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.UsedSimps → Lean.Meta.Origin → Bool | true |
ModularFormClass.cuspFunction_apply_zero | Mathlib.NumberTheory.ModularForms.QExpansion | ∀ {k : ℤ} {F : Type u_1} [inst : FunLike F UpperHalfPlane ℂ] {Γ : Subgroup (GL (Fin 2) ℝ)} {h : ℝ} (f : F)
[ModularFormClass F Γ k],
0 < h → h ∈ Γ.strictPeriods → SlashInvariantFormClass.cuspFunction h (⇑f) 0 = UpperHalfPlane.valueAtInfty ⇑f | true |
norm_tangentSpace_vectorSpace | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {F : Type u_4} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] {x : F}
{v : TangentSpace (modelWithCornersSelf ℝ F) x}, ‖v‖ = ‖v‖ | true |
CategoryTheory.sum.inlCompInlCompAssociator | Mathlib.CategoryTheory.Sums.Associator | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(E : Type u₃) →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
(CategoryTheory.Sum.inl_ C D).comp
((CategoryTheory.Sum.inl_ (C ⊕ D) E).comp (CategoryTheory.sum.associator C D E)) ≅
CategoryTheory.Sum.inl_ C (D ⊕ E) | true |
_private.Mathlib.LinearAlgebra.Matrix.NonsingularInverse.0.Matrix.add_mul_mul_inv_eq_sub'._simp_1_1 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
[inst_3 : Invertible A], A⁻¹ = ⅟A | false |
_private.Mathlib.Algebra.Category.HopfAlgCat.Basic.0.HopfAlgCat.Hom.ext.match_1 | Mathlib.Algebra.Category.HopfAlgCat.Basic | ∀ {R : Type u_2} {inst : CommRing R} {V W : HopfAlgCat R} (motive : V.Hom W → Prop) (h : V.Hom W),
(∀ (toBialgHom' : V.carrier →ₐc[R] W.carrier), motive { toBialgHom' := toBialgHom' }) → motive h | false |
Batteries.OrientedOrd | Batteries.Classes.Deprecated | (α : Type u_1) → [Ord α] → Prop | true |
Ordnode.insert.eq_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : LE α] [inst_1 : DecidableLE α] (x : α), Ordnode.insert x Ordnode.nil = Ordnode.singleton x | true |
_private.Mathlib.Analysis.Normed.Operator.Basic.0.ball_subset_range_iff_surjective._simp_1_2 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
CartanMatrix.not_isSimplyLaced_G₂ | Mathlib.Data.Matrix.Cartan | ¬CartanMatrix.G₂.IsSimplyLaced | true |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.fac_assoc | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} {X : C} {data : F.OneHypercoverDenseData J₀ J X} {X₀ : C₀}
{f : F.obj X₀ ⟶ X} {Y₀ : C₀} {g : Y₀ ⟶ X₀} (self : data.SieveStruct f g) {Z : C} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp self.q (CategoryTheory.CategoryStruct.comp (data.f self.i₀) h) =
CategoryTheory.CategoryStruct.comp (F.map g) (CategoryTheory.CategoryStruct.comp f h) | true |
CategoryTheory.instInhabitedIsSplitCoequalizerId._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id X | false |
TensorProduct.rightComm._proof_17 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (N →ₗ[R] TensorProduct R (TensorProduct R M N) P) | false |
SheafOfModules.QuasicoherentData.bind._proof_3 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
[∀ (X : C) (Y : CategoryTheory.Over X), ((J.over X).over Y).WEqualsLocallyBijective AddCommGrpCat] {I : Type u_3}
(X : I → C) (i : I) (Y : CategoryTheory.Over (X i)), ((J.over (X i)).over Y).WEqualsLocallyBijective AddCommGrpCat | false |
Lean.CollectAxioms.State.mk._flat_ctor | Lean.Util.CollectAxioms | Lean.NameSet → Array Lean.Name → Lean.CollectAxioms.State | false |
Lean.ImportArtifacts.ofArray.inj | Lean.Setup | ∀ {toArray toArray_1 : Array System.FilePath}, { toArray := toArray } = { toArray := toArray_1 } → toArray = toArray_1 | true |
_private.Mathlib.NumberTheory.Harmonic.ZetaAsymp.0.ZetaAsymptotics.term_one._simp_1_11 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a | false |
IsFractionRing.charZero_of_isFractionRing | Mathlib.Algebra.CharP.Algebra | ∀ (R : Type u_3) {K : Type u_4} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
[CharZero R], CharZero K | true |
_private.Lean.Elab.PreDefinition.WF.Unfold.0.Lean.Elab.WF.rwFixEq | Lean.Elab.PreDefinition.WF.Unfold | Lean.MVarId → Lean.MetaM Lean.MVarId | true |
instArchimedeanRat | Mathlib.Algebra.Order.Archimedean.Basic | Archimedean ℚ | true |
Ctop.Realizer | Mathlib.Data.Analysis.Topology | (α : Type u_6) → [T : TopologicalSpace α] → Type (max (u_5 + 1) u_6) | true |
ProbabilityTheory.indepSets_of_indepSets_of_le_right | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s₁ s₂ s₃ : Set (Set Ω)},
ProbabilityTheory.IndepSets s₁ s₂ μ → s₃ ⊆ s₂ → ProbabilityTheory.IndepSets s₁ s₃ μ | true |
Submonoid.groupPowers.eq_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] {x : M} {n : ℕ} (hpos : 0 < n) (hx : x ^ n = 1),
Submonoid.groupPowers hpos hx =
{ toMonoid := (Submonoid.powers x).toMonoid, inv := fun x_1 => x_1 ^ (n - 1), div := DivInvMonoid.div',
div_eq_mul_inv := ⋯, zpow := fun z x_1 => x_1 ^ z.natMod ↑n, zpow_zero' := ⋯, zpow_succ' := ⋯, zpow_neg' := ⋯,
inv_mul_cancel := ⋯ } | true |
ContinuousLinearMap.eqOn_closure_span | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] [T2Space M₂] {s : Set M₁}
{f g : M₁ →SL[σ₁₂] M₂}, Set.EqOn (⇑f) (⇑g) s → Set.EqOn (⇑f) (⇑g) (closure ↑(Submodule.span R₁ s)) | true |
Homeomorph.addLeft.eq_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : SeparatelyContinuousAdd G] (a : G),
Homeomorph.addLeft a = { toEquiv := Equiv.addLeft a, continuous_toFun := ⋯, continuous_invFun := ⋯ } | true |
IsPrimitiveRoot.pow_ne_one_of_pos_of_lt | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k l : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → l ≠ 0 → l < k → ζ ^ l ≠ 1 | true |
Std.TreeSet.Raw.insertMany_append | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} {l₁ l₂ : List α},
t.insertMany (l₁ ++ l₂) = (t.insertMany l₁).insertMany l₂ | true |
_private.Mathlib.Analysis.Normed.Algebra.Exponential.0.NormedSpace.expSeries_radius_eq_top._simp_1_1 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {α : Type u_2} [inst : NormedDivisionRing α] (a b : α), ‖a‖ / ‖b‖ = ‖a / b‖ | false |
SimpleGraph.Dart.symm_mk | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} {G : SimpleGraph V} {p : V × V} (h : G.Adj p.1 p.2),
{ toProd := p, adj := h }.symm = { toProd := p.swap, adj := ⋯ } | true |
Std.DHashMap.Internal.Raw₀.Const.get_insertMany_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m).WF →
∀ {l : List (α × β)} {k k' : α},
(k == k') = true →
∀ {v : β},
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
(k, v) ∈ l →
∀ {h' : (↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m l)).contains k' = true},
Std.DHashMap.Internal.Raw₀.Const.get (↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m l)) k' h' = v | true |
Matrix.conjTranspose_inv_ofNat_smul | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : DivisionSemiring R] [inst_1 : AddCommMonoid α]
[inst_2 : StarAddMonoid α] [inst_3 : Module R α] (c : ℕ) [inst_4 : c.AtLeastTwo] (M : Matrix m n α),
((OfNat.ofNat c)⁻¹ • M).conjTranspose = (OfNat.ofNat c)⁻¹ • M.conjTranspose | true |
Basis.piTensorProduct_apply | Mathlib.LinearAlgebra.PiTensorProduct.Basis | ∀ {ι : Type u_1} {R : Type u_2} {M : ι → Type u_3} {κ : ι → Type u_4} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
(b : (i : ι) → Module.Basis (κ i) R (M i)) (p : (i : ι) → κ i),
(Basis.piTensorProduct b) p = ⨂ₜ[R] (i : ι), (b i) (p i) | true |
pow_le_pow_right₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} {m n : ℕ} [ZeroLEOneClass M₀]
[PosMulMono M₀], 1 ≤ a → m ≤ n → a ^ m ≤ a ^ n | true |
Rep.indCoindIso._proof_2 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] [inst_3 : S.FiniteIndex] (A : Rep.{u_1, u_1, u_1} k ↥S) (g : G),
↑(LinearEquiv.ofLinear A.indToCoind A.coindToInd ⋯ ⋯) ∘ₗ (Representation.ind S.subtype A.ρ) g =
(Representation.coind S.subtype A.ρ) g ∘ₗ ↑(LinearEquiv.ofLinear A.indToCoind A.coindToInd ⋯ ⋯) | false |
DirectedSystem.rTensor | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ (R : Type u) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N] {ι : Type u_3}
[inst_3 : Preorder ι] {F : ι → Type u_4} [inst_4 : (i : ι) → AddCommMonoid (F i)] [inst_5 : (i : ι) → Module R (F i)]
{f : ⦃i j : ι⦄ → i ≤ j → F i →ₗ[R] F j},
(DirectedSystem F fun x x_1 h => ⇑(f h)) →
DirectedSystem (fun i => TensorProduct R (F i) N) fun x x_1 h => ⇑(LinearMap.rTensor N (f h)) | true |
Nat.zeckendorf.eq_def | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (x : ℕ),
x.zeckendorf =
match x with
| 0 => []
| m@h:n.succ => m.greatestFib :: (m - Nat.fib m.greatestFib).zeckendorf | true |
AddSubgroup.index_map_of_injective | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] (H : AddSubgroup G) {f : G →+ G'},
Function.Injective ⇑f → (AddSubgroup.map f H).index = H.index * f.range.index | true |
Action.instLinear._proof_4 | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_3} [inst_1 : Monoid G]
[inst_2 : CategoryTheory.Preadditive V] {R : Type u_4} [inst_3 : Semiring R] [inst_4 : CategoryTheory.Linear R V]
(X Y : Action V G) (a : R), a • 0 = 0 | false |
FiberBundleCore.Fiber | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} → [inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → FiberBundleCore ι B F → B → Type u_3 | true |
CategoryTheory.Limits.widePullbackShapeUnopOp._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) {X Y : CategoryTheory.Limits.WidePullbackShape J} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.widePullbackShapeOp J).comp (CategoryTheory.Limits.widePushoutShapeUnop J)).map f)
((fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Limits.widePullbackShapeOp J).comp (CategoryTheory.Limits.widePushoutShapeUnop J)).obj
x))
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Limits.widePullbackShapeOp J).comp (CategoryTheory.Limits.widePushoutShapeUnop J)).obj
x))
X).hom
((CategoryTheory.Functor.id (CategoryTheory.Limits.WidePullbackShape J)).map f) | false |
DirectSum.coeAddMonoidHom_of | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type v} {M : Type u_1} {S : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike S M]
[inst_3 : AddSubmonoidClass S M] (A : ι → S) (i : ι) (x : ↥(A i)),
(DirectSum.coeAddMonoidHom A) ((DirectSum.of (fun i => ↥(A i)) i) x) = ↑x | true |
_private.Mathlib.FieldTheory.PurelyInseparable.Exponent.0.IsPurelyInseparable.iterateFrobeniusAux | Mathlib.FieldTheory.PurelyInseparable.Exponent | (K : Type u_2) →
(L : Type u_3) →
[inst : Field K] →
[inst_1 : Field L] → [inst_2 : Algebra K L] → [IsPurelyInseparable.HasExponent K L] → ℕ → ℕ → L → K | true |
_private.Lean.Meta.Closure.0.Lean.Meta.Closure.TopoSort.mk | Lean.Meta.Closure | Lean.FVarIdHashSet → Lean.FVarIdHashSet → Array Lean.LocalDecl → Array Lean.Expr → Lean.Meta.Closure.TopoSort✝ | true |
List.getElem_length_sub_one_eq_getLast._proof_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α}, l.length - 1 < l.length → l ≠ [] | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.