name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Finset.singleton_div_singleton | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Div α] (a b : α), {a} / {b} = {a / b} | true |
WeierstrassCurve.HasMultiplicativeReduction.mk._flat_ctor | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R] {K : Type u_2}
[inst_3 : Field K] [inst_4 : Algebra R K] [inst_5 : IsFractionRing R K] {W : WeierstrassCurve K},
MaximalFor (fun C => WeierstrassCurve.IsIntegral R (C • W)) (fun C => WeierstrassCurve.valuation_Δ_aux R (C • W)) 1 →
(IsDedekindDomain.HeightOneSpectrum.valuation K (IsDiscreteValuationRing.maximalIdeal R)) W.Δ < 1 →
(IsDedekindDomain.HeightOneSpectrum.valuation K (IsDiscreteValuationRing.maximalIdeal R)) W.c₄ = 1 →
WeierstrassCurve.HasMultiplicativeReduction R W | false |
FreeGroup.instUniqueOfIsEmpty | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → [IsEmpty α] → Unique (FreeGroup α) | true |
List.idxOfNth_zero | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} [inst : BEq α], List.idxOfNth x xs 0 = List.idxOf x xs | true |
fderivWithin_const_add | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} {s : Set E} (c : F), fderivWithin 𝕜 (fun y => c + f y) s x = fderivWithin 𝕜 f s x | true |
MeasureTheory.Measure.FiniteSpanningSetsIn.mono | Mathlib.MeasureTheory.Measure.Typeclasses.SFinite | {α : Type u_1} →
{m0 : MeasurableSpace α} →
{μ : MeasureTheory.Measure α} → {C D : Set (Set α)} → μ.FiniteSpanningSetsIn C → C ⊆ D → μ.FiniteSpanningSetsIn D | true |
intCyclicAddEquiv | Mathlib.GroupTheory.SpecificGroups.Cyclic | {G : Type u_2} → [Infinite G] → [inst : AddGroup G] → [IsAddCyclic G] → ℤ ≃+ G | true |
Class.coe_union._simp_1 | Mathlib.SetTheory.ZFC.Class | ∀ (x y : ZFSet.{u}), ↑x ∪ ↑y = ↑(x ∪ y) | false |
nhdsLT_le_nhdsNE | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : Preorder α] (a : α), nhdsWithin a (Set.Iio a) ≤ nhdsWithin a {a}ᶜ | true |
CategoryTheory.Pseudofunctor.mkOfLax' | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
(F : CategoryTheory.LaxFunctor B C) →
[∀ (a : B), CategoryTheory.IsIso (F.mapId a)] →
[∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g)] →
CategoryTheory.Pseudofunctor B C | true |
Real.iSup_nonpos | Mathlib.Data.Real.Archimedean | ∀ {ι : Sort u_1} {f : ι → ℝ}, (∀ (i : ι), f i ≤ 0) → ⨆ i, f i ≤ 0 | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_mem_invtSubmodule._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | false |
Finset.orderIsoOfFin.congr_simp | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α) {k : ℕ} (h : s.card = k), s.orderIsoOfFin h = s.orderIsoOfFin h | true |
_private.Init.Data.Order.Factories.0.Std.LawfulOrderSup.of_lt._simp_1_1 | Init.Data.Order.Factories | ∀ {p q : Prop}, (¬p ∧ ¬q) = ¬(p ∨ q) | false |
Lean.Meta.Tactic.TryThis.instToMessageDataSuggestionText.match_1 | Lean.Meta.TryThis | (motive : Lean.Meta.Tactic.TryThis.SuggestionText → Sort u_1) →
(x : Lean.Meta.Tactic.TryThis.SuggestionText) →
((kind : Lean.SyntaxNodeKind) →
(stx : Lean.TSyntax kind) → motive (Lean.Meta.Tactic.TryThis.SuggestionText.tsyntax stx)) →
((s : String) → motive (Lean.Meta.Tactic.TryThis.SuggestionText.string s)) → motive x | false |
OnePoint.map_some | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} {Y : Type u_2} (f : X → Y) (x : X), OnePoint.map f ↑x = ↑(f x) | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_8 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
((a ++ b).extract i j).size = (a.extract i j).size →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size | false |
CategoryTheory.Comma.mapLeftId_inv_app_left | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) (X : CategoryTheory.Comma L R),
((CategoryTheory.Comma.mapLeftId L R).inv.app X).left = CategoryTheory.CategoryStruct.id X.left | true |
MeasureTheory.lpMeasToLpTrimLie_symm_indicator | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {F : Type u_2} {p : ENNReal} [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
[one_le_p : Fact (1 ≤ p)] [inst_1 : NormedSpace ℝ F] {hm : m ≤ m0} {s : Set α} {μ : MeasureTheory.Measure α}
(hs : MeasurableSet s) (hμs : (μ.trim hm) s ≠ ⊤) (c : F),
↑((MeasureTheory.lpMeasToLpTrimLie F ℝ p μ hm).symm (MeasureTheory.indicatorConstLp p hs hμs c)) =
MeasureTheory.indicatorConstLp p ⋯ ⋯ c | true |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosSemidef.intCast._simp_1_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_3} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : IntCast α] (m : ℤ),
↑m = Matrix.diagonal ↑m | false |
ProbabilityTheory.IsCondKernelCDF.toKernel._proof_1 | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | CompactIccSpace ℝ | false |
CategoryTheory.Equivalence | Mathlib.CategoryTheory.Equivalence | (C : Type u₁) →
(D : Type u₂) →
[CategoryTheory.Category.{v₁, u₁} C] → [CategoryTheory.Category.{v₂, u₂} D] → Type (max (max (max u₁ u₂) v₁) v₂) | true |
Finsupp.NonTorsionWeight.ne_zero | Mathlib.Data.Finsupp.Weight | ∀ {σ : Type u_1} {M : Type u_2} (R : Type u_3) [inst : Semiring R] (w : σ → M) [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [Nontrivial R] [Finsupp.NonTorsionWeight R w] (s : σ), w s ≠ 0 | true |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor.congr_simp | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f f_1 : X ⟶ Y) (e_f : f = f_1)
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f],
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor f =
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.opensFunctor f_1 | true |
CategoryTheory.Abelian.SpectralObject.cyclesMap.eq_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) {i' j' k' : ι} (f' : i' ⟶ j')
(g' : j' ⟶ k') (α : CategoryTheory.ComposableArrows.mk₂ f g ⟶ CategoryTheory.ComposableArrows.mk₂ f' g') (n : ℤ),
X.cyclesMap f g f' g' α n =
X.liftCycles f' g' n (n + 1) ⋯
(CategoryTheory.CategoryStruct.comp (X.iCycles f g n)
((X.H n).map (CategoryTheory.ComposableArrows.homMk₁ (α.app 1) (α.app 2) ⋯)))
⋯ | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas.0.Nat.le_nthRoot_iff._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | false |
_private.Lean.Environment.0.Lean.AsyncContext._sizeOf_inst | Lean.Environment | SizeOf Lean.AsyncContext✝ | false |
Std.Net.MACAddr._sizeOf_inst | Std.Net.Addr | SizeOf Std.Net.MACAddr | false |
not_nonempty_empty._simp_1 | Batteries.Logic | Nonempty Empty = False | false |
ContinuousMap.instNonUnitalNonAssocRingOfIsTopologicalRing._proof_3 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : NonUnitalNonAssocRing β] [IsTopologicalRing β], ContinuousNeg β | false |
Tree.map._unsafe_rec | Mathlib.Data.Tree.Basic | {α : Type u} → {β : Type u_1} → (α → β) → Tree α → Tree β | false |
CategoryTheory.Limits.PreservesFilteredColimitsOfSize.casesOn | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{motive : CategoryTheory.Limits.PreservesFilteredColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F → Sort u} →
(t : CategoryTheory.Limits.PreservesFilteredColimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F) →
((preserves_filtered_colimits :
∀ (J : Type w) [inst_2 : CategoryTheory.Category.{w', w} J] [CategoryTheory.IsFiltered J],
CategoryTheory.Limits.PreservesColimitsOfShape J F) →
motive ⋯) →
motive t | false |
HomotopicalAlgebra.FibrantBrownFactorization.r | Mathlib.AlgebraicTopology.ModelCategory.BrownLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : HomotopicalAlgebra.ModelCategory C] →
{X Y : C} → {f : X ⟶ Y} → (self : HomotopicalAlgebra.FibrantBrownFactorization f) → self.Z ⟶ X | true |
CategoryTheory.ObjectProperty.strictMap | Mathlib.CategoryTheory.ObjectProperty.Basic | {C : Type u} →
{D : Type u'} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Category.{v', u'} D] →
CategoryTheory.ObjectProperty C → CategoryTheory.Functor C D → CategoryTheory.ObjectProperty D | true |
CategoryTheory.imageOpUnop._proof_2 | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasImage f.op | false |
CompactlySupportedContinuousMap.instMulLeftMono | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : PartialOrder β]
[inst_3 : MulZeroClass β] [inst_4 : ContinuousMul β] [MulLeftMono β],
MulLeftMono (CompactlySupportedContinuousMap α β) | true |
Field.qsmul_def | Mathlib.Algebra.Field.Defs | ∀ {K : Type u} [self : Field K] (a : ℚ) (x : K), Field.qsmul a x = ↑a * x | true |
Std.Internal.List.DistinctKeys.def | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l ↔ List.Pairwise (fun a b => (a.fst == b.fst) = false) l | true |
Std.ExtTreeSet.getGE? | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → α → Option α | true |
Lean.Linter.UnusedVariables.FVarDefinition.opts | Lean.Linter.UnusedVariables | Lean.Linter.UnusedVariables.FVarDefinition → Lean.Options | true |
MeasureTheory.memLp_re_im_iff | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} {K : Type u_8} [inst : RCLike K]
{f : α → K},
MeasureTheory.MemLp (fun x => RCLike.re (f x)) p μ ∧ MeasureTheory.MemLp (fun x => RCLike.im (f x)) p μ ↔
MeasureTheory.MemLp f p μ | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.ExpandedFieldVal.term | Lean.Elab.StructInst | Lean.Term → Lean.Elab.Term.StructInst.ExpandedFieldVal✝ | true |
Char.isLower | Init.Data.Char.Basic | Char → Bool | true |
MeasureTheory.withDensity_zero | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α}, μ.withDensity 0 = 0 | true |
FreeMagma | Mathlib.Algebra.Free | Type u → Type u | true |
Stream'.WSeq.findIndex | Mathlib.Data.WSeq.Defs | {α : Type u} → (p : α → Prop) → [DecidablePred p] → Stream'.WSeq α → Computation ℕ | true |
Std.IterM.step_takeWhile | Std.Data.Iterators.Lemmas.Combinators.Monadic.TakeWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
{it : Std.IterM m β} {P : β → Bool},
(Std.IterM.takeWhile P it).step = do
let __do_lift ← it.step
match __do_lift.inflate with
| ⟨Std.IterStep.yield it' out, h⟩ =>
match hP : P out with
| true => pure (Std.Shrink.deflate (Std.PlausibleIterStep.yield (Std.IterM.takeWhile P it') out ⋯))
| false => pure (Std.Shrink.deflate (Std.PlausibleIterStep.done ⋯))
| ⟨Std.IterStep.skip it', h⟩ =>
pure (Std.Shrink.deflate (Std.PlausibleIterStep.skip (Std.IterM.takeWhile P it') ⋯))
| ⟨Std.IterStep.done, h⟩ => pure (Std.Shrink.deflate (Std.PlausibleIterStep.done ⋯)) | true |
Lean.Level.PP.Result.offset | Lean.Level | Lean.Level.PP.Result → ℕ → Lean.Level.PP.Result | true |
IsLocalDiffeomorph.diffeomorphOfBijective._proof_3 | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {M : Type u_1} {N : Type u_2} {f : M → N} (g : N → M),
Function.LeftInverse g f ∧ Function.RightInverse g f → Function.LeftInverse g f | false |
_private.Lean.Elab.Parallel.0.Std.Iterators.Types.instIteratorTaskIteratorBaseIO.match_1 | Lean.Elab.Parallel | {α : Type} →
(motive : Std.IterStep (Std.IterM BaseIO α) α → Sort u_1) →
(x : Std.IterStep (Std.IterM BaseIO α) α) →
((it' : Std.IterM BaseIO α) → (out : α) → motive (Std.IterStep.yield it' out)) →
((it : Std.IterM BaseIO α) → motive (Std.IterStep.skip it)) → (Unit → motive Std.IterStep.done) → motive x | false |
CategoryTheory.RelCat.Hom.ctorIdx | Mathlib.CategoryTheory.Category.RelCat | {X Y : CategoryTheory.RelCat} → X.Hom Y → ℕ | false |
CategoryTheory.Limits.HasImage.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
{motive : CategoryTheory.Limits.HasImage f → Sort u_1} →
(t : CategoryTheory.Limits.HasImage f) →
((exists_image : Nonempty (CategoryTheory.Limits.ImageFactorisation f)) → motive ⋯) → motive t | false |
Matrix._aux_Mathlib_LinearAlgebra_Matrix_ConjTranspose___unexpand_Matrix_conjTranspose_1 | Mathlib.LinearAlgebra.Matrix.ConjTranspose | Lean.PrettyPrinter.Unexpander | false |
PseudoMetric.finsetSup_apply | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : AddCommMonoid R] [inst_1 : LinearOrder R] [inst_2 : AddLeftStrictMono R]
[inst_3 : IsOrderedAddMonoid R] {Y : Type u_3} {f : Y → PseudoMetric X R} {s : Finset Y} (hs : s.Nonempty) (x y : X),
(s.sup f) x y = s.sup' hs fun i => (f i) x y | true |
Std.TreeMap.getKey?_diff | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
(t₁ \ t₂).getKey? k = if k ∈ t₂ then none else t₁.getKey? k | true |
AbsoluteValue.instInhabitedIsAdmissibleIntAbs | Mathlib.NumberTheory.ClassNumber.AdmissibleAbs | Inhabited AbsoluteValue.abs.IsAdmissible | true |
Submodule.idemSemiring._proof_5 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra R A]
(a b : Submodule R A), a + b = a ⊔ b | false |
Mathlib.Tactic.Linarith.PComp.noConfusionType | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | Sort u → Mathlib.Tactic.Linarith.PComp → Mathlib.Tactic.Linarith.PComp → Sort u | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_alterKey_eq_self._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, ((a == b) = true) = (compare a b = Ordering.eq) | false |
DihedralGroup.instGroup._proof_13 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (n_1 : ℕ) (a : DihedralGroup n), zpowRec npowRec (↑n_1.succ) a = zpowRec npowRec (↑n_1) a * a | false |
kroneckerTMulLinearEquiv._proof_6 | Mathlib.RingTheory.MatrixAlgebra | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | false |
ProbabilityTheory.IsGaussian.noAtoms | Mathlib.Probability.Distributions.Gaussian.Fernique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{μ : MeasureTheory.Measure E} [ProbabilityTheory.IsGaussian μ] [CompleteSpace E] [SecondCountableTopology E],
(∀ (x : E), μ ≠ MeasureTheory.Measure.dirac x) → MeasureTheory.NoAtoms μ | true |
AlgebraicGeometry.Scheme.Modules.pseudofunctor_mapComp_hom_τl | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {a b c : CategoryTheory.LocallyDiscrete AlgebraicGeometry.Schemeᵒᵖ} (x : a ⟶ b) (x_1 : b ⟶ c),
(AlgebraicGeometry.Scheme.Modules.pseudofunctor.mapComp x x_1).hom.τl =
CategoryTheory.NatTrans.toCatHom₂ (AlgebraicGeometry.Scheme.Modules.pullbackComp x_1.as.unop x.as.unop).inv | true |
_private.Mathlib.Algebra.Homology.ShortComplex.PreservesHomology.0.CategoryTheory.ShortComplex.LeftHomologyData.mapCyclesIso_eq._simp_1_1 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃) (h₁ : S₁.LeftHomologyData)
(h₂ : S₂.LeftHomologyData) (h₃ : S₃.LeftHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap' φ₁ h₁ h₂)
(CategoryTheory.ShortComplex.cyclesMap' φ₂ h₂ h₃) =
CategoryTheory.ShortComplex.cyclesMap' (CategoryTheory.CategoryStruct.comp φ₁ φ₂) h₁ h₃ | false |
MvPolynomial.sumSMulX | Mathlib.RingTheory.MvPolynomial.IrreducibleQuadratic | {n : Type u_1} → {R : Type u_2} → [inst : CommRing R] → (n →₀ R) →ₗ[R] MvPolynomial n R | true |
ReflBEq | Init.Core | (α : Type u_1) → [BEq α] → Prop | true |
LaurentPolynomial.«term_[T;T⁻¹]» | Mathlib.Algebra.Polynomial.Laurent | Lean.TrailingParserDescr | true |
Std.DHashMap.Const.getKey!_insertManyIfNewUnit_list_of_not_mem_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α fun x => Unit} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {l : List α} {k : α},
k ∉ m → l.contains k = false → (Std.DHashMap.Const.insertManyIfNewUnit m l).getKey! k = default | true |
Lean.PrettyPrinter.Formatter.ident.formatter._regBuiltin.Lean.PrettyPrinter.Formatter.ident.formatter_1 | Lean.Parser | IO Unit | false |
mabs_le_mabs_of_one_le | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a b : α} [MulLeftMono α], 1 ≤ a → a ≤ b → |a|ₘ ≤ |b|ₘ | true |
AlternatingMap.toMultilinearMap | Mathlib.LinearAlgebra.Alternating.Basic | {R : Type u_1} →
[inst : Semiring R] →
{M : Type u_2} →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{N : Type u_3} →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R N] → {ι : Type u_7} → M [⋀^ι]→ₗ[R] N → MultilinearMap R (fun x => M) N | true |
String._sizeOf_1.eq._@.Mathlib.Util.CompileInductive.3964927263._hygCtx._hyg.24 | Mathlib.Util.CompileInductive | String._sizeOf_1 = String._sizeOf_1✝ | false |
Std.Tactic.BVDecide.BoolExpr.eval_ite | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | ∀ {α : Type} {a : α → Bool} {d l r : Std.Tactic.BVDecide.BoolExpr α},
Std.Tactic.BVDecide.BoolExpr.eval a (d.ite l r) =
bif Std.Tactic.BVDecide.BoolExpr.eval a d then Std.Tactic.BVDecide.BoolExpr.eval a l
else Std.Tactic.BVDecide.BoolExpr.eval a r | true |
groupHomology.H1ToTensorOfIsTrivial.match_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (y : G →₀ ↑A)
(hy : y ∈ (groupHomology.cycles₁ A).toAddSubgroup)
(motive : ⟨y, hy⟩ ∈ (groupHomology.shortComplexH1 A).moduleCatToCycles.range.toAddSubgroup → Prop)
(x : ⟨y, hy⟩ ∈ (groupHomology.shortComplexH1 A).moduleCatToCycles.range.toAddSubgroup),
(∀ (z : ↑(groupHomology.shortComplexH1 A).X₁) (hz : (groupHomology.shortComplexH1 A).moduleCatToCycles z = ⟨y, hy⟩),
motive ⋯) →
motive x | false |
instCStarAlgebraProd._proof_2 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_2} {B : Type u_1} [inst : CStarAlgebra A] [inst_1 : CStarAlgebra B], CStarRing (A × B) | false |
CategoryTheory.Limits.CategoricalPullback.instCategory._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_4} {B : Type u_2} {C : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} A]
[inst_1 : CategoryTheory.Category.{u_1, u_2} B] [inst_2 : CategoryTheory.Category.{u_5, u_6} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} (x : CategoryTheory.Limits.CategoricalPullback F G),
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.id x.fst)) x.iso.hom =
CategoryTheory.CategoryStruct.comp x.iso.hom (G.map (CategoryTheory.CategoryStruct.id x.snd)) | false |
_private.Mathlib.Order.Defs.Unbundled.0.«term_≺_» | Mathlib.Order.Defs.Unbundled | Lean.TrailingParserDescr | true |
_private.Mathlib.Topology.Irreducible.0.isIrreducible_iff_sUnion_isClosed._simp_1_12 | Mathlib.Topology.Irreducible | ∀ {α : Type u} {s t : Set α}, (¬Disjoint s t) = (s ∩ t).Nonempty | false |
MeasureTheory.Measure.InnerRegularWRT.of_imp | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop},
(∀ (s : Set α), q s → p s) → μ.InnerRegularWRT p q | true |
Subgroup.isComplement'_bot_top | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G], ⊥.IsComplement' ⊤ | true |
Algebraic.countable | Mathlib.Algebra.AlgebraicCard | ∀ (R : Type u) (A : Type v) [inst : CommRing R] [IsDomain R] [inst_2 : CommRing A] [IsDomain A] [inst_4 : Algebra R A]
[Module.IsTorsionFree R A] [Countable R], {x | IsAlgebraic R x}.Countable | true |
CategoryTheory.op_mono_iff._simp_1 | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono f.op = CategoryTheory.Epi f | false |
Batteries.RBSet.union | Batteries.Data.RBMap.Basic | {α : Type u_1} → {cmp : α → α → Ordering} → Batteries.RBSet α cmp → Batteries.RBSet α cmp → Batteries.RBSet α cmp | true |
_private.Lean.Meta.Tactic.Grind.VarRename.0.Lean.Meta.Grind.collectMapVars.match_1 | Lean.Meta.Tactic.Grind.VarRename | {α : Type u_1} →
{Expr : Type u_2} →
(motive : α × Expr → Sort u_3) → (x : α × Expr) → ((a : α) → (snd : Expr) → motive (a, snd)) → motive x | false |
Lean.Elab.Tactic.Omega.State.recOn | Lean.Elab.Tactic.Omega.OmegaM | {motive : Lean.Elab.Tactic.Omega.State → Sort u} →
(t : Lean.Elab.Tactic.Omega.State) → ((atoms : Std.HashMap Lean.Expr ℕ) → motive { atoms := atoms }) → motive t | false |
Int.shiftLeft_add | Init.Data.Int.Bitwise.Lemmas | ∀ (a : ℤ) (b c : ℕ), a <<< (b + c) = a <<< b <<< c | true |
TopCat.range_pullback_map | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {W X Y Z S T : TopCat} (f₁ : W ⟶ S) (f₂ : X ⟶ S) (g₁ : Y ⟶ T) (g₂ : Z ⟶ T) (i₁ : W ⟶ Y) (i₂ : X ⟶ Z) (i₃ : S ⟶ T)
[H₃ : CategoryTheory.Mono i₃]
(eq₁ : CategoryTheory.CategoryStruct.comp f₁ i₃ = CategoryTheory.CategoryStruct.comp i₁ g₁)
(eq₂ : CategoryTheory.CategoryStruct.comp f₂ i₃ = CategoryTheory.CategoryStruct.comp i₂ g₂),
Set.range ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.pullback.map f₁ f₂ g₁ g₂ i₁ i₂ i₃ eq₁ eq₂)) =
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.pullback.fst g₁ g₂)) ⁻¹'
Set.range ⇑(CategoryTheory.ConcreteCategory.hom i₁) ∩
⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.pullback.snd g₁ g₂)) ⁻¹'
Set.range ⇑(CategoryTheory.ConcreteCategory.hom i₂) | true |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.eval.match_1.eq_7 | Mathlib.Computability.TuringMachine.Config | ∀ (motive : Turing.ToPartrec.Code → Sort u_1) (f : Turing.ToPartrec.Code)
(h_1 : Unit → motive Turing.ToPartrec.Code.zero') (h_2 : Unit → motive Turing.ToPartrec.Code.succ)
(h_3 : Unit → motive Turing.ToPartrec.Code.tail) (h_4 : (f fs : Turing.ToPartrec.Code) → motive (f.cons fs))
(h_5 : (f g : Turing.ToPartrec.Code) → motive (f.comp g)) (h_6 : (f g : Turing.ToPartrec.Code) → motive (f.case g))
(h_7 : (f : Turing.ToPartrec.Code) → motive f.fix),
(match f.fix with
| Turing.ToPartrec.Code.zero' => h_1 ()
| Turing.ToPartrec.Code.succ => h_2 ()
| Turing.ToPartrec.Code.tail => h_3 ()
| f.cons fs => h_4 f fs
| f.comp g => h_5 f g
| f.case g => h_6 f g
| f.fix => h_7 f) =
h_7 f | true |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.posSemidef_diagonal_iff.match_1_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_1} {R : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [inst_3 : DecidableEq n]
{d : n → R} (motive : (Matrix.diagonal d).PosSemidef → Prop) (x : (Matrix.diagonal d).PosSemidef),
(∀ (left : (Matrix.diagonal d).IsHermitian)
(hP : ∀ (x : n →₀ R), 0 ≤ x.sum fun i xi => x.sum fun j xj => star xi * Matrix.diagonal d i j * xj), motive ⋯) →
motive x | false |
BitVec.slt_eq_sle_and_ne | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x.slt y = (x.sle y && x != y) | true |
AlgebraicGeometry.PresheafedSpace.Hom.ext._proof_1 | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : AlgebraicGeometry.PresheafedSpace C}
(α β : X.Hom Y), α.base = β.base → (TopologicalSpace.Opens.map α.base).op = (TopologicalSpace.Opens.map β.base).op | false |
List.zipWithLeft'TR.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → {β : Type u_2} → {γ : Type u_3} → (α → Option β → γ) → List α → List β → Array γ → List γ × List β | false |
CategoryTheory.Limits.Cocone.precomposeEquivalence._proof_10 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F G : CategoryTheory.Functor J C} (α : F ≅ G)
(X : CategoryTheory.Limits.Cocone F),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.NatIso.ofComponents'
(fun s =>
CategoryTheory.Limits.Cocone.ext_inv
(CategoryTheory.Iso.refl
(((CategoryTheory.Limits.Cocone.precompose α.hom).comp
(CategoryTheory.Limits.Cocone.precompose α.inv)).obj
s).pt)
⋯)
⋯).inv.app
((CategoryTheory.Limits.Cocone.precompose α.inv).obj X))
((CategoryTheory.Limits.Cocone.precompose α.inv).map
((CategoryTheory.NatIso.ofComponents'
(fun s =>
CategoryTheory.Limits.Cocone.ext_inv
(CategoryTheory.Iso.refl ((CategoryTheory.Functor.id (CategoryTheory.Limits.Cocone F)).obj s).pt) ⋯)
⋯).inv.app
X)) =
CategoryTheory.CategoryStruct.id ((CategoryTheory.Limits.Cocone.precompose α.inv).obj X) | false |
CategoryTheory.Localization.Construction.LocQuiver.mk.injEq | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C} (obj obj_1 : C),
({ obj := obj } = { obj := obj_1 }) = (obj = obj_1) | true |
LeftCancelMonoid.groupOfFinite | Mathlib.GroupTheory.OrderOfElement | {G : Type u_1} → [LeftCancelMonoid G] → [Finite G] → Group G | true |
CategoryTheory.Limits.isIsoZeroEquiv | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) →
CategoryTheory.IsIso 0 ≃ CategoryTheory.CategoryStruct.id X = 0 ∧ CategoryTheory.CategoryStruct.id Y = 0 | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.Term.listEncode.match_1.splitter | Mathlib.ModelTheory.Encoding | {L : FirstOrder.Language} →
{α : Type u_3} →
(motive : L.Term α → Sort u_4) →
(x : L.Term α) →
((i : α) → motive (FirstOrder.Language.var i)) →
((l : ℕ) → (f : L.Functions l) → (ts : Fin l → L.Term α) → motive (FirstOrder.Language.func f ts)) → motive x | true |
Int.emod_abs | Mathlib.Algebra.Order.Group.Unbundled.Int | ∀ (a b : ℤ), a % |b| = a % b | true |
RootPairing.pairingIn_lt_zero_iff | Mathlib.LinearAlgebra.RootSystem.Finite.CanonicalBilinear | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N) (S : Type u_5)
[inst_5 : CommRing S] [inst_6 : LinearOrder S] [IsStrictOrderedRing S] [inst_8 : Algebra S R] [FaithfulSMul S R]
[inst_10 : Module S M] [IsScalarTower S R M] [inst_12 : P.IsValuedIn S] {i j : ι} [Finite ι],
P.pairingIn S i j < 0 ↔ P.pairingIn S j i < 0 | true |
ContinuousLinearMap.inl | Mathlib.Topology.Algebra.Module.LinearMapPiProd | (R : Type u_1) →
[inst : Semiring R] →
(M₁ : Type u_2) →
[inst_1 : TopologicalSpace M₁] →
[inst_2 : AddCommMonoid M₁] →
[inst_3 : Module R M₁] →
(M₂ : Type u_3) →
[inst_4 : TopologicalSpace M₂] → [inst_5 : AddCommMonoid M₂] → [inst_6 : Module R M₂] → M₁ →L[R] M₁ × M₂ | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.