name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.UInt.Lemmas.0.USize.toUInt8_eq._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a = b) = (a.toNat = b.toNat) | null | false |
CategoryTheory.Limits.biprod.fst_op_opIso_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P Q : C) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct P Q] {Z : Cᵒᵖ} (h : Opposite.op P ⊞ Opposite.op Q ⟶ Z),
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.biprod.fst.op
(Category... | null | true |
_private.Mathlib.Analysis.Calculus.TangentCone.ProperSpace.0.tangentConeAt_nonempty_of_properSpace._simp_1_7 | Mathlib.Analysis.Calculus.TangentCone.ProperSpace | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
Aesop.Options.ctorIdx | Aesop.Options.Public | Aesop.Options → ℕ | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.isPatternVar._sparseCasesOn_4 | Lean.Elab.Match | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.WithTerminal.down | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → (CategoryTheory.WithTerminal.of X ⟶ CategoryTheory.WithTerminal.of Y) → (X ⟶ Y) | Helper function for typechecking. | true |
Matrix.toBlocks₂₁ | Mathlib.Data.Matrix.Block | {l : Type u_1} →
{m : Type u_2} → {n : Type u_3} → {o : Type u_4} → {α : Type u_11} → Matrix (n ⊕ o) (l ⊕ m) α → Matrix o l α | Given a matrix whose row and column indexes are sum types, we can extract the corresponding
"bottom left" submatrix. | true |
HomotopicalAlgebra.RelativeCellComplex.transfiniteCompositionOfShape'._proof_3 | Mathlib.AlgebraicTopology.RelativeCellComplex.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4} [inst_1 : LinearOrder J]
[inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J] {α : J → Type u_5} {A B : (j : J) → α j → C}
{basicCell : (j : J) → (i : α j) → A j i ⟶ B j i} {X Y : C} {f : X ⟶ Y}
(c : HomotopicalAlgebr... | null | false |
Dioph.«termD&_» | Mathlib.NumberTheory.Dioph | Lean.ParserDescr | Projection preserves Diophantine functions. | true |
partialOrderOfSO._proof_4 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [IsStrictOrder α r] (x y : α), x = y ∨ r x y → y = x ∨ r y x → x = y | null | false |
FourierTransformInv.casesOn | Mathlib.Analysis.Fourier.Notation | {E : Type u} →
{F : Type v} →
{motive : FourierTransformInv E F → Sort u_1} →
(t : FourierTransformInv E F) → ((fourierInv : E → F) → motive { fourierInv := fourierInv }) → motive t | null | false |
List.iterate.match_1 | Mathlib.Data.List.Defs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
Aesop.RappId.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.RappId} → t = t' → Aesop.RappId.noConfusionType P t t' | null | false |
isOpen_compl_iff._simp_1 | Mathlib.Topology.Basic | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen sᶜ = IsClosed s | null | false |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.sSameSide_self_iff.match_1_1 | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x : P} (motive : s.SSameSide x x → Prop) (x_1 : s.SSameSide x x),
(∀ (h : s.WSameSide x x... | null | false |
Pi.normedCommGroup._proof_1 | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_2} [inst : (i : ι) → NormedCommGroup (G i)] (a b : (i : ι) → G i), a * b = b * a | null | false |
kroneckerTMulLinearEquiv._proof_2 | Mathlib.RingTheory.MatrixAlgebra | ∀ (l : Type u_1) (m : Type u_3) (n : Type u_4) (p : Type u_5) (R : Type u_8) (S : Type u_7) (M : Type u_6)
(N : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N]
[inst_4 : Algebra R S] [inst_5 : Module R M] [inst_6 : Module S M] [inst_7 : Module R N]
[in... | null | false |
Function.Injective.invOfMemRange_surjective | Mathlib.Data.Fintype.Inv | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : DecidableEq β] {f : α → β} (hf : Function.Injective f),
Function.Surjective hf.invOfMemRange | null | true |
SSet.const_app | Mathlib.AlgebraicTopology.SimplicialSet.Basic | ∀ {X Y : SSet} (y : Y.obj (Opposite.op { len := 0 })) (n : SimplexCategoryᵒᵖ),
(SSet.const y).app n =
TypeCat.ofHom fun x => (CategoryTheory.ConcreteCategory.hom (Y.map ((Opposite.unop n).const { len := 0 } 0).op)) y | null | true |
AlgHom.fieldRange._proof_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_3} {L : Type u_1} {L' : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'], RingHomClass (L →ₐ[K] L') L L' | null | false |
Polynomial.card_support_eraseLead_add_one | Mathlib.Algebra.Polynomial.EraseLead | ∀ {R : Type u_1} [inst : Semiring R] {f : Polynomial R}, f ≠ 0 → f.eraseLead.support.card + 1 = f.support.card | null | true |
AlgebraicGeometry.locallyQuasiFinite_iff_isDiscrete_preimage_singleton | Mathlib.AlgebraicGeometry.Morphisms.QuasiFinite | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [AlgebraicGeometry.LocallyOfFiniteType f],
AlgebraicGeometry.LocallyQuasiFinite f ↔ ∀ (x : ↥Y), IsDiscrete (⇑f ⁻¹' {x}) | null | true |
Algebra.SubmersivePresentation.ofSubsingleton._proof_2 | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ (R : Type u_1) (S : Type u_3) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Subsingleton S],
Ideal.span (Set.range fun x => 1) = { val := fun x => 1, σ' := fun x => 1, aeval_val_σ' := ⋯, algebraMap_eq := ⋯ }.ker | null | false |
Std.CloseableChannel.instDecidableEqError._proof_2 | Std.Sync.Channel | ∀ (x y : Std.CloseableChannel.Error), ¬x.ctorIdx = y.ctorIdx → x = y → False | null | false |
ProfiniteAddGrp.instPreservesLimitsProfiniteForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteContinuousMap | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget₂ ProfiniteAddGrp.{u_1} Profinite) | null | true |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.Style.Header.headerLinter.match_3 | Mathlib.Tactic.Linter.Header | (motive : Option Bool → Sort u_1) →
(__do_lift : Option Bool) → ((d : Bool) → motive (some d)) → (Unit → motive none) → motive __do_lift | null | false |
Mathlib.Tactic.AtomM.Recurse.Config.contextual._default | Mathlib.Util.AtomM.Recurse | Bool | null | false |
separableClosure.adjoin_eq_of_isAlgebraic | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsAlgebraic F E],
IntermediateField.adjoin E ↑(separableClosure F K) = separableClosure E K | If `K / E / F` is a field extension tower, such that `E / F` is algebraic, then
`E` adjoin `separableClosure F K` is equal to `separableClosure E K`. | true |
IrreducibleSpace.rec | Mathlib.Topology.Irreducible | {X : Type u_3} →
[inst : TopologicalSpace X] →
{motive : IrreducibleSpace X → Sort u} →
([toPreirreducibleSpace : PreirreducibleSpace X] → (toNonempty : Nonempty X) → motive ⋯) →
(t : IrreducibleSpace X) → motive t | null | false |
AddMonoidHom.compLeftContinuous.congr_simp | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ (α : Type u_1) {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_3}
[inst_2 : AddMonoid β] [inst_3 : ContinuousAdd β] [inst_4 : TopologicalSpace γ] [inst_5 : AddMonoid γ]
[inst_6 : ContinuousAdd γ] (g g_1 : β →+ γ) (e_g : g = g_1) (hg : Continuous ⇑g),
AddMonoidHom.compLeftCon... | null | true |
Std.ExtDTreeMap.Const.getKey?_filter | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α},
(Std.ExtDTreeMap.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.ExtDTreeMap.Const.get t x ⋯) | null | true |
CategoryTheory.GrothendieckTopology.toPretopology._proof_4 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (J : CategoryTheory.GrothendieckTopology C) (X : C)
(S : CategoryTheory.Presieve X) (Ti : ⦃Y : C⦄ → (f : Y ⟶ X) → S f → CategoryTheory.Presieve Y),
S ∈ {R | CategoryTheory.Sieve.generate R ∈ J X} →
(∀ ⦃Y : C⦄ (f : Y ⟶ X) (H : S f), Ti f H ∈ {R | Cat... | null | false |
AntitoneOn.sup | Mathlib.Order.Lattice | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : SemilatticeSup β] {f g : α → β} {s : Set α},
AntitoneOn f s → AntitoneOn g s → AntitoneOn (f ⊔ g) s | Pointwise supremum of two antitone functions is an antitone function. | true |
_private.Mathlib.Algebra.Order.Antidiag.Nat.0.Nat.card_pair_lcm_eq.f._proof_1 | Mathlib.Algebra.Order.Antidiag.Nat | NeZero (2 + 1) | null | false |
CategoryTheory.Mon.instCartesianMonoidalCategory._proof_3 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (M N : CategoryTheory.Mon C),
{ hom := CategoryTheory.SemiCartesianMonoidalCategory.fst M.X N.X, isMonHom_hom := ⋯ } =
CategoryTheory.CategoryStruct.co... | null | false |
StrictMonoOn.continuousWithinAt_right_of_image_mem_nhdsWithin | Mathlib.Topology.Order.MonotoneContinuity | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[inst_3 : LinearOrder β] [inst_4 : TopologicalSpace β] [OrderTopology β] [DenselyOrdered β] {f : α → β} {s : Set α}
{a : α},
StrictMonoOn f s →
s ∈ nhdsWithin a (Set.Ici a) → f '' s ∈ nhdsWithin (f a) (Set.I... | If a function `f` with a densely ordered codomain is strictly monotone on a right neighborhood
of `a` and the image of this neighborhood under `f` is a right neighborhood of `f a`, then `f` is
continuous at `a` from the right. | true |
Sylow.inhabited | Mathlib.GroupTheory.Sylow | {p : ℕ} → {G : Type u_1} → [inst : Group G] → Inhabited (Sylow p G) | null | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.node4L.match_1.eq_2 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (motive : Ordnode α → α → Ordnode α → α → Ordnode α → Sort u_2) (l : Ordnode α) (x z : α)
(r : Ordnode α)
(h_1 :
(l : Ordnode α) →
(x : α) →
(size : ℕ) →
(ml : Ordnode α) →
(y : α) → (mr : Ordnode α) → (z : α) → (r : Ordnode α) → motive l x (Ordnode.node size... | null | true |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.discharge?'.match_3 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Except Lean.Exception Lean.Meta.Simp.DischargeResult → Sort u_1) →
(x : Except Lean.Exception Lean.Meta.Simp.DischargeResult) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.proved)) →
(Unit → motive (Except.ok Lean.Meta.Simp.DischargeResult.notProved)) →
(Unit → motive (Except.... | null | false |
ModularForm.E₆ | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | ModularForm (Matrix.SpecialLinearGroup.mapGL ℝ).range 6 | The normalised level 1 Eisenstein series of weight 6. | true |
BitVec.slt_trichotomy | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), x.slt y = true ∨ x = y ∨ y.slt x = true | For all bitvectors `x, y`, either `x` is signed less than `y`,
or is equal to `y`, or is signed greater than `y`. | true |
Set.union_diff_self | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ∪ t \ s = s ∪ t | **Alias** of `Set.union_sdiff_self`. | true |
Algebra.HasSeparableResidueFieldsAt.mk._flat_ctor | Mathlib.RingTheory.LocalRing.ResidueField.Separable | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {p : Ideal A}
[inst_3 : p.IsPrime],
(∀ (q : Ideal B) [inst_4 : q.IsPrime] [inst_5 : q.LiesOver p], Algebra.IsSeparable p.ResidueField q.ResidueField) →
Algebra.HasSeparableResidueFieldsAt A B p | null | false |
Matrix.mul_transvection_apply_same | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {n : Type u_1} {R : Type u₂} [inst : DecidableEq n] [inst_1 : CommRing R] (i j : n) [inst_2 : Fintype n]
{m : Type u_4} (a : m) (c : R) (M : Matrix m n R), (M * Matrix.transvection i j c) a j = M a j + c * M a i | null | true |
SSet.Subcomplex.Pairing.hint._@.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing.1340996045._hygCtx._hyg.3 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} →
{A : X.Subcomplex} → A.Pairing → {Y : SSet} → {B : Y.Subcomplex} → (e : Y ≅ X) → A.preimage e.hom = B → Prop | A unification hint for the type (II) simplices of `Pairing.ofIso`. | false |
AddCommGroup.modEq_iff_eq_add_zsmul | Mathlib.Algebra.Group.ModEq | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, a ≡ b [PMOD p] ↔ ∃ z, b = a + z • p | null | true |
CommMonCat.fullyFaithfulForgetToMonCat.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | CommMonCat.fullyFaithfulForgetToMonCat =
{ preimage := fun {X Y} f => CommMonCat.ofHom (MonCat.Hom.hom f),
map_preimage := @CommMonCat.fullyFaithfulForgetToMonCat._proof_1,
preimage_map := @CommMonCat.fullyFaithfulForgetToMonCat._proof_2 } | null | true |
NonUnitalNonAssocSemiring.mem_center_iff | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (a : α),
a ∈ NonUnitalSubsemiring.center α ↔
AddMonoid.End.mulRight a = AddMonoid.End.mulLeft a ∧ AddMonoid.End.mulLeft a ∈ (CentroidHom.toEndRingHom α).rangeS | null | true |
equicontinuousWithinAt_empty._simp_1 | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [h : IsEmpty ι]
(F : ι → X → α) (S : Set X) (x₀ : X), EquicontinuousWithinAt F S x₀ = True | null | false |
Lean.Meta.Grind.AC.EqCnstr.casesOn | Lean.Meta.Tactic.Grind.AC.Types | {motive_1 : Lean.Meta.Grind.AC.EqCnstr → Sort u} →
(t : Lean.Meta.Grind.AC.EqCnstr) →
((lhs rhs : Lean.Grind.AC.Seq) →
(h : Lean.Meta.Grind.AC.EqCnstrProof) → (id : ℕ) → motive_1 { lhs := lhs, rhs := rhs, h := h, id := id }) →
motive_1 t | null | false |
IccRightChart._proof_1 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) [h : Fact (x < y)] (z : EuclideanHalfSpace 1), max (y - (↑z).ofLp 0) x ∈ Set.Icc x y | null | false |
Set.inl_compl_union_inr_compl | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Sum.inl '' sᶜ ∪ Sum.inr '' tᶜ = (Sum.inl '' s ∪ Sum.inr '' t)ᶜ | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity.0.ContinuousOn.cfc_fun._simp_1_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} {p : Filter ι} [inst : UniformSpace β] {𝔖 : Set (Set α)}
{F : ι → UniformOnFun α β 𝔖} {f : UniformOnFun α β 𝔖},
Filter.Tendsto F p (nhds f) = ∀ s ∈ 𝔖, TendstoUniformlyOn (⇑(UniformOnFun.toFun 𝔖) ∘ F) ((UniformOnFun.toFun 𝔖) f) p s | null | false |
LocallyConstant.mk | Mathlib.Topology.LocallyConstant.Basic | {X : Type u_5} →
{Y : Type u_6} → [inst : TopologicalSpace X] → (toFun : X → Y) → IsLocallyConstant toFun → LocallyConstant X Y | null | true |
PartialHomeomorph.mk | Mathlib.Topology.PartialHomeomorph.Defs | {X : Type u_5} →
{Y : Type u_6} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
(toPartialEquiv : PartialEquiv X Y) →
ContinuousOn (↑toPartialEquiv) toPartialEquiv.source →
ContinuousOn toPartialEquiv.invFun toPartialEquiv.target → PartialHomeomorph X Y | null | true |
CategoryTheory.Functor.instMonoidalActionMapAction | Mathlib.CategoryTheory.Action.Monoidal | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
{G : Type u_2} →
[inst_1 : Monoid G] →
{W : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_2, u_3} W] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalCategory W] →... | A monoidal functor induces a monoidal functor between
the categories of `G`-actions within those categories. | true |
Homeomorph.neg._proof_1 | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G],
Continuous (Equiv.neg G).toFun | null | false |
SimpleGraph.UnitDistEmbedding.noConfusion | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | {P : Sort u} →
{V : Type u_1} →
{G : SimpleGraph V} →
{E : Type u_3} →
{inst : MetricSpace E} →
{t : G.UnitDistEmbedding E} →
{V' : Type u_1} →
{G' : SimpleGraph V'} →
{E' : Type u_3} →
{inst' : MetricSpace E'} →
... | null | false |
IsOrderedModule.of_smul_one_mono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] [inst_3 : Preorder α]
[inst_4 : Preorder β] [inst_5 : MulOneClass β] [PosMulMono β] [MulPosMono β] [IsScalarTower α β β],
(Monotone fun x => x • 1) → IsOrderedModule α β | null | true |
alternatingGroup.isCoatom_stabilizer_of_ncard_lt_ncard_compl | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {s : Set α},
s.Nontrivial → s.ncard < sᶜ.ncard → IsCoatom (MulAction.stabilizer (↥(alternatingGroup α)) s) | Note : The proof of this statement is close to that
of `Equiv.Perm.isCoatom_stabilizer_of_ncard_lt_ncard_compl`,
and while it would not be absolutely impossible to abstract both proofs,
the result would be slightly awkward because the
details of the results involved in the proof differ in annoying details.
And it would... | true |
toAlgHom_comp_sectionOfRetractionKerToTensorAux | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] (l : TensorProduct P S Ω[P⁄R] →ₗ[P] ↥(RingHom.ker (algebraMap P S)))
(hl : l ∘ₗ KaehlerDifferential.kerToTensor R P S = LinearMap.id) (σ : S → P)
(hσ : ∀ (x ... | null | true |
_private.Mathlib.Data.Finset.Slice.0.Set.sized_iUnion._simp_1_2 | Mathlib.Data.Finset.Slice | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Bimod.comp | Mathlib.CategoryTheory.Monoidal.Bimod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{A B : CategoryTheory.Mon C} → {M N O : Bimod A B} → M.Hom N → N.Hom O → M.Hom O | Composition of bimodule object morphisms. | true |
Cardinal.SharplyLT.IsCardinalFilteredAndHasCardinalLT.isColimit | Mathlib.CategoryTheory.Presentable.SharplyLT.Basic | (κ₁ κ₂ : Cardinal.{w}) →
[inst : Fact κ₁.IsRegular] →
[Fact κ₂.IsRegular] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
{X : C} →
{J : Type w} →
[inst_3 : PartialOrder J] →
(p : (CategoryTheory.isCardinalPresentable C κ₁).ColimitOf... | Given a presentation `p` of `X : C` as a colimit indexed by a partially
ordered type `J` of `κ₁`-presentable objects, `X` is also the colimit
of all the colimits of the restrictions of the diagram `p.diag`
to the subsets `A` of `J` that are `κ₁`-directed and of cardinality `< κ₂`. | true |
List.head_append_right | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ l₂ : List α} (w : l₁ ++ l₂ ≠ []) (h : l₁ = []), (l₁ ++ l₂).head w = l₂.head ⋯ | null | true |
CategoryTheory.CommShift₂Setup._sizeOf_inst | Mathlib.CategoryTheory.Shift.CommShiftTwo | (D : Type u_5) →
{inst : CategoryTheory.Category.{v_5, u_5} D} →
(M : Type u_6) →
{inst_1 : AddCommMonoid M} →
{inst_2 : CategoryTheory.HasShift D M} → [SizeOf D] → [SizeOf M] → SizeOf (CategoryTheory.CommShift₂Setup D M) | null | false |
GrpCat.fullyFaithfulForget₂ToMonCat._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} (f : X ⟶ Y), GrpCat.ofHom (MonCat.Hom.hom ((CategoryTheory.forget₂ GrpCat MonCat).map f)) = f | null | false |
QuadraticMap.isOrtho_comm | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {Q : QuadraticMap R M N} {x y : M}, Q.IsOrtho x y ↔ Q.IsOrtho y x | null | true |
Subgroup.finite_quotient_of_finiteIndex | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [H.FiniteIndex], Finite (G ⧸ H) | null | true |
Matroid.IsCocircuit.delete_isCocircuit | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {K D : Set α}, M.IsCocircuit K → D ⊂ K → (M.delete D).IsCocircuit (K \ D) | null | true |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Iic_top._simp_1_1 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] {a x : α}, (x ∈ Finset.Iic a) = (x ≤ a) | null | false |
Lean.Meta.RefinedDiscrTree.Key.labelledStar.inj | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ∀ {id id_1 : ℕ},
Lean.Meta.RefinedDiscrTree.Key.labelledStar id = Lean.Meta.RefinedDiscrTree.Key.labelledStar id_1 → id = id_1 | null | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.match_syntax.expand.match_7 | Lean.Elab.Quotation | (motive : Option (Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → Sort u_1) →
(x : Option (Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term))) →
((tuples : Array (Lean.Syntax × Array (Lean.TSyntax `term) × Lean.TSyntax `term)) → motive (some tuples)) →
(Unit → mo... | null | false |
Nat.Prime.one_le | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Nat.Prime p → 1 ≤ p | null | true |
_private.Mathlib.Combinatorics.SetFamily.LYM.0.Finset.slice_union_shadow_falling_succ._simp_1_4 | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : DecidableEq α] {k : ℕ} {𝒜 : Finset (Finset α)} {s : Finset α},
(s ∈ Finset.falling k 𝒜) = ((∃ t ∈ 𝒜, s ⊆ t) ∧ s.card = k) | null | false |
Batteries.Tactic.DeclCache._sizeOf_1 | Batteries.Util.Cache | {α : Type} → [SizeOf α] → Batteries.Tactic.DeclCache α → ℕ | null | false |
Nat.cast_div_charZero._simp_1 | Mathlib.Data.Nat.Cast.Field | ∀ {K : Type u_1} [inst : DivisionSemiring K] {m n : ℕ} [CharZero K], n ∣ m → ↑m / ↑n = ↑(m / n) | null | false |
Decidable.not_and_iff_not_or_not | Init.PropLemmas | ∀ {a b : Prop} [Decidable a], ¬(a ∧ b) ↔ ¬a ∨ ¬b | null | true |
Manifold.delabMDifferentiable | Mathlib.Geometry.Manifold.Notation | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for `MDifferentiable` using the custom elaborator | true |
Module.End.hasEigenvalue_iff | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R}, f.HasEigenvalue μ ↔ f.eigenspace μ ≠ ⊥ | null | true |
List.eraseIdx_nil | Init.Data.List.Basic | ∀ {α : Type u} {i : ℕ}, [].eraseIdx i = [] | null | true |
CategoryTheory.IsPushout.of_map | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {W X Y Z : C} {f : W ⟶ X} {g : W ⟶ Y} {h : X ⟶ Z} {i : Y ⟶ Z}
[CategoryTheory.Limits.ReflectsColimit (CategoryTheory.Limits.span f g) F],
CategoryTheory.Category... | null | true |
SemiRingCat.semiringObj._aux_8 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J SemiRingCat) → (j : J) → NSMul ((F.comp (CategoryTheory.forget SemiRingCat)).obj j) | null | false |
Std.Time.DateTime.subNanoseconds | Std.Time.DateTime | Std.Time.DateTime → Std.Time.Nanosecond.Offset → Std.Time.DateTime | Subtract `Nanosecond.Offset` from a `DateTime`.
| true |
List.foldl.match_1.congr_eq_1 | Init.Data.List.MinMaxOn | ∀ {α : Type u_3} {β : Type u_1} (motive : α → List β → Sort u_2) (x : α) (x_1 : List β) (h_1 : (a : α) → motive a [])
(h_2 : (a : α) → (b : β) → (l : List β) → motive a (b :: l)) (a : α),
x = a →
x_1 = [] →
(match x, x_1 with
| a, [] => h_1 a
| a, b :: l => h_2 a b l) ≍
h_1 a | null | true |
AddEquiv.arrowCongr._proof_3 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_4} {N : Type u_1} {P : Type u_3} {Q : Type u_2} [inst : Add P] [inst_1 : Add Q] (f : M ≃ N) (g : P ≃+ Q)
(h k : M → P), (fun n => g ((h + k) (f.symm n))) = (fun n => g (h (f.symm n))) + fun n => g (k (f.symm n)) | null | false |
CategoryTheory.Limits.createsColimitsOfShapeOfCreatesCoequalizersAndCoproducts._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{D : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} D]
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) D]
(G : CategoryTheory.Functor C D)... | null | false |
NonUnitalSubsemiring.prod_mono_right | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(s : NonUnitalSubsemiring R), Monotone fun t => s.prod t | null | true |
StarAlgHom.realContinuousMapOfNNReal._proof_2 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | IsTopologicalSemiring ℝ | null | false |
profiniteToCompHaus | Mathlib.Topology.Category.Profinite.Basic | CategoryTheory.Functor Profinite CompHaus | The fully faithful embedding of `Profinite` in `CompHaus`. | true |
iterateInduction.eq_2 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ {X : ℕ → Type u_1} {a : ℕ} (x : (i : ↥(Finset.Iic a)) → X ↑i)
(ind : (n : ℕ) → ((i : ↥(Finset.Iic n)) → X ↑i) → X (n + 1)) (k : ℕ),
iterateInduction x ind k.succ = if h : k + 1 ≤ a then x ⟨k + 1, ⋯⟩ else ind k fun i => iterateInduction x ind ↑i | null | true |
Lean.PrettyPrinter.Delaborator.SubExpr.withBoundedAppFnArgs._sunfold | Lean.PrettyPrinter.Delaborator.SubExpr | {α : Type} →
{m : Type → Type} →
[Monad m] → [MonadReaderOf Lean.SubExpr m] → [MonadWithReaderOf Lean.SubExpr m] → ℕ → m α → (α → m α) → m α | null | false |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.instDecidableEqStained.decEq._proof_8 | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.Stained.wildcard✝ = Mathlib.Linter.Flexible.Stained.goal✝ → False | null | false |
_private.Batteries.Data.Array.Scan.0.Array.getElem?_scanl._proof_1_1 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {a : β} {l : Array α} {i : ℕ} {f : β → α → β},
i + 1 ≤ (Array.scanl f a l).size → i < (Array.scanl f a l).size | null | false |
_private.Mathlib.CategoryTheory.WithTerminal.Cone.0.CategoryTheory.WithInitial.id.match_1.eq_2 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_1} (motive : CategoryTheory.WithInitial C → Sort u_2)
(h_1 : (a : C) → motive (CategoryTheory.WithInitial.of a)) (h_2 : Unit → motive CategoryTheory.WithInitial.star),
(match CategoryTheory.WithInitial.star with
| CategoryTheory.WithInitial.of a => h_1 a
| CategoryTheory.WithInitial.star => h_... | null | true |
FunLike.addCancelMonoid | Mathlib.Algebra.Group.FunLike | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : Add F] →
[inst_2 : Zero F] →
[inst_3 : SMul ℕ F] →
[inst_4 : AddCancelMonoid β] →
[IsZeroApply F α β] → [IsAddApply F α β] → [IsSMulApply ℕ F α β] → AddCancelMono... | A `FunLike` type that satisfies `(f + g) x = f x + g x`, `0 x = 0`, and
`(n • f) x = n • f x` is a cancel additive monoid if `β` is a cancel additive monoid. | true |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkListLitAux._sunfold | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → List Lean.Expr → Lean.Expr | null | false |
_private.Mathlib.RingTheory.ZariskisMainTheorem.0.Algebra.ZariskisMainProperty.of_adjoin_eq_top._simp_1_9 | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_2} [inst : Ring R] (f : Polynomial R), f.eraseLead = f - (Polynomial.monomial f.natDegree) f.leadingCoeff | null | false |
CochainComplex.mappingCone.rotateHomotopyEquiv_comm₂_assoc | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L)
{Z : HomotopyCategory C (ComplexShape.up ℤ)}
(h :
(HomotopyCategory.quotient C (ComplexShape.up ℤ)).obj
(... | null | true |
_private.Mathlib.NumberTheory.ModularForms.Cusps.0.Subgroup.two_mul_widthInfty_mem_strictPeriods._simp_1_2 | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {A : Type u_1} {M : Type u_3} [inst : AddMonoid A] [inst_1 : Monoid M] (ψ : AddChar A M) (n : ℕ) (x : A),
ψ x ^ n = ψ (n • x) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.