name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
OrderType.inductionOn₂ | Mathlib.Order.Types.Defs | ∀ {C : OrderType.{u_1} → OrderType.{u_2} → Prop} (o₁ : OrderType.{u_1}) (o₂ : OrderType.{u_2}),
(∀ (α : Type u_1) [inst : LinearOrder α] (β : Type u_2) [inst_1 : LinearOrder β],
C (OrderType.type α) (OrderType.type β)) →
C o₁ o₂ | `Quotient.inductionOn₂` specialized to `OrderType`. | true |
_private.Mathlib.RingTheory.Localization.Algebra.0.IsLocalization.ker_map._simp_1_2 | Mathlib.RingTheory.Localization.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (s : ↥M),
(IsLocalization.mk' S x s = 0) = ∃ m, ↑m * x = 0 | null | false |
Submonoid.LocalizationMap.map | Mathlib.GroupTheory.MonoidLocalization.Maps | {M : Type u_1} →
[inst : CommMonoid M] →
{S : Submonoid M} →
{N : Type u_2} →
[inst_1 : CommMonoid N] →
{P : Type u_3} →
[inst_2 : CommMonoid P] →
S.LocalizationMap N →
{g : M →* P} →
{T : Submonoid P} →
(∀ (y ... | Given a `CommMonoid` homomorphism `g : M →* P` where for Submonoids `S ⊆ M, T ⊆ P` we have
`g(S) ⊆ T`, the induced Monoid homomorphism from the Localization of `M` at `S` to the
Localization of `P` at `T`: if `f : M →* N` and `k : P →* Q` are Localization maps for `S` and
`T` respectively, we send `z : N` to `k (g x) *... | true |
Submodule.finrank_quotient | Mathlib.LinearAlgebra.Dimension.RankNullity | ∀ {R : Type u_2} {M : Type u} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[HasRankNullity.{u, u_2} R] [StrongRankCondition R] [Module.Finite R M] {S : Type u_1} [inst_6 : Ring S]
[inst_7 : SMul R S] [inst_8 : Module S M] [inst_9 : IsScalarTower R S M] (N : Submodule S M),
Module.finrank R (M ⧸... | Rank-nullity theorem using `finrank` and subtraction. | true |
BitVec.toNat_mul_toNat_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x.toNat * y.toNat < 2 ^ (w * 2) | null | true |
Lean.Meta.Grind.Arith.Linear.Case.fvarId | Lean.Meta.Tactic.Grind.Arith.Linear.SearchM | Lean.Meta.Grind.Arith.Linear.Case → Lean.FVarId | Decision variable used to represent the case-split.
For example, suppose we are splitting on `p ≠ 0`. Then,
we create a decision variable `h : p < 0`
| true |
Ideal.stabilizerEquiv_symm_apply_smul | Mathlib.RingTheory.Ideal.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {N : Type u_3}
[inst_3 : Group N] [inst_4 : MulSemiringAction N R] (I : Ideal R) (e : M ≃* N)
(he : ∀ (m : M) (x : R), e m • x = m • x) (n : ↥(MulAction.stabilizer N I)) (x : R),
(I.stabilizerEquiv e he).symm n... | null | true |
CochainComplex.mappingCone.rotateHomotopyEquiv._proof_7 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K L : CochainComplex C ℤ} (φ : K ⟶ L),
CochainComplex.HomComplex.Cochain.ofHom
(CategoryTheory.CategoryStruct.comp
(CochainComplex.mappingCone.... | null | false |
Lean.Elab.Term.ElabElim.Context | Lean.Elab.App | Type | Context of the `elab_as_elim` elaboration procedure. | true |
Lean.Elab.Term.Do.ToTerm.reassignToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.MacroM Lean.Syntax | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unsafe_rec | Std.Sat.AIG.CNF | (aig : Std.Sat.AIG ℕ) →
(upper : ℕ) →
(h : upper < aig.decls.size) →
(state : Std.Sat.AIG.toCNF.State✝ aig) → { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state out upper h } | null | false |
CategoryTheory.Functor.instCommShift₂IntCochainComplexIntMap₂CochainComplex._proof_4 | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.Preadditive C₁] [inst_4 : CategoryTheory.Preadditive C₂]
[inst_5 : CategoryTheory.Preadditive D]... | null | false |
_private.Mathlib.Algebra.GroupWithZero.Range.0.MonoidWithZeroHom.valueGroup_eq_range._simp_1_4 | Mathlib.Algebra.GroupWithZero.Range | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
AlgebraicGeometry.IsAffineOpen.isoSpec_hom | Mathlib.AlgebraicGeometry.AffineScheme | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (hU : AlgebraicGeometry.IsAffineOpen U), hU.isoSpec.hom = U.toSpecΓ | null | true |
CategoryTheory.Comma.mapLeftIso | 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] →
(R : CategoryTheory.Functor B T) →
{L₁ L₂ : CategoryTheory.Functor A T} → ... | A natural isomorphism `L₁ ≅ L₂` induces an equivalence of categories
`Comma L₁ R ≌ Comma L₂ R`. | true |
_private.Init.Data.Nat.Control.0.Nat.forM.loop | Init.Data.Nat.Control | {m : Type → Type u_1} → [Monad m] → (n : ℕ) → ((i : ℕ) → i < n → m Unit) → (i : ℕ) → i ≤ n → m Unit | null | true |
_private.Mathlib.CategoryTheory.ConnectedComponents.0.CategoryTheory.instIsConnectedComponent._proof_10 | Mathlib.CategoryTheory.ConnectedComponents | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (j₁ j₂ : J)
(hj₁ : CategoryTheory.ConnectedComponents.objectProperty (Quotient.mk'' j₂) j₁) (l : List J)
(hf : ∀ a ∈ l, CategoryTheory.Zigzag a j₂),
¬(j₁ :: l).length - 1 = 0 →
({ obj := j₁, property := ⋯ } :: List.pmap (fun x h => { obj := x, pro... | null | false |
TopModuleCat.instIsRightAdjointTopCatForget₂ContinuousLinearMapIdCarrierContinuousMapCarrier | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ (R : Type u) [inst : Ring R] [inst_1 : TopologicalSpace R],
(CategoryTheory.forget₂ (TopModuleCat R) TopCat).IsRightAdjoint | null | true |
SheafOfModules.GeneratingSections.map | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | {C : Type u'} →
[inst : CategoryTheory.Category.{v', u'} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
[inst_3 : J.HasShe... | Let `F` be a functor from sheaf of `R`-module to sheaf of `S`-module, if `F` preserves
colimits and `F.obj (unit R) ≅ unit S`, given generating sections `G : M.GeneratingSections`,
then we obtain generating sections of `F.obj M`. | true |
Complex.UnitDisc | Mathlib.Analysis.Complex.UnitDisc.Basic | Type | The complex unit disc, denoted as `𝔻` within the Complex namespace | true |
Subgroup.instInfSet | Mathlib.Algebra.Group.Subgroup.Lattice | {G : Type u_1} → [inst : Group G] → InfSet (Subgroup G) | null | true |
CochainComplex.HomComplex.Cochain.rightShift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | IsRightCancelAdd ℤ | null | false |
CategoryTheory.Mon.limit_mon_mul | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] (F : CategoryTheory.Functor J (CategoryTheory.Mon C))
(c : CategoryTheory.Limits.Cone (F.comp (CategoryTheory.Mon.forget C))) (hc : CategoryTheory.Limits.I... | null | true |
Lean.Meta.Grind.TopSort.State.recOn | Lean.Meta.Tactic.Grind.EqResolution | {motive : Lean.Meta.Grind.TopSort.State → Sort u} →
(t : Lean.Meta.Grind.TopSort.State) →
((tempMark permMark : Std.HashSet Lean.Expr) →
(result : Array Lean.Expr) → motive { tempMark := tempMark, permMark := permMark, result := result }) →
motive t | null | false |
Finset.compls_subset_compls._simp_1 | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] {s₁ s₂ : Finset α}, (s₁.compls ⊆ s₂.compls) = (s₁ ⊆ s₂) | null | false |
cfc_const._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
Std.Packages.LinearPreorderOfLEArgs.rec | Init.Data.Order.PackageFactories | {α : Type u} →
{motive : Std.Packages.LinearPreorderOfLEArgs α → Sort u_1} →
((toPreorderOfLEArgs : Std.Packages.PreorderOfLEArgs α) →
(ord :
let this := toPreorderOfLEArgs.le;
let this := toPreorderOfLEArgs.decidableLE;
Ord α) →
(le_total : ∀ (a b : α), a ≤ b... | null | false |
Set.EqOn.comp_eq | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_7} {f : ι → α} {g₁ g₂ : α → β},
Set.EqOn g₁ g₂ (Set.range f) → g₁ ∘ f = g₂ ∘ f | **Alias** of the forward direction of `Set.eqOn_range`. | true |
MeasureTheory.Measure.instMeasurableAdd₂ | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_3} {m : MeasurableSpace α}, MeasurableAdd₂ (MeasureTheory.Measure α) | null | true |
ENNReal.mul_div_cancel_right | Mathlib.Data.ENNReal.Inv | ∀ {a b : ENNReal}, b ≠ 0 → b ≠ ⊤ → a * b / b = a | See `ENNReal.mul_div_cancel_right'` for a stronger version. | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.getEntryD.eq_def | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (a : α) (fallback : (a : α) × β a)
(x : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.getEntryD a fallback x =
match x with
| Std.DHashMap.Internal.AssocList.nil => fallback
| Std.DHashMap.Internal.AssocList.cons k v es =>
if (... | null | true |
Lean.Lsp.DidSaveTextDocumentParams.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.DidSaveTextDocumentParams → Sort u} →
((textDocument : Lean.Lsp.TextDocumentIdentifier) →
(text? : Option String) → motive { textDocument := textDocument, text? := text? }) →
(t : Lean.Lsp.DidSaveTextDocumentParams) → motive t | null | false |
Set.swap_mem_addAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMagma α] {s t : Set α} {a : α} {x : α × α},
x.swap ∈ s.addAntidiagonal t a ↔ x ∈ t.addAntidiagonal s a | null | true |
CategoryTheory.Lax.LaxTrans.homCategory._proof_4 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {X Y : F ⟶ G} (f : CategoryTheory.Lax.LaxTrans.Hom X Y),
{ as := f.as.vcomp { as := CategoryTheory.Lax.LaxTrans.Modification.id Y }.as } = f | null | false |
Polynomial.coeff_comp_degree_mul_degree | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
q.natDegree ≠ 0 → (p.comp q).coeff (p.natDegree * q.natDegree) = p.leadingCoeff * q.leadingCoeff ^ p.natDegree | null | true |
WeierstrassCurve.valuation_Δ_aux.eq_1 | 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),
WeierstrassCurve.valuation_Δ_aux R W =
if h : WeierstrassCurve.IsIntegral R W then
⟨(IsDedekindDo... | null | true |
NonUnitalCommCStarAlgebra.rec | Mathlib.Analysis.CStarAlgebra.Classes | {A : Type u_1} →
{motive : NonUnitalCommCStarAlgebra A → Sort u} →
([toNonUnitalNormedCommRing : NonUnitalNormedCommRing A] →
[toStarRing : StarRing A] →
[toCompleteSpace : CompleteSpace A] →
[toCStarRing : CStarRing A] →
[toNormedSpace : NormedSpace ℂ A] →
... | null | false |
dimH_empty | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {X : Type u_2} [inst : EMetricSpace X], dimH ∅ = 0 | null | true |
AlgHom.liftOfSurjective._proof_4 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B), (RingHom.ker f).IsTwoSided | null | false |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_right._simp_1_2 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) | null | false |
AlgebraicGeometry.Scheme.Modules.restrictStalkNatIso | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X Y : AlgebraicGeometry.Scheme} →
(f : X ⟶ Y) →
[inst : AlgebraicGeometry.IsOpenImmersion f] →
(x : ↥X) →
(AlgebraicGeometry.Scheme.Modules.restrictFunctor f).comp
((AlgebraicGeometry.Scheme.Modules.toPresheaf X).comp (TopCat.Presheaf.stalkFunctor Ab x)) ≅
(AlgebraicGeometry.S... | Restriction along open immersions commutes with taking stalks. | true |
Lagrange.nodal_insert_eq_nodal | Mathlib.LinearAlgebra.Lagrange | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} {s : Finset ι} {v : ι → R} [inst_1 : DecidableEq ι] {i : ι},
i ∉ s → Lagrange.nodal (insert i s) v = (Polynomial.X - Polynomial.C (v i)) * Lagrange.nodal s v | null | true |
HDiv.hDiv | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → [self : HDiv α β γ] → α → β → γ | `a / b` computes the result of dividing `a` by `b`.
The meaning of this notation is type-dependent.
* For most types like `Nat`, `Int`, `Rat`, `Real`, `a / 0` is defined to be `0`.
* For `Nat`, `a / b` rounds downwards.
* For `Int`, `a / b` rounds downwards if `b` is positive or upwards if `b` is negative.
It is impl... | true |
Valuation.toMonoidWithZeroHom | Mathlib.RingTheory.Valuation.Basic | {R : Type u_3} →
{Γ₀ : Type u_4} → [inst : LinearOrderedCommMonoidWithZero Γ₀] → [inst_1 : Ring R] → Valuation R Γ₀ → R →*₀ Γ₀ | null | true |
Std.DHashMap.get_modify_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k : α}
{f : β k → β k} {h : k ∈ m.modify k f}, (m.modify k f).get k h = f (m.get k ⋯) | null | true |
AddAction.nonempty_orbit | Mathlib.GroupTheory.GroupAction.Defs | ∀ {M : Type u_1} {α : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M α] (a : α), (AddAction.orbit M a).Nonempty | null | true |
Topology.closure_of | Mathlib.Topology.Defs.Basic | Lean.ParserDescr | Notation for `closure` with respect to a non-standard topology. | true |
Lean.Meta.simpEq.match_6 | Mathlib.Lean.Meta.Simp | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((u : Lean.Level) → (α lhs rhs : Lean.Expr) → motive ((((Lean.Expr.const `Eq [u]).app α).app lhs).app rhs)) →
((x : Lean.Expr) → motive x) → motive type | null | false |
BitVec.shiftLeftZeroExtend._proof_1 | Init.Data.BitVec.Basic | ∀ {w x : ℕ}, x < 2 ^ w → ∀ (m : ℕ), x <<< m < 2 ^ (w + m) | null | false |
Lean.Meta.Grind.EMatch.SearchState._sizeOf_inst | Lean.Meta.Tactic.Grind.EMatch | SizeOf Lean.Meta.Grind.EMatch.SearchState | null | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.guessReorder.visit._sparseCasesOn_11 | Mathlib.Tactic.Translate.Reorder | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.MorphismProperty.multiplicativeClosure'.below.id | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure' x → Prop} (x : C),
CategoryTheory.MorphismProperty.multiplicativeClosure'.below ⋯ | null | true |
LocallyConstant.instCommMonoid | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [CommMonoid Y] → CommMonoid (LocallyConstant X Y) | null | true |
conjneg_inj | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f g : G → R},
conjneg f = conjneg g ↔ f = g | null | true |
GenContFract.IntFractPair.stream_zero | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.stream v 0 = some (GenContFract.IntFractPair.of v) | null | true |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuse_1 | Mathlib.Tactic.DefEqAbuse | Lean.Elab.Tactic.Tactic | > **WARNING:** `#defeq_abuse` is an experimental tool intended to assist with breaking
changes to transparency handling. Its syntax may change at any time, and it may not behave as
expected. Please report unexpected behavior [on Zulip](https://leanprover.zulipchat.com/#narrow/channel/113488-general/topic/backward.2EisD... | false |
CategoryTheory.Functor.essImage.liftFunctor._proof_1 | Mathlib.CategoryTheory.EssentialImage | ∀ {J : Type u_6} {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
(G : CategoryTheory.Functor J D) (F : CategoryTheory.Functor C D) [inst_3 : F.Full] [F.Faithful]
(hG : ∀ (j : J), F.essImage ... | null | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.Modifiers.isNoncomputable._sparseCasesOn_1 | Lean.Elab.DeclModifiers | {motive : Lean.Elab.ComputeKind → Sort u} →
(t : Lean.Elab.ComputeKind) →
motive Lean.Elab.ComputeKind.noncomputable → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
CommRingCat.commRingObj._aux_1 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J CommRingCat) → (j : J) → Add ((F.comp (CategoryTheory.forget CommRingCat)).obj j) | null | false |
AddMonoidAlgebra.uniqueAlgEquiv | Mathlib.Algebra.MonoidAlgebra.Basic | (R : Type u_1) →
{A : Type u_4} →
(M : Type u_7) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] → [inst_3 : AddMonoid M] → [Unique M] → AddMonoidAlgebra A M ≃ₐ[R] A | The trivial monoid algebra is the base ring. | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_85 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
MeasureTheory.Measure.addHaarMeasure.eq_1 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] (K₀ : TopologicalSpace.PositiveCompacts G),
MeasureTheory.Measure.addHaarMeasure K₀ =
((MeasureTheory.Measure.haar.addHaarContent K₀).measure ↑K₀)⁻¹ •
... | null | true |
CategoryTheory.Functor.HomObj.naturality_assoc | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} {A : CategoryTheory.Functor C (Type w)} (self : F.HomObj G A) {c d : C} (f : c ⟶ d)
(a : A.obj c) {Z : D} (h : G.obj d ⟶ Z),
CategoryTheory.CategoryStruct.comp (F... | null | true |
Lean.Meta.getElimExprInfo | Lean.Meta.Tactic.ElimInfo | Lean.Expr → optParam (Option Lean.Name) none → Lean.MetaM Lean.Meta.ElimInfo | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_3 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (Category... | null | false |
RBTree.RBSet.AlterWF.recOn | BatteriesRecycling.RBTree.Basic | {α : Type u_1} →
{cmp : α → α → Ordering} →
{t : RBTree.RBSet α cmp} →
{cut : α → Ordering} →
{f : Option α → Option α} →
{motive : t.AlterWF cut f → Sort u} →
(t_1 : t.AlterWF cut f) →
((wf : RBTree.RBNode.WF cmp (RBTree.RBNode.alter cut f ↑t)) → motive ⋯) → moti... | null | false |
TestFunction.instAddCommGroup._proof_8 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {n : ℕ∞},
autoParam
(∀ (n_1 : ℕ) (a : TestFunction Ω F n),
{ toFun := ↑n_1.succ • ⇑a, contDiff' := ⋯, hasCompactSupport' := ⋯, ... | null | false |
Homeomorph.preimageImageRestrict._proof_2 | Mathlib.Topology.IsClosedRestrict | ∀ {ι : Type u_1} (α : ι → Type u_2) (S : Set ι) (s : Set ((j : ι) → α j)) (p : ↑(Sᶜ.restrict '' s) × ((i : ↑S) → α ↑i)),
(fun x => (⟨Sᶜ.restrict ↑x, ⋯⟩, fun i => ↑x ↑i)) ((fun p => ⟨Topology.reorderRestrictProd S s p, ⋯⟩) p) = p | null | false |
_private.Std.Async.UDP.0.Std.Async.UDP.Socket.ofNative._flat_ctor | Std.Async.UDP | Std.Internal.UV.UDP.Socket → Std.Async.UDP.Socket | null | false |
_private.Mathlib.Analysis.BoxIntegral.Box.Basic.0.BoxIntegral.Box.disjoint_withBotCoe._simp_1_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b ≤ ⊥) | null | false |
TopologicalSpace.IrreducibleCloseds.mk.injEq | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_4} [inst : TopologicalSpace α] (carrier : Set α) (isIrreducible' : IsIrreducible carrier)
(isClosed' : IsClosed carrier) (carrier_1 : Set α) (isIrreducible'_1 : IsIrreducible carrier_1)
(isClosed'_1 : IsClosed carrier_1),
({ carrier := carrier, isIrreducible' := isIrreducible', isClosed' := isClosed... | null | true |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_counitIso_hom_app_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
(X :
CategoryTheory.Comma (CategoryTheory.Functor.const SimplexCategory)
(CategoryTheory.Functor.id (CategoryTheory.Functor SimplexCategory C))),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.counitIso.hom.app X).left =
Catego... | null | true |
TopologicalSpace.IsTopologicalBasis.nhds_hasBasis | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α] {b : Set (Set α)},
TopologicalSpace.IsTopologicalBasis b → ∀ {a : α}, (nhds a).HasBasis (fun t => t ∈ b ∧ a ∈ t) fun t => t | null | true |
Lean.Meta.Sym.Arith.CommRing.mk.inj | Lean.Meta.Sym.Arith.Types | ∀ {toRing : Lean.Meta.Sym.Arith.Ring} {invFn? : Option Lean.Expr} {semiringId? : Option ℕ}
{commSemiringInst commRingInst : Lean.Expr} {noZeroDivInst? fieldInst? : Option Lean.Expr}
{toRing_1 : Lean.Meta.Sym.Arith.Ring} {invFn?_1 : Option Lean.Expr} {semiringId?_1 : Option ℕ}
{commSemiringInst_1 commRingInst_1 : ... | null | true |
UV.shadow_compression_subset_compression_shadow | Mathlib.Combinatorics.SetFamily.Compression.UV | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} (u v : Finset α),
(∀ x ∈ u, ∃ y ∈ v, UV.IsCompressed (u.erase x) (v.erase y) 𝒜) →
(UV.compression u v 𝒜).shadow ⊆ UV.compression u v 𝒜.shadow | UV-compression reduces the size of the shadow of `𝒜` if, for all `x ∈ u` there is `y ∈ v` such
that `𝒜` is `(u.erase x, v.erase y)`-compressed. This is the key fact about compression for
Kruskal-Katona. | true |
Int.divisorsAntidiag_neg_natCast._proof_1 | Mathlib.NumberTheory.Divisors | ∀ (n : ℕ),
Disjoint
(Finset.map (Nat.castEmbedding.prodMap (Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))))
n.divisorsAntidiagonal)
(Finset.map ((Nat.castEmbedding.trans (Equiv.toEmbedding (Equiv.neg ℤ))).prodMap Nat.castEmbedding)
n.divisorsAntidiagonal) | null | false |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instPosMulStrictMono._simp_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : LT α] (a : α), (⊥ < ↑a) = True | null | false |
CategoryTheory.leftDistributor_ext_left | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {X Y : C} {f : J → C}
{g h : CategoryTheo... | null | true |
Submodule.submoduleOf_sup_of_le | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N₁ N₂ N : Submodule R M}, N₁ ≤ N → N₂ ≤ N → (N₁ ⊔ N₂).submoduleOf N = N₁.submoduleOf N ⊔ N₂.submoduleOf N | null | true |
Lean.MetavarContext.incDepth | Lean.MetavarContext | Lean.MetavarContext → optParam Bool false → Lean.MetavarContext | null | true |
AddMonoidHom.compHom'_apply_apply | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type uM} {N : Type uN} {P : Type uP} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] [inst_2 : AddCommMonoid P]
(f : M →+ N) (y : N →+ P) (x : M), (f.compHom' y) x = y (f x) | null | true |
Matrix.circulant_col_zero_eq | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ {α : Type u_1} {n : Type u_3} [inst : SubtractionMonoid n] (v : n → α) (i : n), Matrix.circulant v i 0 = v i | null | true |
_private.Lean.Environment.0.Lean.ImportedModule.rec | Lean.Environment | {motive : Lean.ImportedModule✝ → Sort u} →
((toEffectiveImport : Lean.EffectiveImport) →
(parts : Array (Lean.ModuleData × Lean.CompactedRegion)) →
(irData? : Option (Lean.ModuleData × Lean.CompactedRegion)) →
(needsIRTrans : Bool) →
motive
{ toEffectiveImport := toEf... | null | false |
CategoryTheory.toSkeleton | Mathlib.CategoryTheory.Skeletal | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → C → CategoryTheory.Skeleton C | The class of an object in the skeleton. | true |
LinearEquiv.toEquiv | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
{S : Type u_6} →
{M : Type u_7} →
{M₂ : Type u_9} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
{modM : Module R M} →
{modM₂ : Module S M₂} →
... | The equivalence of types underlying a linear equivalence. | true |
Homotopy.mkInductiveAux₂._proof_4 | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : ChainComplex V ℕ} (e : P ⟶ Q) (zero : P.X 0 ⟶ Q.X 1) (one : P.X 1 ⟶ Q.X 2)
(comm_one :
e.f 1 = CategoryTheory.CategoryStruct.comp (P.d 1 0) zero + CategoryTheory.CategoryStruct.comp one (Q.d 2 1))
(su... | null | false |
Ideal.radical_le_jacobson | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u} [inst : CommRing R] {I : Ideal R}, I.radical ≤ I.jacobson | null | true |
CategoryTheory.Grothendieck.fiber_eqToHom | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (h : X = Y), (CategoryTheory.eqToHom h).fiber = CategoryTheory.eqToHom ⋯ | null | true |
Lean.DataValue.ofString.injEq | Lean.Data.KVMap | ∀ (v v_1 : String), (Lean.DataValue.ofString v = Lean.DataValue.ofString v_1) = (v = v_1) | null | true |
Lean.Elab.Term.PostponeBehavior.partial.sizeOf_spec | Lean.Elab.SyntheticMVars | sizeOf Lean.Elab.Term.PostponeBehavior.partial = 1 | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter.0.CategoryTheory.SimplicialObject.δ_δ₀Iter._proof_1_2 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ (i : ℕ) {m : ℕ} (j : Fin (m + 2)), ↑j ≤ i → ↑j ≤ i | null | false |
_private.Batteries.Data.List.Perm.0.List.Perm.idxBij_leftInverse_idxBij_symm._proof_1_15 | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs ys : List α} (h : xs.Perm ys) (w : Fin ys.length),
List.countBefore xs[⋯.idxBij w] xs ↑(⋯.idxBij w) + 1 ≤ (List.filter (fun x => x == xs[⋯.idxBij w]) ys).length →
List.countBefore xs[⋯.idxBij w] xs ↑(⋯.idxBij w) < (List.findIdxs (fun x => x == xs[⋯.idxBij... | null | false |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.comap_dist_right_atTop._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
AddCommGrpCat.instCreatesColimitsOfSizeUliftFunctor | Mathlib.Algebra.Category.Grp.Ulift | CategoryTheory.CreatesColimitsOfSize.{w, u, u, max u v, u + 1, max (u + 1) (v + 1)} AddCommGrpCat.uliftFunctor | The functor `uliftFunctor : AddCommGrpCat.{u} ⥤ AddCommGrpCat.{max u v}` creates `u`-small colimits.
| true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.guessUnivReorder.match_9 | Mathlib.Tactic.Translate.Reorder | (motive : { l // 2 ≤ l.length } → Sort u_1) →
(x : { l // 2 ≤ l.length }) → ((cycle : List ℕ) → (property : 2 ≤ cycle.length) → motive ⟨cycle, property⟩) → motive x | null | false |
FloorRing.ofFloor._proof_1 | Mathlib.Algebra.Order.Floor.Defs | ∀ (α : Type u_1) [inst : Ring α] [inst_1 : LinearOrder α] [IsOrderedRing α] (floor : α → ℤ),
GaloisConnection Int.cast floor → ∀ (a : α) (z : ℤ), (fun a => -floor (-a)) a ≤ z ↔ a ≤ ↑z | null | false |
Stream'.get_even | Mathlib.Data.Stream.Init | ∀ {α : Type u} (n : ℕ) (s : Stream' α), s.even.get n = s.get (2 * n) | null | true |
Units.coe_smul | Mathlib.Algebra.Group.Action.Units | ∀ {M : Type u_6} {N : Type u_7} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : MulDistribMulAction M N] (m : M)
(u : Nˣ), ↑(m • u) = m • ↑u | null | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.processAssignmentFOApproxAux | Lean.Meta.ExprDefEq | Lean.Expr → Array Lean.Expr → Lean.Expr → Lean.MetaM Bool | null | true |
List.bagInter.match_1.congr_eq_3 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (x x_1 : List α) (h_1 : (x : List α) → motive [] x)
(h_2 : (x : List α) → motive x []) (h_3 : (a : α) → (l₁ l₂ : List α) → motive (a :: l₁) l₂) (a : α) (l₁ l₂ : List α),
x = a :: l₁ →
x_1 = l₂ →
(l₂ = [] → False) →
(match x, x_1 with
... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.