name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TruncatedWittVector.out.eq_1 | Mathlib.RingTheory.WittVector.Truncated | ∀ {p n : ℕ} {R : Type u_1} [inst : CommRing R] (x : TruncatedWittVector p n R),
x.out = { coeff := fun i => if h : i < n then TruncatedWittVector.coeff ⟨i, h⟩ x else 0 } | null | true |
PeriodPair.derivWeierstrassP_neg | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair) (z : ℂ), L.derivWeierstrassP (-z) = -L.derivWeierstrassP z | null | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.noConfusionType | Lean.Meta.IndPredBelow | Sort u → Lean.Meta.IndPredBelow.NewDecl✝ → Lean.Meta.IndPredBelow.NewDecl✝ → Sort u | null | false |
MonomialOrder.degree_pow_of_pow_leadingCoeff_ne_zero | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f : MvPolynomial σ R} {n : ℕ},
m.leadingCoeff f ^ n ≠ 0 → m.degree (f ^ n) = n • m.degree f | Monomial degree of powers | true |
FractionalIdeal.coe_spanSingleton | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R) {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
[inst_3 : IsLocalization S P] (x : P), ↑((FractionalIdeal.spanSingleton S) x) = R ∙ x | null | true |
Ideal.span_singleton_mul_right_inj | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : CommSemiring R] {I J : Ideal R} [IsDomain R] {x : R},
x ≠ 0 → (Ideal.span {x} * I = Ideal.span {x} * J ↔ I = J) | null | true |
_private.Mathlib.Analysis.Analytic.ConvergenceRadius.0.FormalMultilinearSeries.isLittleO_of_lt_radius._simp_1_7 | Mathlib.Analysis.Analytic.ConvergenceRadius | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Std.DTreeMap.Internal.Impl.size_inter_le_size_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF), m₂.WF → (m₁.inter m₂ ⋯).size ≤ m₁.size | null | true |
CategoryTheory.Bicategory.LeftLift.ofIdComp_hom | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(t :
CategoryTheory.Bicategory.LeftLift f (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id c) g)),
t.ofIdComp.hom = CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.leftUnitor g).inv t.unit | null | true |
AlgebraicTopology.AlternatingCofaceMapComplex.obj.eq_1 | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.CosimplicialObject C),
AlgebraicTopology.AlternatingCofaceMapComplex.obj X =
CochainComplex.of (fun n => X.obj { len := n }) (AlgebraicTopology.AlternatingCofaceMapComplex.objD X) ⋯ | null | true |
Lean.Elab.DocElabInfo | Lean.Elab.InfoTree.Types | Type | Indicates that an extensible document elaborator was used. This info is applied to the name on a
role, directive, code block, or command, and is used to generate the hover.
A `TermInfo` would not give the correct hover for a few reasons:
1. The name used to invoke a document extension is not necessarily the name of t... | true |
lipschitzGroup.coe_mem_iff_mem | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} {x : (CliffordAlgebra Q)ˣ},
↑x ∈ Submonoid.map (Units.coeHom (CliffordAlgebra Q)) (lipschitzGroup Q).toSubmonoid ↔ x ∈ lipschitzGroup Q | null | true |
mul_sub_right_distrib | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), (a - b) * c = a * c - b * c | null | true |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.QuickResult.decidable.elim | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | {motive : Lean.Meta.Grind.QuickResult✝ → Sort u} →
(t : Lean.Meta.Grind.QuickResult✝) →
Lean.Meta.Grind.QuickResult.ctorIdx✝ t = 2 → motive Lean.Meta.Grind.QuickResult.decidable✝ → motive t | null | false |
cyclotomicCharacter.toFun_spec | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | ∀ {L : Type u} [inst : CommRing L] [inst_1 : IsDomain L] (p : ℕ) [inst_2 : Fact (Nat.Prime p)]
[∀ (i : ℕ), HasEnoughRootsOfUnity L (p ^ i)] (g : L ≃+* L) {n : ℕ} (t : ↥(rootsOfUnity (p ^ n) L)),
g ↑↑t = ↑↑t ^ ((PadicInt.toZModPow n) (cyclotomicCharacter.toFun p g)).val | null | true |
Polynomial.isUnit_aeval_of_isUnit_aeval_of_isNilpotent_sub | Mathlib.RingTheory.Polynomial.Nilpotent | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Polynomial R}
{a b : S}, IsUnit ((Polynomial.aeval b) P) → IsNilpotent (a - b) → IsUnit ((Polynomial.aeval a) P) | null | true |
CategoryTheory.CommGrp | Mathlib.CategoryTheory.Monoidal.CommGrp_ | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] → [CategoryTheory.BraidedCategory C] → Type (max u₁ v₁) | A commutative group object internal to a Cartesian monoidal category. | true |
isLindelof_iff_countable_subcover | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X},
IsLindelof s ↔
∀ {ι : Type u} (U : ι → Set X), (∀ (i : ι), IsOpen (U i)) → s ⊆ ⋃ i, U i → ∃ t, t.Countable ∧ s ⊆ ⋃ i ∈ t, U i | A set `s` is Lindelöf if and only if
for every open cover of `s`, there exists a countable subcover. | true |
Std.DHashMap.Internal.Raw₀.getEntryₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] → (m : Std.DHashMap.Internal.Raw₀ α β) → (a : α) → m.containsₘ a = true → (a : α) × β a | Internal implementation detail of the hash map | true |
AddCon.addMonoid | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : AddMonoid M] → (c : AddCon M) → AddMonoid c.Quotient | The quotient of an `AddMonoid` by an additive congruence relation is
an `AddMonoid`. | true |
RootPairing.ker_polarization_eq_ker_rootForm | 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) [inst_5 : Fintype ι],
P.Polarization.ker = LinearMap.ker P.RootForm | null | true |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_9 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z)
(pb :
(i : Function.Pullback f.f g.f) →
CategoryTheory.Limits.PullbackCone (CategoryTheory.CategoryStruct.comp (f.φ (↑i).1) (CategoryTheory.eqToHom ⋯))
(g.φ (↑i)... | null | false |
Lean.Meta.DSimp.Config.zetaHave | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool | When `false` (default: `true`), then disables zeta reduction of `have` expressions.
If `zeta` is `false`, then this option has no effect.
Unused `have`s are still removed if `zeta` or `zetaUnused` are true.
| true |
Std.Tactic.BVDecide.Return.mk | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred | {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
(result : aig.ExtendingEntrypoint) → Std.Tactic.BVDecide.BVExpr.Cache (↑result).aig → Std.Tactic.BVDecide.Return aig | null | true |
UInt64._sizeOf_1._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.284 | Mathlib.Util.CompileInductive | UInt64 → ℕ | null | false |
ComplexShape.instTotalComplexShape._proof_3 | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I : Type u_1} [inst : AddMonoid I] (c : ComplexShape I) [inst_1 : c.TensorSigns] {i₁ i₁' i₂ : I},
c.Rel i₁ i₁' →
(match (i₁, i₂) with
| (p, snd) => c.ε p) *
1 =
-1 *
match (i₁', i₂) with
| (p, snd) => c.ε p | null | false |
Int.gcd_mul_right_right | Init.Data.Int.Gcd | ∀ (a b : ℤ), a.gcd (a * b) = a.natAbs | null | true |
Monotone.functor | Mathlib.CategoryTheory.Category.Preorder | {X : Type u} →
{Y : Type v} → [inst : Preorder X] → [inst_1 : Preorder Y] → {f : X → Y} → Monotone f → CategoryTheory.Functor X Y | A monotone function between preorders induces a functor between the associated categories. | true |
Lean.Environment.unlockAsync | Lean.Environment | Lean.Environment → Lean.Environment | Forgets about the asynchronous context restrictions. Used only for `withoutModifyingEnv`. | true |
SemidirectProduct.instGroup._proof_16 | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N} (a : N ⋊[φ] G), a⁻¹ * a = 1 | null | false |
Nat.isLE_compare | Init.Data.Nat.Compare | ∀ {a b : ℕ}, (compare a b).isLE = true ↔ a ≤ b | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.DropWhile.0.Std.Iter.step_intermediateDropWhile.match_3.eq_2 | Std.Data.Iterators.Lemmas.Combinators.DropWhile | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {it : Std.Iter β} (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(h : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.Iter β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩)
(h_2... | null | true |
Subalgebra.rank_top | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {F : Type u_2} {E : Type u_3} [inst : CommSemiring F] [inst_1 : Semiring E] [inst_2 : Algebra F E],
Module.rank F ↥⊤ = Module.rank F E | null | true |
Lean.Grind.Linarith.Poly.denote_combine | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] (ctx : Lean.Grind.Linarith.Context α)
(p₁ p₂ : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.Poly.denote ctx (p₁.combine p₂) =
Lean.Grind.Linarith.Poly.denote ctx p₁ + Lean.Grind.Linarith.Poly.denote ctx p₂ | null | true |
_private.Mathlib.RingTheory.LocalProperties.InjectiveDimension.0.ModuleCat.injectiveDimension_le_injectiveDimension_of_isLocalizedModule._simp_1_4 | Mathlib.RingTheory.LocalProperties.InjectiveDimension | ∀ {R : Type u} [inst : Ring R] {M : ModuleCat R}, CategoryTheory.Limits.IsZero M = Subsingleton ↑M | null | false |
_private.Init.Data.Order.Ord.0.Std.instTransCmpCompareLex._simp_1 | Init.Data.Order.Ord | ∀ {o₁ o₂ : Ordering}, ((o₁.then o₂).isLE = true) = (o₁.isLE = true ∧ (o₁ = Ordering.lt ∨ o₂.isLE = true)) | null | false |
SupConvergenceClass.casesOn | Mathlib.Topology.Order.MonotoneConvergence | {α : Type u_3} →
[inst : Preorder α] →
[inst_1 : TopologicalSpace α] →
{motive : SupConvergenceClass α → Sort u} →
(t : SupConvergenceClass α) →
((tendsto_coe_atTop_isLUB :
∀ (a : α) (s : Set α), IsLUB s a → Filter.Tendsto Subtype.val Filter.atTop (nhds a)) →
... | null | false |
LeftCancelSemigroup.casesOn | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} →
{motive : LeftCancelSemigroup G → Sort u} →
(t : LeftCancelSemigroup G) →
([toSemigroup : Semigroup G] →
[toIsLeftCancelMul : IsLeftCancelMul G] →
motive { toSemigroup := toSemigroup, toIsLeftCancelMul := toIsLeftCancelMul }) →
motive t | null | false |
MeasureTheory.lpMeas._proof_5 | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} (F : Type u_2) [inst : NormedAddCommGroup F] (m : MeasurableSpace α) [inst_1 : MeasurableSpace α]
(p : ENNReal) (μ : MeasureTheory.Measure α), ∃ g, MeasureTheory.StronglyMeasurable g ∧ ↑↑0 =ᵐ[μ] g | null | false |
IsSelfAdjoint.norm_eq_max_norm_posPart_negPart._auto_1 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Isometric | Lean.Syntax | null | false |
CategoryTheory.Retract.ofIso | Mathlib.CategoryTheory.Retract | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (X ≅ Y) → CategoryTheory.Retract X Y | If `e : X ≅ Y`, then `X` is a retract of `Y`. | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftRightConst.go._unary._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (distance curr : ℕ)
(hcurr : curr ≤ w) (s : aig.RefVec curr) (hidx : curr < w),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.casesOn hcurr fun hcurr s => w - curr)
⟨curr + 1, ⟨⋯, s.... | null | false |
NumberField.RingOfIntegers.restrict.eq_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K] {M : Type u_3} (f : M → K) (h : ∀ (x : M), IsIntegral ℤ (f x)) (x : M),
NumberField.RingOfIntegers.restrict f h x = ⟨f x, ⋯⟩ | null | true |
BddDistLat.Hom.rec | Mathlib.Order.Category.BddDistLat | {X Y : BddDistLat} →
{motive : X.Hom Y → Sort u_1} →
((hom' : BoundedLatticeHom ↑X.toDistLat ↑Y.toDistLat) → motive { hom' := hom' }) → (t : X.Hom Y) → motive t | null | false |
_private.Lean.Meta.Tactic.Cleanup.0.Lean.Meta.cleanupCore.addUsedFVars.match_1 | Lean.Meta.Tactic.Cleanup | (motive : Unit × Lean.CollectFVars.State → Sort u_1) →
(x : Unit × Lean.CollectFVars.State) → ((fst : Unit) → (s : Lean.CollectFVars.State) → motive (fst, s)) → motive x | null | false |
Finset.exists_not_mem_of_card_lt_enatCard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Finset α}, ↑s.card < ENat.card α → ∃ a, a ∉ s | **Alias** of `Finset.exists_notMem_of_card_lt_enatCard`. | true |
mem_nullAddSubgroup_iff | Mathlib.Analysis.Normed.Group.NullSubmodule | ∀ {M : Type u_1} [inst : SeminormedAddCommGroup M] {x : M}, x ∈ nullAddSubgroup M ↔ ‖x‖ = 0 | null | true |
LinearMap.isStrictMap_iff_isEmbedding_liftQ_ker | Mathlib.Topology.Maps.Strict.Module | ∀ {R : Type u_1} {S : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S}
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module S N] {f : M →ₛₗ[σ] N}
[inst_6 : TopologicalSpace M] [inst_7 : TopologicalSpace N],
Topology.IsStrictMap ⇑f ↔ Topo... | A linear map `f : M → N` is strict if and only if the induced map `M ⧸ f.ker → N` is an
embedding. | true |
addAddMonoidHom._proof_2 | Mathlib.Algebra.Group.Prod | ∀ {α : Type u_1} [inst : AddCommMonoid α] (x y : α × α), addAddHom.toFun (x + y) = addAddHom.toFun x + addAddHom.toFun y | null | false |
Module.isTorsionFree_nat_iff_hasUniqueDiv._simp_1 | Mathlib.Algebra.Module.Torsion.Free | ∀ {M : Type u_3} [inst : AddCommMonoid M], Module.IsTorsionFree ℕ M = HasUniqueDiv M | null | false |
CategoryTheory.Limits.image.ι_zero | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasZeroObject C] {X Y : C} [inst_3 : CategoryTheory.Limits.HasImage 0],
CategoryTheory.Limits.image.ι 0 = 0 | null | true |
isTop_ofDual_iff | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : LE α] {a : αᵒᵈ}, IsTop (OrderDual.ofDual a) ↔ IsBot a | null | true |
addOrderOf_smul_dvd | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {x : G} (n : ℕ), addOrderOf (n • x) ∣ addOrderOf x | null | true |
_private.Lean.Util.Diff.0.Lean.Diff.lcs.match_1 | Lean.Util.Diff | {α : Type} →
(left right : Subarray α) →
(motive : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right)) → Sort u_1) →
(best : Option (ℕ × α × Fin (Std.Slice.size left) × Fin (Std.Slice.size right))) →
(Unit → motive none) →
((count : ℕ) →
(snd : α × Fin (St... | null | false |
ContinuousAlternatingMap.mk.noConfusion | Mathlib.Topology.Algebra.Module.Alternating.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
{ι : Type u_4} →
{inst : Semiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : Module R M} →
{inst_3 : TopologicalSpace M} →
{inst_4 : AddCommMonoid N} →
{inst_5 : Module R N} →
... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_erase._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = false) = (a ≠ b) | null | false |
CoxeterMatrix.reindexGroupEquiv_apply_simple | Mathlib.GroupTheory.Coxeter.Basic | ∀ {B : Type u_1} {B' : Type u_2} (M : CoxeterMatrix B) (e : B ≃ B') (i : B'),
(M.reindexGroupEquiv e) ((CoxeterMatrix.reindex e M).simple i) = M.simple (e.symm i) | null | true |
Mathlib.Tactic.DepRewrite.visitInner | Mathlib.Tactic.DepRewrite | Lean.Expr → Option Lean.Expr → Mathlib.Tactic.DepRewrite.M Lean.Expr | See `visit`. | true |
Std.DTreeMap.Internal.Impl.getKey.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α) (size : ℕ) (k' : α) (v : β k')
(l r : Std.DTreeMap.Internal.Impl α β)
(hlk_2 : Std.DTreeMap.Internal.Impl.contains k (Std.DTreeMap.Internal.Impl.inner size k' v l r) = true),
(Std.DTreeMap.Internal.Impl.inner size k' v l r).getKey k hlk_2 =
match h : comp... | null | true |
Algebra.prod_embeddings_eq_finrank_pow | Mathlib.RingTheory.Norm.Basic | ∀ {K : Type u_4} {L : Type u_5} (F : Type u_6) [inst : Field K] [inst_1 : Field L] [inst_2 : Field F]
[inst_3 : Algebra K L] [inst_4 : Algebra K F] (E : Type u_7) [inst_5 : Field E] [inst_6 : Algebra K E]
[inst_7 : Algebra L F] [IsScalarTower K L F] [IsAlgClosed E] [Algebra.IsSeparable K F]
[inst_11 : FiniteDimen... | null | true |
CategoryTheory.MonoidalCategory.whiskerLeftIso._proof_2 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C)
{Y Z : C} (f : Y ≅ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f.hom)
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X f.inv) =
CategoryTh... | null | false |
FunLike.compSemiring._proof_3 | Mathlib.Algebra.Ring.FunLike | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α α] [inst_1 : Zero F] [inst_2 : One F] [inst_3 : Mul F]
[inst_4 : Add F] [inst_5 : AddCommMonoid α] [inst_6 : IsZeroApply F α α] [inst_7 : IsAddApply F α α]
[inst_8 : IsOneApplyEqSelf F α] [inst_9 : IsMulApplyEqComp F α] [inst_10 : AddMonoidHomClass F α α]
[inst_... | null | false |
CategoryTheory.Limits.colimit.ι_map_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C]
{G : CategoryTheory.Functor J C} (α : F ⟶ G) (j : J) {Z : C} (h : Z ⟶ CategoryTheory.Limits.lim.obj F),
Catego... | null | false |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Stream.forIn.loop._unsafe_rec | Std.Http.Data.Body.Stream | {β : Type} → (Std.Http.Chunk → β → Std.Async.Async (ForInStep β)) → Std.Http.Body.Stream → β → Std.Async.Async β | null | false |
AddOpposite.instAddAction.eq_1 | Mathlib.Algebra.Group.Action.Opposite | ∀ {M : Type u_1} {α : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M α],
AddOpposite.instAddAction = { toVAdd := AddOpposite.instVAdd, add_vadd := ⋯, zero_vadd := ⋯ } | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_union._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.LinearAlgebra.ExteriorAlgebra.BaseChange.0.ExteriorAlgebra.baseChangeEquivForward._proof_4 | Mathlib.LinearAlgebra.ExteriorAlgebra.BaseChange | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S : Type u_3)
[inst_3 : CommRing S] [inst_4 : Algebra R S] (s : S) (y : ExteriorAlgebra R M),
Commute ((algebraMap S (ExteriorAlgebra S (TensorProduct R S M))) s)
((ExteriorAlgebra.baseChangeEquivForwardAux✝ R M... | null | false |
summable_iterate_mul_iff_isQuasiregular | Mathlib.Analysis.SpecificLimits.Normed | ∀ {R : Type u_4} [inst : NonUnitalNormedRing R] {x : R},
‖x‖ < 1 → ((Summable fun x_1 => (fun x_2 => x_2 * x)^[x_1] x) ↔ IsQuasiregular (-x)) | If `‖x‖ < 1` and `x` lies in a non-unital normed ring, then `∑' n : ℕ, x ^ (n + 1)` is summable
if and only if `-x` is quasiregular. | true |
Small.recOn | Mathlib.Logic.Small.Defs | {α : Type v} →
{motive : Small.{w, v} α → Sort u} →
(t : Small.{w, v} α) → ((equiv_small : ∃ S, Nonempty (α ≃ S)) → motive ⋯) → motive t | null | false |
LinearEquiv.arrowCongr._proof_5 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_5} {R₂ : Type u_7} {R₁' : Type u_6} {R₂' : Type u_8} {M₁ : Type u_2} {M₂ : Type u_4} {M₁' : Type u_1}
{M₂' : Type u_3} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : CommSemiring R₁'] [inst_3 : CommSemiring R₂']
[inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂] [inst_6 : AddCommMonoid M₁... | null | false |
TopRep.Hom | Mathlib.RepresentationTheory.Continuous.TopRep | {k : Type u} →
{G : Type v} →
[inst : TopologicalSpace k] → [inst_1 : Ring k] → [inst_2 : Monoid G] → TopRep k G → TopRep k G → Type (max u_1 u_2) | The type of morphisms in `TopRep k G`. | true |
CategoryTheory.GradedObject.isColimitCofan₃MapBifunctor₁₂BifunctorMapObj._proof_13 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₃ : Type u_3} {J : Type u_5} {r : I₁ × I₂ × I₃ → J}
(ρ₁₂ : CategoryTheory.GradedObject.BifunctorComp₁₂IndexData r) (i₁₂ : ρ₁₂.I₁₂) (i₃ : I₃) (i₁ : I₁) (i₂ : I₂),
(i₁, i₂) ∈ ρ₁₂.p ⁻¹' {i₁₂} →
(i₁, i₂, i₃) ∈
(fun x =>
match x with
| (i₁, i₂, i₃) => (ρ₁... | null | false |
FormalMultilinearSeries.instAddCommGroup._proof_9 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Ring 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalAddGroup E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommGroup F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : IsTopologica... | null | false |
Multiset.fst_prod | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {M : Type u_5} {N : Type u_6} [inst : CommMonoid M] [inst_1 : CommMonoid N] (s : Multiset (M × N)),
s.prod.1 = (Multiset.map Prod.fst s).prod | null | true |
Finset.vadd_stabilizer_of_no_doubling | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : DecidableEq G] {A : Finset G} {a : G},
(A + A).card ≤ A.card → a ∈ A → a +ᵥ ↑(AddAction.stabilizer G A) = ↑A | A non-empty set with no doubling is the left-translate of its stabilizer. | true |
Equiv.Set.sep | Mathlib.Logic.Equiv.Set | {α : Type u} → (s : Set α) → (t : α → Prop) → ↑{x | x ∈ s ∧ t x} ≃ ↑{x | t ↑x} | The set `{x ∈ s | t x}` is equivalent to the set of `x : s` such that `t x`. | true |
CategoryTheory.Limits.pullbackDiagonalMapIdIso._proof_10 | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {S T : C}
(i : T ⟶ S) [inst_2 : CategoryTheory.Limits.HasPullback i i],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.diagonal i)
(CategoryTheory.CategoryStruct.id (CategoryTheor... | null | false |
_private.Mathlib.Tactic.ReduceModChar.0.Tactic.ReduceModChar.typeToCharP._sparseCasesOn_4 | Mathlib.Tactic.ReduceModChar | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Topology.IsScott.isOpen_iff_scottContinuous_mem | Mathlib.Topology.Order.ScottTopology | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} [inst_1 : TopologicalSpace α] [Topology.IsScott α Set.univ],
IsOpen s ↔ ScottContinuous fun x => x ∈ s | null | true |
_private.Lean.Meta.Tactic.Simp.Attr.0.Lean.Meta.addDeclToUnfold._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.Attr | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
HomologicalComplex.op._proof_1 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {c : ComplexShape ι}
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (X : HomologicalComplex V c) (i j : ι),
¬c.symm.Rel i j → (X.d j i).op = 0 | null | false |
ZMod.toAddCircle_injective | Mathlib.Topology.Instances.AddCircle.Real | ∀ (N : ℕ) [inst : NeZero N], Function.Injective ⇑ZMod.toAddCircle | null | true |
WithBot.instMonoidWithZero | Mathlib.Algebra.Order.Ring.WithTop | {α : Type u_1} →
[DecidableEq α] → [inst : MonoidWithZero α] → [NoZeroDivisors α] → [Nontrivial α] → MonoidWithZero (WithBot α) | null | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.bitwise_lt_two_pow._simp_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ (x : ℕ), (x < 2 ^ 0) = (x = 0) | null | false |
ComplexShape.Embedding.extendFunctor._proof_2 | Mathlib.Algebra.Homology.Embedding.Extend | ∀ {ι : Type u_3} {ι' : Type u_4} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') (C : Type u_2)
[inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : HomologicalComplex C c),
HomologicalComplex.exten... | null | false |
CategoryTheory.Pi.monoidalCategory | Mathlib.CategoryTheory.Pi.Monoidal | {I : Type w₁} →
{C : I → Type u₁} →
[inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] →
[(i : I) → CategoryTheory.MonoidalCategory (C i)] → CategoryTheory.MonoidalCategory ((i : I) → C i) | `Pi.monoidalCategory C` equips the product of an indexed family of categories with
the pointwise monoidal structure. | true |
memPartition | Mathlib.Data.Set.MemPartition | {α : Type u_1} → (ℕ → Set α) → ℕ → Set (Set α) | `memPartition f n` is the partition containing at most `2^(n+1)` sets, where each set contains
the points that for all `i` belong to one of `f i` or its complement. | true |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prod_fac₁ | Mathlib.CategoryTheory.Localization.Prod | ∀ {C₁ : Type u₁} {C₂ : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {E : Type u₅} [inst_2 : CategoryTheory.Category.{v₅, u₅} E]
(F : CategoryTheory.Functor (C₁ × C₂) E) (hF :... | null | true |
typeToBoolAlgOp._proof_4 | Mathlib.Order.Category.BoolAlg | ∀ {X Y : Type u_1} (f : X ⟶ Y) (a b : Set Y),
(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)) (a ⊓ b) =
(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)) a ⊓
(CompleteLatticeHom.setPreimage ⇑(CategoryTheory.ConcreteCategory.hom f)) b | null | false |
Std.TreeSet.Raw.containsThenInsert_fst | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.containsThenInsert k).1 = t.contains k | null | true |
mulLeftMono_of_mulLeftStrictMono | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (M : Type u_3) [inst : Mul M] [inst_1 : PartialOrder M] [MulLeftStrictMono M], MulLeftMono M | null | true |
Lean.Parser.PrattParsingTables.mk.injEq | Lean.Parser.Basic | ∀ (leadingTable : Lean.Parser.TokenMap (Lean.Parser.Parser × ℕ)) (leadingParsers : List (Lean.Parser.Parser × ℕ))
(trailingTable : Lean.Parser.TokenMap (Lean.Parser.Parser × ℕ)) (trailingParsers : List (Lean.Parser.Parser × ℕ))
(leadingTable_1 : Lean.Parser.TokenMap (Lean.Parser.Parser × ℕ)) (leadingParsers_1 : Lis... | null | true |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.processConstructors | Lean.Elab.Tactic.RCases | Lean.Syntax →
ℕ →
optParam (Array Lean.Meta.AltVarNames) #[] →
List Lean.Name →
List Lean.Elab.Tactic.RCases.RCasesPatt →
Lean.MetaM (Array Lean.Meta.AltVarNames × List (Lean.Name × List Lean.Elab.Tactic.RCases.RCasesPatt)) | Takes a list of constructor names, and an (alternation) list of patterns, and matches each
pattern against its constructor. It returns the list of names that will be passed to `cases`,
and the list of `(constructor name, patterns)` for each constructor, where `patterns` is the
(conjunctive) list of patterns to apply to... | true |
AList.lookup_union_eq_some | Mathlib.Data.List.AList | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {b : β a} {s₁ s₂ : AList β},
AList.lookup a (s₁ ∪ s₂) = some b ↔ AList.lookup a s₁ = some b ∨ a ∉ s₁ ∧ AList.lookup a s₂ = some b | null | true |
Lean.NameGenerator.mk.injEq | Init.MetaTypes | ∀ (namePrefix : Lean.Name) (idx : ℕ) (namePrefix_1 : Lean.Name) (idx_1 : ℕ),
({ namePrefix := namePrefix, idx := idx } = { namePrefix := namePrefix_1, idx := idx_1 }) =
(namePrefix = namePrefix_1 ∧ idx = idx_1) | null | true |
cfcₙ_comp_smul._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.Cache.addFalse._proof_2 | Std.Sat.AIG.CNF | ∀ {aig : Std.Sat.AIG ℕ} {cnf : Std.Sat.CNF ℕ} (cache : Std.Sat.AIG.toCNF.Cache✝ aig cnf) (idx : ℕ)
(hmarkbound : idx < (Std.Sat.AIG.toCNF.Cache.marks✝ cache).size),
((Std.Sat.AIG.toCNF.Cache.marks✝ cache).set idx true hmarkbound).size = aig.decls.size | null | false |
_private.Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact.0.AlgebraicGeometry.exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isCompact._simp_1_3 | Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact | ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, (a ⊓ b ≤ b) = True | null | false |
Lean.PrettyPrinter.Delaborator.withFnRefWhenTagAppFns | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab → Lean.PrettyPrinter.Delaborator.Delab | If `pp.tagAppFns` is set, and if the current expression is a constant application,
then `d` is evaluated with the head constant delaborated with `delabConst` as the ref.
| true |
Ordnode.Bounded.eq_1 | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), Ordnode.nil.Bounded (some a) (some b) = (a < b) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.