name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
GradedAlgHom.toGradedRingHom_ofClass | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_6} {B : Type u_7} {ι : Type u_10} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grad... | null | true |
CategoryTheory.Limits.Trident.IsLimit.homIso._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C)
(x :
{ h // ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp h (f j₁) = CategoryTheory.CategoryStr... | null | false |
TopologicalSpace.Opens.instCompleteLattice._proof_4 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a b : TopologicalSpace.Opens α), { carrier := ↑a ∩ ↑b, is_open' := ⋯ } ≤ a | null | false |
CategoryTheory.colimitYonedaHomEquiv._proof_5 | Mathlib.CategoryTheory.Limits.Indization.LocallySmall | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} C] {I : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} I] [CategoryTheory.Limits.HasLimitsOfShape Iᵒᵖ (Type u_4)]
(F : CategoryTheory.Functor I C) (G : CategoryTheory.Functor Cᵒᵖ (Type u_4)),
CategoryTheory.Limits.HasLimit ((F.op.comp G).comp Cat... | null | false |
Valuation.RankLeOne.rankOne_of_nontrivial._proof_1 | Mathlib.RingTheory.Valuation.RankOne | ∀ {Γ₀ : Type u_2} [inst : LinearOrderedCommGroupWithZero Γ₀] {K : Type u_1} [inst_1 : DivisionRing K]
(v : Valuation K Γ₀), Nontrivial (MonoidWithZeroHom.ofClass v).ValueGroup₀ˣ → ∃ x, v x ≠ 0 ∧ v x ≠ 1 | null | false |
BitVec.toFin_setWidth | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ} {x : BitVec w}, (BitVec.setWidth v x).toFin = Fin.ofNat (2 ^ v) x.toNat | null | true |
Std.DTreeMap.getKeyLED | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → α → α → α | Tries to retrieve the largest key that is less than or equal to the
given key, returning `fallback` if no such key exists.
| true |
Nat.bitwise_zero_right | Mathlib.Data.Nat.Bitwise | ∀ {f : Bool → Bool → Bool} (n : ℕ), Nat.bitwise f n 0 = if f true false = true then n else 0 | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.isCoatom_stabilizer_of_ncard_lt_ncard_compl._proof_1_1 | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} {s : Set α}, 1 < s.ncard → s.ncard < sᶜ.ncard → s.ncard + sᶜ.ncard = Nat.card α → 4 < Nat.card α | null | false |
Filter.EventuallyEq.iInter | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {ι : Sort x} {l : Filter α} [Finite ι] {s t : ι → Set α},
(∀ (i : ι), s i =ᶠ[l] t i) → ⋂ i, s i =ᶠ[l] ⋂ i, t i | null | true |
IntermediateField.restrictScalars_eq_top_iff._simp_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type u_3}
[inst_3 : Field K] [inst_4 : Algebra K E] [inst_5 : Algebra K F] [inst_6 : IsScalarTower K F E]
{L : IntermediateField F E}, (IntermediateField.restrictScalars K L = ⊤) = (L = ⊤) | null | false |
List.reduceOption_concat | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (l : List (Option α)) (x : Option α), (l.concat x).reduceOption = l.reduceOption ++ x.toList | null | true |
AddSubmonoid.toSubmonoid_closure | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {A : Type u_4} [inst : AddZeroClass A] (S : Set A),
AddSubmonoid.toSubmonoid (AddSubmonoid.closure S) = Submonoid.closure (⇑Multiplicative.toAdd ⁻¹' S) | null | true |
CategoryTheory.ObjectProperty.epiModSerre | Mathlib.CategoryTheory.Abelian.SerreClass.MorphismProperty | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
(P : CategoryTheory.ObjectProperty C) → [P.IsSerreClass] → CategoryTheory.MorphismProperty C | The class of epimorphisms modulo a Serre class: given a
Serre class `P : ObjectProperty C`, this is the class of morphisms `f`
such that `cokernel f` satisfies `P`. | true |
Hypergraph.rec | Mathlib.Combinatorics.Hypergraph.Basic | {α : Type u_4} →
{motive : Hypergraph α → Sort u} →
((vertexSet : Set α) →
(edgeSet : Set (Set α)) →
(subset_vertexSet_of_mem_edgeSet' : ∀ ⦃e : Set α⦄, e ∈ edgeSet → e ⊆ vertexSet) →
motive
{ vertexSet := vertexSet, edgeSet := edgeSet,
subset_vertexSet_o... | null | false |
Nat.Linear.Poly.denote_eq_cancelAux | Init.Data.Nat.Linear | ∀ (ctx : Nat.Linear.Context) (fuel : ℕ) (m₁ m₂ r₁ r₂ : Nat.Linear.Poly),
Nat.Linear.Poly.denote_eq ctx (List.reverse r₁ ++ m₁, List.reverse r₂ ++ m₂) →
Nat.Linear.Poly.denote_eq ctx (Nat.Linear.Poly.cancelAux fuel m₁ m₂ r₁ r₂) | null | true |
Lean.Syntax.node8 | Init.Prelude | Lean.SourceInfo →
Lean.SyntaxNodeKind →
Lean.Syntax →
Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax | Create syntax node with 8 children | true |
CategoryTheory.Functor.isColimitOfIsWellOrderContinuous' | Mathlib.CategoryTheory.Limits.Shapes.Preorder.WellOrderContinuous | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : PartialOrder J] →
(F : CategoryTheory.Functor J C) →
[F.IsWellOrderContinuous] →
{α : Type u_1} →
[inst_3 : PartialOrder α] →
(f : α <i J) → Order.IsSuccLimit f.top... | If `F : J ⥤ C` is well-order-continuous and `h : α <i J` is a principal
segment such that `h.top` is a limit element, then
`F.obj h.top` identifies to the colimit of the `F.obj j` for `j : α`. | true |
PolynomialModule.comp_eval | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Polynomial R)
(q : PolynomialModule R M) (r : R),
(PolynomialModule.eval r) ((PolynomialModule.comp p) q) = (PolynomialModule.eval (Polynomial.eval r p)) q | null | true |
ExteriorAlgebra.liftAlternatingEquiv._proof_2 | Mathlib.LinearAlgebra.ExteriorAlgebra.OfAlternating | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] (x y : (i : ℕ) → M [⋀^Fin i]→ₗ[R] N),
ExteriorAlgebra.liftAlternating (x + y) = ExteriorAlgebra.liftAlternating x + ExteriorAlgebra.liftAlternating y | null | false |
KaehlerDifferential.mvPolynomialBasis_repr_symm_single | Mathlib.RingTheory.Kaehler.Polynomial | ∀ (R : Type u) [inst : CommRing R] (σ : Type u_1) (i : σ) (x : MvPolynomial σ R),
((KaehlerDifferential.mvPolynomialBasis R σ).repr.symm fun₀ | i => x) =
x • (KaehlerDifferential.D R (MvPolynomial σ R)) (MvPolynomial.X i) | null | true |
Turing.TM2to1.trStAct | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
[DecidableEq K] →
{k : K} →
Turing.TM1.Stmt (Turing.TM2to1.Γ' K Γ) (Turing.TM2to1.Λ' K Γ Λ σ) σ →
Turing.TM2to1.StAct K Γ σ k → Turing.TM1.Stmt (Turing.TM2to1.Γ' K Γ) (Turing.TM2to1.Λ' K Γ Λ σ... | The program corresponding to state transitions at the end of a stack. Here we start out just
after the top of the stack, and should end just after the new top of the stack. | true |
CategoryTheory.GlueData.types_π_surjective | Mathlib.CategoryTheory.GlueData | ∀ (D : CategoryTheory.GlueData (Type u_1)), Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom D.π) | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic.0.SSet.Subcomplex.Pairing.anodyneExtensions._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : CategoryTheory.MorphismProperty C}
[Q.IsStableUnderCobaseChange], (P.pushouts ≤ Q) = (P ≤ Q) | null | false |
Mathlib.Tactic.BicategoryLike.Mor₁.id | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Lean.Expr → Mathlib.Tactic.BicategoryLike.Obj → Mathlib.Tactic.BicategoryLike.Mor₁ | `id e a` is the expression for `𝟙 a`, where `e` is the underlying lean expression. | true |
Cardinal.aleph0_le_mul_iff | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}}, Cardinal.aleph0 ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (Cardinal.aleph0 ≤ a ∨ Cardinal.aleph0 ≤ b) | See also `Cardinal.aleph0_le_mul_iff`. | true |
Lean.Grind.ToInt.Add.casesOn | Init.Grind.ToInt | {α : Type u} →
[inst : Add α] →
{I : Lean.Grind.IntInterval} →
[inst_1 : Lean.Grind.ToInt α I] →
{motive : Lean.Grind.ToInt.Add α I → Sort u_1} →
(t : Lean.Grind.ToInt.Add α I) →
((toInt_add : ∀ (x y : α), ↑(x + y) = I.wrap (↑x + ↑y)) → motive ⋯) → motive t | null | false |
AlgebraicGeometry.Scheme.Pullback.Triplet.tensor._proof_1 | Mathlib.AlgebraicGeometry.PullbackCarrier | ∀ {X Y S : AlgebraicGeometry.Scheme} {f : X ⟶ S} {g : Y ⟶ S} (T : AlgebraicGeometry.Scheme.Pullback.Triplet f g),
CategoryTheory.Limits.HasPushout
(CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.residueFieldCongr ⋯).inv
(AlgebraicGeometry.Scheme.Hom.residueFieldMap f T.x))
(CategoryTheory.... | null | false |
_private.Std.Data.TreeMap.Lemmas.0.Std.TreeMap.Equiv.symm.match_1_1 | Std.Data.TreeMap.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} (motive : t₁.Equiv t₂ → Prop)
(x : t₁.Equiv t₂), (∀ (h : t₁.inner.Equiv t₂.inner), motive ⋯) → motive x | null | false |
Subgroup.IsSubnormal.trans | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {H K : Subgroup G},
H ≤ K → (H.subgroupOf K).IsSubnormal → K.IsSubnormal → H.IsSubnormal | If `H` is a subnormal subgroup of `K` and `K` is a subnormal subgroup of `G`,
then `H` is a subnormal subgroup of `G`.
| true |
CategoryTheory.IsGrothendieckAbelian.tensorObj | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.GabrielPopescu | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] →
(G : C) → CategoryTheory.Functor (ModuleCat (CategoryTheory.End G)ᵐᵒᵖ) C | The left adjoint of the functor `Hom(G, ·)`, which can be thought of as `· ⊗ G`. | true |
AddSubmonoid.multiples_fg | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} [inst : AddMonoid M] (r : M), (AddSubmonoid.multiples r).FG | null | true |
Lean.Lsp.LeanClientCapabilities.incrementalDiagnosticSupport?._default | Lean.Data.Lsp.Capabilities | Option Bool | null | false |
Lean.Meta.Grind.ParentSet.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.ParentSet → Sort u} →
(t : Lean.Meta.Grind.ParentSet) → ((parents : List Lean.Expr) → motive { parents := parents }) → motive t | null | false |
WithTop.untopD_add | Mathlib.Algebra.Order.WithTop.Untop0 | ∀ {α : Type u_1} [inst : Add α] {a b : WithTop α} {c : α},
a ≠ ⊤ → b ≠ ⊤ → WithTop.untopD c (a + b) = WithTop.untopD c a + WithTop.untopD c b | null | true |
_private.Lean.Meta.Tactic.Grind.EqResolution.0.Lean.Meta.Grind.topsortMVars?.visit | Lean.Meta.Tactic.Grind.EqResolution | Array Lean.Expr → Lean.Expr → Lean.Meta.Grind.TopSortM Unit | null | true |
_private.Mathlib.Analysis.Calculus.LocalExtr.Rolle.0.exists_hasDerivAt_eq_zero.match_1_1 | Mathlib.Analysis.Calculus.LocalExtr.Rolle | ∀ {f : ℝ → ℝ} {a b : ℝ} (motive : (∃ c ∈ Set.Ioo a b, IsLocalExtr f c) → Prop) (x : ∃ c ∈ Set.Ioo a b, IsLocalExtr f c),
(∀ (c : ℝ) (cmem : c ∈ Set.Ioo a b) (hc : IsLocalExtr f c), motive ⋯) → motive x | null | false |
Mathlib.Tactic.GCongr.GCongrKey._sizeOf_1 | Mathlib.Tactic.GCongr.Core | Mathlib.Tactic.GCongr.GCongrKey → ℕ | null | false |
tensorIteratedFDerivTwo | Mathlib.Analysis.InnerProductSpace.Laplacian | (𝕜 : 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] → (E → F) → E → TensorProduct 𝕜 E E →ₗ[𝕜] F | Convenience reformulation of the second iterated derivative, as a map from `E` to linear maps
`E ⊗[𝕜] E →ₗ[𝕜] F`.
| true |
String.containsSubstr | Batteries.Data.String.Matcher | String → Substring.Raw → Bool | Returns true iff `pattern` occurs as a substring of `s`.
| true |
CategoryTheory.Limits.BinaryBiproductData.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} →
(bicone : CategoryTheory.Limits.BinaryBicone P Q) →
bicone.IsBilimit → CategoryTheory.Limits.BinaryBiproductData P Q | null | false |
Lean.Grind.Ring.OfSemiring.add | Init.Grind.Ring.Envelope | {α : Type u} →
[inst : Lean.Grind.Semiring α] →
Lean.Grind.Ring.OfSemiring.Q α → Lean.Grind.Ring.OfSemiring.Q α → Lean.Grind.Ring.OfSemiring.Q α | null | true |
posPart_pos_iff._simp_1 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : AddGroup α] {a : α}, (0 < a⁺) = (0 < a) | null | false |
Lean.Meta.instReduceEvalName | Lean.Meta.ReduceEval | Lean.Meta.ReduceEval Lean.Name | null | true |
Nat.modulus_mul_add_modEq_iff | Mathlib.Data.Nat.ModEq | ∀ {n a b c : ℕ}, n * b + a ≡ c [MOD n] ↔ a ≡ c [MOD n] | null | true |
Lean.Level.PP.Context.mk.sizeOf_spec | Lean.Level | ∀ (mvars : Bool) (lIndex? : Lean.LMVarId → Option ℕ), sizeOf { mvars := mvars, lIndex? := lIndex? } = 1 + sizeOf mvars | null | true |
Lean.Core.checkInterrupted | Lean.CoreM | Lean.CoreM Unit | Throws an internal interrupt exception if cancellation has been requested. The exception is not
caught by `try catch` but is intended to be caught by `Command.withLoggingExceptions` at the top
level of elaboration. In particular, we want to skip producing further incremental snapshots after
the exception has been throw... | true |
retractionOfSectionOfKerSqZero._proof_2 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : Algebra R P], SMulCommClass R P P | null | false |
AddValuation.map_le_sum | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
{ι : Type u_6} {s : Finset ι} {f : ι → R} {g : Γ₀}, (∀ i ∈ s, g ≤ v (f i)) → g ≤ v (∑ i ∈ s, f i) | null | true |
Flag._sizeOf_inst | Mathlib.Order.Preorder.Chain | (α : Type u_4) → {inst : LE α} → [SizeOf α] → SizeOf (Flag α) | null | false |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.ev_app | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
[inst_4 : CategoryTheory.MonoidalClosed V] →
... | Given `ℌ : DayConvolutionInternalHom F H`, if we think of `H.obj G`
as the internal hom `[F, G]`, then this is the transformation
corresponding to the component at `G` of the "evaluation" natural morphism
`F ⊛ [F, _] ⟶ 𝟭`. | true |
ContinuousMonoidHom.continuous_comp_left | Mathlib.Topology.Algebra.Group.CompactOpen | ∀ {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : Monoid A] [inst_1 : Monoid B] [inst_2 : Monoid C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] (f : A →ₜ* B),
Continuous fun g => g.comp f | null | true |
Filter.subsingleton_bot | Mathlib.Order.Filter.Subsingleton | ∀ {α : Type u_1}, ⊥.Subsingleton | null | true |
CategoryTheory.PrelaxFunctor.map₂_inv_hom_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.PrelaxFunctor B C) {a b : B} {f g : a ⟶ b} (η : f ≅ g) {Z : F.obj a ⟶ F.obj b} (h : F.map g ⟶ Z),
CategoryTheory.CategoryStruct.comp (F.map₂ η.inv) (CategoryTheory.CategoryStruct.comp (F.map... | null | true |
finprod_mem_image | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : CommMonoid M] {f : α → M} {s : Set β} {g : β → α},
Set.InjOn g s → ∏ᶠ (i : α) (_ : i ∈ g '' s), f i = ∏ᶠ (j : β) (_ : j ∈ s), f (g j) | The product of `f y` over `y ∈ g '' s` equals the product of `f (g i)` over `s` provided that
`g` is injective on `s`. | true |
LowerSet.coe_bot | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], ↑⊥ = ∅ | null | true |
RingCat.Colimits.quot_zero | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat),
Quot.mk (⇑(RingCat.Colimits.colimitSetoid F)) RingCat.Colimits.Prequotient.zero = 0 | null | true |
_private.Mathlib.Combinatorics.Matroid.Rank.ENat.0.Matroid.eRk_le_one_iff.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} {M : Matroid α} {X : Set α} (motive : (∃ e ∈ M.E, X ⊆ M.closure {e}) → Prop)
(x : ∃ e ∈ M.E, X ⊆ M.closure {e}), (∀ (e : α) (left : e ∈ M.E) (he : X ⊆ M.closure {e}), motive ⋯) → motive x | null | false |
AddMonoidAlgebra.tensorEquiv._proof_3 | Mathlib.RingTheory.TensorProduct.MonoidAlgebra | ∀ (R : Type u_4) {M : Type u_2} (A : Type u_3) (B : Type u_1) [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : CommSemiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddCommMonoid M] (p : A)
(n : AddMonoidAlgebra B M),
Commute
(((IsScalarTower.toAlgHom A (TensorProduct R A B) (AddM... | null | false |
CategoryTheory.Limits.biproduct.isLimitFromSubtype._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (f : J → C) (i : J)
[inst_2 : CategoryTheory.Limits.HasBiproduct f]
[inst_3 : CategoryTheory.Limits.HasBiproduct (Subtype.restrict (fun j => j ≠ i) f)]
(s : CategoryTheory.Limits.For... | null | false |
List.sublists_append | Mathlib.Data.List.Sublists | ∀ {α : Type u} (l₁ l₂ : List α),
(l₁ ++ l₂).sublists = do
let x ← l₂.sublists
List.map (fun x_1 => x_1 ++ x) l₁.sublists | null | true |
BitVec.divSubtractShift.match_1 | Init.Data.BitVec.Bitblast | {w : ℕ} →
(motive : BitVec.DivModArgs w → Sort u_1) →
(args : BitVec.DivModArgs w) → ((n d : BitVec w) → motive { n := n, d := d }) → motive args | null | false |
_private.Init.Data.List.Perm.0.List.foldl.match_1.splitter | Init.Data.List.Perm | {α : Type u_3} →
{β : Type u_1} →
(motive : α → List β → Sort u_2) →
(x : α) →
(x_1 : List β) → ((a : α) → motive a []) → ((a : α) → (b : β) → (l : List β) → motive a (b :: l)) → motive x x_1 | null | true |
_private.Mathlib.Combinatorics.SetFamily.Shatter.0.Finset.Shatters.nonempty.match_1_1 | Mathlib.Combinatorics.SetFamily.Shatter | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} (motive : (∃ u ∈ 𝒜, s ∩ u = s) → Prop)
(x : ∃ u ∈ 𝒜, s ∩ u = s), (∀ (t : Finset α) (ht : t ∈ 𝒜) (right : s ∩ t = s), motive ⋯) → motive x | null | false |
_private.Mathlib.Data.Real.ConjExponents.0.ENNReal.coe_conjExponent._simp_1_5 | Mathlib.Data.Real.ConjExponents | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
CategoryTheory.Functor.HomObj.id_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F : CategoryTheory.Functor C D} (A : CategoryTheory.Functor C (Type w)) (X : C) (x : A.obj X),
(CategoryTheory.Functor.HomObj.id A).app X x = CategoryTheory.CategoryStruct.id (F.obj X) | null | true |
_private.Mathlib.Algebra.Homology.TotalComplexShift.0.HomologicalComplex₂.totalShift₁XIso._proof_3 | Mathlib.Algebra.Homology.TotalComplexShift | ∀ (x n n' : ℤ), n + x = n' → ∀ (p q : ℤ), p + q = n' → p - x + q = n | null | false |
Int.add_mul_modulus_modEq_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a + b * n ≡ c [ZMOD n] ↔ a ≡ c [ZMOD n] | null | true |
Lean.MonadLog.recOn | Lean.Log | {m : Type → Type} →
{motive : Lean.MonadLog m → Sort u} →
(t : Lean.MonadLog m) →
([toMonadFileMap : Lean.MonadFileMap m] →
(getRef : m Lean.Syntax) →
(getFileName : m String) →
(hasErrors : m Bool) →
(logMessage : Lean.Message → m Unit) →
... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema.0.Polynomial.Chebyshev.abs_eval_T_real_eq_one_iff._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.isUniformInducing_ofLp_aux | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [inst : Fact (1 ≤ p)] [inst_1 : (i : ι) → PseudoEMetricSpace (β i)]
[inst_2 : Fintype ι], IsUniformInducing WithLp.ofLp | null | true |
Matrix.blockDiagonal'_injective | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [inst : Zero α] [inst_1 : DecidableEq o],
Function.Injective Matrix.blockDiagonal' | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.FiveWheelLike.0.SimpleGraph.IsFiveWheelLike.minDegree_le_of_cliqueFree_fiveWheelLikeFree_succ._proof_1_11 | Mathlib.Combinatorics.SimpleGraph.FiveWheelLike | ∀ {α : Type u_1} {G : SimpleGraph α} {r k : ℕ} {v w₁ w₂ : α} {s t : Finset α} [inst : DecidableEq α],
G.IsFiveWheelLike r k v w₁ w₂ s t →
({v} ∪ ({w₁} ∪ ({w₂} ∪ (s ∪ t)))).card + k = 2 * r + 3 →
¬k = 0 →
3 ≤ ({v} ∪ ({w₁} ∪ ({w₂} ∪ (s ∪ t)))).card →
({v} ∪ ({w₁} ∪ ({w₂} ∪ (s ∪ t)))).card - ... | null | false |
CategoryTheory.Bicategory.rec | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
{motive : CategoryTheory.Bicategory B → Sort u_1} →
([toCategoryStruct : CategoryTheory.CategoryStruct.{v, u} B] →
(homCategory : (a b : B) → CategoryTheory.Category.{w, v} (a ⟶ b)) →
(whiskerLeft :
{a b c : B} →
(f : a ⟶ b) →
{g h :... | null | false |
ContinuousLinearMap.norm_iteratedFDerivWithin_comp_left | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type uG}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (L : F →L[𝕜] G) {f : E → F} {s : Set E}... | null | true |
Std.DTreeMap.Internal.Impl.balanceₘ._proof_5 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (l : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.leaf.size > Std.DTreeMap.Internal.delta * l.size → False | null | false |
Std.DTreeMap.Internal.Unit.RioSliceData.casesOn | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
[inst : Ord α] →
{motive : Std.DTreeMap.Internal.Unit.RioSliceData α → Sort u_1} →
(t : Std.DTreeMap.Internal.Unit.RioSliceData α) →
((treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit) →
(range : Std.Rio α) → motive { treeMap := treeMap, range := range }) →
m... | null | false |
ArchimedeanClass.instFieldFiniteResidueField._proof_58 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
Nontrivial (ArchimedeanClass.FiniteResidueField K) | null | false |
Repr.addAppParen | Init.Data.Repr | Std.Format → ℕ → Std.Format | Adds parentheses to `f` if the precedence `prec` from the context is at least that of function
application.
Together with `reprArg`, this can be used to correctly parenthesize function application
syntax.
| true |
Set.PartiallyWellOrderedOn.subsetProdLex | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] {s : Set (Lex (α × β))},
((fun x => (ofLex x).1) '' s).IsPWO → (∀ (a : α), {y | toLex (a, y) ∈ s}.IsPWO) → s.IsPWO | null | true |
Lean.Elab.Tactic.Do.ProofMode.FocusResult.mk | Lean.Elab.Tactic.Do.ProofMode.Focus | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Elab.Tactic.Do.ProofMode.FocusResult | null | true |
Rep.coinvariantsTensorIndNatIso_inv_app | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u} [inst : CommRing k] {G H : Type u} [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{u, u, u} k G) (X : Rep.{u, u, u} k H),
(Rep.coinvariantsTensorIndNatIso φ A).inv.app X = Rep.coinvariantsTensorIndInv φ A X | null | true |
ProbabilityTheory.IsRatCondKernelCDFAux.integrable | Mathlib.Probability.Kernel.Disintegration.CDFToKernel | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α × β → ℚ → ℝ}
{κ : ProbabilityTheory.Kernel α (β × ℝ)} {ν : ProbabilityTheory.Kernel α β},
ProbabilityTheory.IsRatCondKernelCDFAux f κ ν →
∀ (a : α) (q : ℚ), MeasureTheory.Integrable (fun c => f (a, c) q) (ν a) | null | true |
CategoryTheory.Limits.monoCoprodOfHasZeroMorphisms | Mathlib.CategoryTheory.Limits.MonoCoprod | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.Limits.HasZeroMorphisms C],
CategoryTheory.Limits.MonoCoprod C | null | true |
HomologicalComplex.pOpcyclesIso | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{ι : Type u_2} →
{c : ComplexShape ι} →
(K : HomologicalComplex C c) →
(i j : ι) → c.prev j = i → K.d i j = 0 → [inst_2 : K.HasHomology j] → K.X j ≅ K.opcycles... | The canonical isomorphism `K.X j ≅ K.opCycles j` when the differential to `j` is zero. | true |
NonUnitalStarSubalgebra.toStarSubalgebra._proof_1 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : StarRing A]
[inst_3 : Algebra R A] (S : NonUnitalStarSubalgebra R A) {a b : A}, a ∈ S.carrier → b ∈ S.carrier → a * b ∈ S.carrier | null | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.hausdorffDist_zero_iff_closure_eq_closure._simp_1_3 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ (x : ENNReal), (x.toReal = 0) = (x = 0 ∨ x = ⊤) | null | false |
List.sum_toFinset | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_5} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] (f : ι → M) {l : List ι},
l.Nodup → l.toFinset.sum f = (List.map f l).sum | null | true |
decidable_of_decidable_of_eq | Init.Core | {p q : Prop} → [Decidable p] → p = q → Decidable q | Transfer a decidability proof across an equality of propositions. | true |
Complex.sinh_zero | Mathlib.Analysis.Complex.Trigonometric | Complex.sinh 0 = 0 | null | true |
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local.inj | Lean.Elab.Tactic.Do.Attr | ∀ {fvarId fvarId_1 : Lean.FVarId},
Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local fvarId = Lean.Elab.Tactic.Do.SpecAttr.SpecProof.local fvarId_1 →
fvarId = fvarId_1 | null | true |
YoungDiagram.exists_notMem_col | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (μ : YoungDiagram) (j : ℕ), ∃ i, (i, j) ∉ μ.cells | null | true |
WithSeminorms.withSeminorms_eq | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕜 : Type u_2} {E : Type u_6} {ι : Type u_9} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
{p : SeminormFamily 𝕜 E ι} [t : TopologicalSpace E], WithSeminorms p → t = p.moduleFilterBasis.topology | null | true |
ModuleCat.instModuleCarrierMkOfSMul'._proof_2 | Mathlib.Algebra.Category.ModuleCat.Basic | ∀ {R : Type u_2} [inst : Ring R] {A : AddCommGrpCat} (φ : R →+* CategoryTheory.End A) (b : ↑(ModuleCat.mkOfSMul' φ)),
1 • b = b | null | false |
Int.gcd_eq_zero_iff | Init.Data.Int.Gcd | ∀ {a b : ℤ}, a.gcd b = 0 ↔ a = 0 ∧ b = 0 | null | true |
CategoryTheory.Limits.coneUnopOfCoconeEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} J] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_3, u_1} C] {F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ}
{X Y Z : (CategoryTheory.Limits.Cocone F)ᵒᵖ} (f : Y ⟶ X) (g : Z ⟶ Y),
{ hom := (CategoryTheory.CategoryStruct.comp g f).unop.hom.unop, w := ⋯ } =
C... | null | false |
IO.Promise.isResolved | Init.System.Promise | {α : Type} → IO.Promise α → BaseIO Bool | Checks whether the promise has already been resolved, i.e. whether access to `result*` will return
immediately.
| true |
GradedAlgHom.coe_ofClass | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_6} {B : Type u_7} {ι : Type u_10} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grad... | null | true |
Std.CancellationToken.Consumer.normal.injEq | Std.Sync.CancellationToken | ∀ (promise promise_1 : IO.Promise Unit),
(Std.CancellationToken.Consumer.normal promise = Std.CancellationToken.Consumer.normal promise_1) =
(promise = promise_1) | null | true |
Std.ExtTreeSet.isSome_max?_of_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
t.contains k = true → t.max?.isSome = true | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.