name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
KaehlerDifferential.tensorKaehlerEquivOfFormallyEtale._proof_2 | Mathlib.RingTheory.Etale.Kaehler | ∀ (T : Type u_1) [inst : CommRing T], RingHomInvPair (RingHom.id T) (RingHom.id T) | null | false |
Lean.IR.LogEntry.noConfusionType | Lean.Compiler.IR.CompilerM | Sort u → Lean.IR.LogEntry → Lean.IR.LogEntry → Sort u | null | false |
AddCommute.add_right | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : AddSemigroup S] {a b c : S}, AddCommute a b → AddCommute a c → AddCommute a (b + c) | If `a` commutes with both `b` and `c`, then it commutes with their sum. | true |
DFinsupp.eq_mk_support | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (f : Π₀ (i : ι), β i), f = DFinsupp.mk f.support fun i => f ↑i | null | true |
Lean.Elab.WF.EqnInfo.mk | Lean.Elab.PreDefinition.WF.Eqns | Lean.Name →
List Lean.Name →
Lean.Expr →
Lean.Expr → Array Lean.Name → Lean.Name → Lean.Meta.ArgsPacker → Lean.Elab.FixedParamPerms → Lean.Elab.WF.EqnInfo | null | true |
Function.locallyFinsuppWithin.mem_supported | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddGroup Y] {s : Set X}
{D : Function.locallyFinsuppWithin U Y}, D ∈ Function.locallyFinsuppWithin.supported Y U s ↔ D.support ⊆ s | null | true |
FilterBasis.mk._flat_ctor | Mathlib.Order.Filter.Bases.Basic | {α : Type u_5} →
(sets : Set (Set α)) → sets.Nonempty → (∀ {x y : Set α}, x ∈ sets → y ∈ sets → ∃ z ∈ sets, z ⊆ x ∩ y) → FilterBasis α | null | false |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.changesBefore | Lean.Widget.Diff | Lean.Widget.ExprDiff✝ → Lean.SubExpr.PosMap Lean.Widget.ExprDiffTag✝ | Map from subexpr positions in `e₀` to diff points. | true |
SimplexCategoryGenRel.simplicialInsert._f | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | (x : List ℕ) → List.below (motive := fun x => ℕ → List ℕ) x → ℕ → List ℕ | null | false |
Filter.cocompact_neBot_iff | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} [inst : TopologicalSpace X], (Filter.cocompact X).NeBot ↔ NoncompactSpace X | null | true |
ImportGraph.WorkspaceModel.libOfMod! | ImportGraph.WorkspaceModel.Model | ImportGraph.WorkspaceModel → ImportGraph.WorkspaceModel.Module → ImportGraph.WorkspaceModel.Library | null | true |
Lean.Meta.Grind.Arith.CommRing.RingM.Context.ringId | Lean.Meta.Tactic.Grind.Arith.CommRing.RingM | Lean.Meta.Grind.Arith.CommRing.RingM.Context → ℕ | null | true |
CategoryTheory.Limits.weakKernel.lift' | Mathlib.CategoryTheory.Limits.WeakLimits.WeakKernels | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_2 : CategoryTheory.Limits.HasWeakKernel f] →
{W : C} →
(k : W ⟶ X) →
CategoryTheory.CategoryStruc... | Any morphism `k : W ⟶ X` satisfying `k ≫ f = 0` induces a morphism `l : W ⟶ weakKernel f`
such that `l ≫ weakKernel.ι f = k`. | true |
Equiv.piCongr.eq_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (a : α) → W a ≃ Z (h₁ a)),
h₁.piCongr h₂ = (Equiv.piCongrRight h₂).trans (Equiv.piCongrLeft Z h₁) | null | true |
CategoryTheory.Triangulated.TStructure.eTruncLT_map_eq_truncLTι._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ (n : ℤ), WithBotTop.coe n ≤ ⊤ | null | false |
Std.DTreeMap.Internal.Impl.contains'.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α → Ordering),
Std.DTreeMap.Internal.Impl.contains' k Std.DTreeMap.Internal.Impl.leaf = false | null | true |
TopologicalSpace.IsOpenCover.mk | Mathlib.Topology.Sets.OpenCover | ∀ {ι : Type u_1} {X : Type u_3} [inst : TopologicalSpace X] {u : ι → TopologicalSpace.Opens X},
iSup u = ⊤ → TopologicalSpace.IsOpenCover u | null | true |
IO.Error.mkResourceBusy | Init.System.IOError | UInt32 → String → IO.Error | null | true |
ENNReal.smul_toNNReal | Mathlib.Basic.ENNReal.Action | ∀ (a : NNReal) (b : ENNReal), (a • b).toNNReal = a * b.toNNReal | null | true |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.Filter.totallyBounded_iSup._simp_1_2 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {ι : Sort w} {s : ι → Set α}, Filter.principal (⋃ i, s i) = ⨆ x, Filter.principal (s x) | null | false |
Int.ldiff.eq_3 | Mathlib.Data.Int.Bitwise | ∀ (m n : ℕ), (Int.negSucc m).ldiff (Int.ofNat n) = Int.negSucc (m ||| n) | null | true |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.ext | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {X : CategoryTheory.SimplicialObject.Augmented C}
{x y : X.ExtraDegeneracy}, x.s' = y.s' → x.s = y.s → x = y | null | true |
CochainComplex.XIsoOfEq_shift | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : CochainComplex C ℤ) (n : ℤ) {p q : ℤ} (hpq : p = q),
HomologicalComplex.XIsoOfEq ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).obj K) hpq =
HomologicalComplex.XIsoOfEq K ⋯ | null | true |
CategoryTheory.TwoSquare.whiskerVertical | Mathlib.CategoryTheory.GuitartExact.VerticalComposition | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D₁ : Type u_4} →
{D₂ : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} D₁] →
[inst_3 : CategoryTheory.Category.{v_5, u... | Given `w : TwoSquare T L R B`, one may obtain a 2-square `TwoSquare T L' R' B` if we
provide natural transformations `α : L ⟶ L'` and `β : R' ⟶ R`. | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxo.Iterator.instIteratorLoop.loop.wf.eq_def | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α] {n : Type u → Type w}
[inst_5 : Monad n] (γ : Type u) (Pl : α → γ → ForInStep γ → Prop)
(wf : Std.IteratorLoop.WellFounded ... | null | true |
BitVec.extractAndExtendAux._unary | Init.Data.BitVec.Bitblast | {w : ℕ} → (len : ℕ) → BitVec w → (k : ℕ) ×' (_ : BitVec (k * len)) ×' k ≤ w → BitVec (w * len) | Recursively extract one bit at a time and extend it to width `w` | false |
UInt64.toInt64_sub | Init.Data.SInt.Lemmas | ∀ (a b : UInt64), (a - b).toInt64 = a.toInt64 - b.toInt64 | null | true |
Equiv.pprodProd_apply | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Sort u_2} {β₁ : Sort u_5} {α₂ : Type u_9} {β₂ : Type u_10} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (a : α₁ ×' β₁),
(ea.pprodProd eb) a = (ea a.fst, eb a.snd) | null | true |
Set.rangeFactorization_eq_rangeFactorization_iff | Mathlib.Data.Set.Operations | ∀ {ι : Sort u_2} {α : Type u_3} {f : ι → α} (a b : ι),
Set.rangeFactorization f a = Set.rangeFactorization f b ↔ f a = f b | null | true |
NumberField.mixedEmbedding.fundamentalCone.integerSetEquiv._proof_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(a :
Quotient
(MulAction.orbitRel ↥(NumberField.Units.torsion K) ↑(NumberField.mixedEmbedding.fundamentalCone.integerSet K))),
(↥(NumberField.Units.torsion K) ⧸ MulAction.stabilizer (↥(NumberField.Units.torsion K)) a.out ≃
↥(NumberField.Unit... | null | false |
stronglyMeasurable_deriv_with_param | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_3} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {α : Type u_4} [inst_3 : TopologicalSpace α] [inst_4 : MeasurableSpace α]
[OpensMeasurableSpace α] [CompleteSpace F] [LocallyCompactSpace 𝕜] [inst_8 : MeasurableSpace 𝕜]
[OpensMeasura... | null | true |
Batteries.Tactic.Lint.env_linter | Batteries.Tactic.Lint.Basic | Lean.ParserDescr | Defines the `@[env_linter]` attribute for adding a linter to the default set.
The form `@[env_linter disabled]` will not add the linter to the default set,
but it will be shown by `#list_linters` and can be selected by the `#lint` command.
Linters are named using their declaration names, without the namespace. These m... | true |
AddSubsemigroup.prodEquiv.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] (s : AddSubsemigroup M) (t : AddSubsemigroup N),
s.prodEquiv t = { toEquiv := Equiv.Set.prod ↑s ↑t, map_add' := ⋯ } | null | true |
SemiRingCat.hasForgetToAddCommMonCat._proof_2 | Mathlib.Algebra.Category.Ring.Basic | ∀ {X Y Z : SemiRingCat} (f : X ⟶ Y) (g : Y ⟶ Z),
AddCommMonCat.ofHom (SemiRingCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g)).toAddMonoidHom =
CategoryTheory.CategoryStruct.comp (AddCommMonCat.ofHom (SemiRingCat.Hom.hom f).toAddMonoidHom)
(AddCommMonCat.ofHom (SemiRingCat.Hom.hom g).toAddMonoidHom) | null | false |
Topology.WithScott.ofScott | Mathlib.Topology.Order.ScottTopology | {α : Type u_1} → Topology.WithScott α ≃ α | `ofScott` is the identity function from the `WithScott` of a type. | true |
UniformSpace.hausdorff.instCompactSpaceSet | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] [CompactSpace α], CompactSpace (Set α) | null | true |
sbtw_const_sub_iff | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] {x y z : V} (v : V), Sbtw R (v - x) (v - y) (v - z) ↔ Sbtw R x y z | null | true |
AddCommGrpCat.kernelIsoKer._proof_3 | Mathlib.Algebra.Category.Grp.Limits | ∀ {G H : AddCommGrpCat} (f : G ⟶ H),
CategoryTheory.CategoryStruct.comp (AddCommGrpCat.ofHom (AddCommGrpCat.Hom.hom f).ker.subtype) f = 0 | null | false |
TopCat.Presheaf.stalkCongr_hom | Mathlib.Topology.Sheaves.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C] {X : TopCat}
(F : TopCat.Presheaf C X) {x y : ↑X} (e : Inseparable x y), (F.stalkCongr e).hom = F.stalkSpecializes ⋯ | null | true |
Lean.Meta.ElimAltInfo.mk | Lean.Meta.Tactic.ElimInfo | Lean.Name → Option Lean.Name → ℕ → Bool → Lean.Meta.ElimAltInfo | null | true |
CategoryTheory.Limits.DiagramOfCones.id | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] {C : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} (self : CategoryTheory.Limits.DiagramOfCones F) (j : J),
(self.ma... | null | true |
Finset.lcm_congr | Mathlib.Algebra.GCDMonoid.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] {s₁ s₂ : Finset β}
{f g : β → α}, s₁ = s₂ → (∀ a ∈ s₂, f a = g a) → s₁.lcm f = s₂.lcm g | null | true |
Group.Presentation.ofFreeGroupHom_rel | Mathlib.GroupTheory.Presentation | ∀ {G : Type u_1} {ι : Type u_2} [inst : Group G] (φ : FreeGroup ι →* G) (hφ : Function.Surjective ⇑φ)
(rel : Set (FreeGroup ι)) (hrel : φ.ker = Subgroup.normalClosure rel),
(Group.Presentation.ofFreeGroupHom φ hφ rel hrel).rel = rel | null | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Sort u → Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u | null | false |
Std.TreeSet.maxD_eq_getLastD_toList | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {fallback : α},
t.maxD fallback = t.toList.getLastD fallback | null | true |
Algebra.adjoin_root_eq_top_of_isSplittingField | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u} [inst : Field K] {n : ℕ},
(primitiveRoots n K).Nonempty →
∀ {a : K},
Irreducible (Polynomial.X ^ n - Polynomial.C a) →
∀ {L : Type u_1} [inst_1 : Field L] [inst_2 : Algebra K L]
[Polynomial.IsSplittingField K L (Polynomial.X ^ n - Polynomial.C a)] {α : L},
α ^ n = ... | null | true |
Matrix.mvPolynomialX | Mathlib.LinearAlgebra.Matrix.MvPolynomial | (m : Type u_1) → (n : Type u_2) → (R : Type u_3) → [inst : CommSemiring R] → Matrix m n (MvPolynomial (m × n) R) | The matrix with variable `X (i,j)` at location `(i,j)`. | true |
Std.Do.SPred.and_curry | Std.Do.SPred.Laws | ∀ {σs : List (Type u)} {P Q : Std.Do.SVal.StateTuple σs → Prop},
((Std.Do.SVal.curry fun t => { down := P t }) ∧ Std.Do.SVal.curry fun t => { down := Q t }) ⊣⊢ₛ
Std.Do.SVal.curry fun t => { down := P t ∧ Q t } | null | true |
AddOpposite.instIsUniformAddGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α], IsUniformAddGroup αᵃᵒᵖ | null | true |
Std.TreeSet.Raw.get?_ofList_of_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.Raw.ofList l cmp).get? k' = some k | null | true |
ValueDistribution.logCounting | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
[ProperSpace 𝕜] → {E : Type u_2} → [inst_2 : NormedAddCommGroup E] → [NormedSpace 𝕜 E] → (𝕜 → E) → WithTop E → ℝ → ℝ | The logarithmic counting function of a meromorphic function.
If `f : 𝕜 → E` is meromorphic and `a : WithTop E` is any value, this is a logarithmically weighted
measure of the number of times the function `f` takes a given value `a` within the disk `∣z∣ ≤ r`,
taking multiplicities into account. In the special case wh... | true |
AddCircle.instAddQuotientMeasureEqMeasurePreimageSubtypeAddOppositeRealMemAddSubgroupOpZmultiplesVolume | Mathlib.MeasureTheory.Integral.IntervalIntegral.Periodic | ∀ (T : ℝ) [hT : Fact (0 < T)],
MeasureTheory.AddQuotientMeasureEqMeasurePreimage MeasureTheory.volume MeasureTheory.volume | null | true |
Std.WP.EStateM.of_run_eq_wp | Std.WP.Monad.Sound | ∀ {ε σ α : Type} {x : EStateM.Result ε σ α} {prog : EStateM ε σ α} {s : σ},
prog.run s = x →
∀ (P : EStateM.Result ε σ α → Prop),
Std.WP.wp prog (fun a s' => P (EStateM.Result.ok a s')) (fun e s' => P (EStateM.Result.error e s')) s → P x | Soundness for `EStateM`: if `wp prog P s` holds, then `P` holds of `(prog.run s)`. | true |
Lean.Meta.Sym.State.maxFVar._default | Lean.Meta.Sym.SymM | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr (Option Lean.FVarId) | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Rat.0.Std.Tactic.BVDecide.LRAT.Internal.State.checkRat.match_1.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Rat | ∀ (motive : Option Std.Tactic.BVDecide.LRAT.Internal.Assignment → Sort u_1)
(assign : Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(h_1 : (assign : Std.Tactic.BVDecide.LRAT.Internal.Assignment) → motive (some assign)) (h_2 : Unit → motive none),
(match some assign with
| some assign => h_1 assign
| none ... | null | true |
_private.Mathlib.Algebra.BigOperators.Group.List.Basic.0.List.sum_hom_nonempty.match_1_1 | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_1} (motive : (l : List M) → l ≠ [] → Prop) (l : List M) (hl : l ≠ []),
(∀ (x : M) (xs : List M) (hl : x :: xs ≠ []), motive (x :: xs) hl) → motive l hl | null | false |
NonUnitalSubring.nonUnitalCommRingTopologicalClosure | Mathlib.Topology.Algebra.Ring.Basic | {R : Type u_1} →
[inst : TopologicalSpace R] →
[inst_1 : NonUnitalRing R] →
[inst_2 : IsSemitopologicalRing R] →
[T2Space R] → (s : NonUnitalSubring R) → (∀ (x y : ↥s), x * y = y * x) → NonUnitalCommRing ↥s.topologicalClosure | If a non-unital subring of a non-unital topological ring is commutative, then so is its
topological closure.
See note [reducible non-instances] | true |
Lean.MessageData.instCoeArrayExpr | Lean.Message | Coe (Array Lean.Expr) Lean.MessageData | null | true |
ContinuousDiv.continuous_div' | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u_4} {inst : TopologicalSpace G} {inst_1 : Div G} [self : ContinuousDiv G], Continuous fun p => p.1 / p.2 | null | true |
Lean.Meta.instImpl._@.Lean.Meta.Basic.383016249._hygCtx._hyg.24 | Lean.Meta.Basic | TypeName Lean.Meta.FunInfo | null | false |
Lean.ConstantInfo.recInfo.noConfusion | Lean.Declaration | {P : Sort u} →
{val val' : Lean.RecursorVal} → Lean.ConstantInfo.recInfo val = Lean.ConstantInfo.recInfo val' → (val = val' → P) → P | null | false |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk._flat_ctor | Lean.Meta.Tactic.Grind.Theorems | {α : Type} →
Lean.PHashMap Lean.Name (List α) →
Lean.PHashSet Lean.Meta.Grind.Origin →
Lean.PHashSet Lean.Meta.Grind.Origin → Lean.PHashMap Lean.Meta.Grind.Origin (List α) → Lean.Meta.Grind.Theorems α | null | false |
CategoryTheory.MonoidalCategory.curriedTensor | Mathlib.CategoryTheory.Monoidal.Category | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.MonoidalCategory C] → CategoryTheory.Functor C (CategoryTheory.Functor C C) | The tensor product bifunctor `C ⥤ C ⥤ C` of a monoidal category. | true |
CategoryTheory.GradedObject.HasGoodTensor₁₂Tensor | Mathlib.CategoryTheory.GradedObject.Monoidal | {I : Type u} →
[AddMonoid I] →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.MonoidalCategory C] →
CategoryTheory.GradedObject I C → CategoryTheory.GradedObject I C → CategoryTheory.GradedObject I C → Prop | Given three graded objects `X₁`, `X₂`, `X₃` in `GradedObject I C`, this is the
assumption that for all `i₁₂ : I` and `i₃ : I`, the tensor product functor `- ⊗ X₃ i₃`
commutes with the coproduct of the objects `X₁ i₁ ⊗ X₂ i₂` such that `i₁ + i₂ = i₁₂`. | true |
DirectSum.instRingOfNat._proof_10 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GRing A] (x : A 0) (x_1 : ℕ),
(DirectSum.of A 0) (x ^ x_1) = (DirectSum.of A 0) x ^ x_1 | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_mapM.match_1_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} {n : Type u_1 → Type u_3} [inst : Std.Iterator α m β] {it : Std.IterM m β}
{γ : Type u_1} {f : β → n γ} [inst_1 : Monad n] [inst_2 : MonadAttach n] [inst_3 : MonadLiftT m n]
(motive : (Std.IterM.mapM f it).internalState.inner.Step → Prop) (x : (Std.IterM.mapM f it).inter... | null | false |
Lean.Meta.Simp.Config.failIfUnchanged._default | Init.MetaTypes | Bool | null | false |
CategoryTheory.codiscreteEquiv._proof_4 | Mathlib.CategoryTheory.CodiscreteCategory | ∀ {α : Type u_1}, Function.RightInverse CategoryTheory.Codiscrete.mk CategoryTheory.Codiscrete.as | null | false |
String.Pos.Raw.prev_lt_of_pos | Init.Data.String.Basic | ∀ (s : String) (i : String.Pos.Raw), i ≠ 0 → (String.Pos.Raw.prev s i).byteIdx < i.byteIdx | null | true |
Submodule.rTensorOne_tmul_one | Mathlib.LinearAlgebra.TensorProduct.Submodule | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {M : Submodule R S}
(m : ↥M), M.rTensorOne (m ⊗ₜ[R] 1) = m | null | true |
AdjoinRoot.powerBasisAux'._proof_8 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] {g : Polynomial R} (hg : g.Monic) (f₁ : R) (f₂ : AdjoinRoot g),
(fun i => ((AdjoinRoot.modByMonicHom hg) (f₁ • f₂)).coeff ↑i) =
(RingHom.id R) f₁ • fun i => ((AdjoinRoot.modByMonicHom hg) f₂).coeff ↑i | null | false |
_private.Init.Data.List.Impl.0.List.take.match_1.eq_3 | Init.Data.List.Impl | ∀ {α : Type u_1} (motive : ℕ → List α → Sort u_2) (n : ℕ) (a : α) (as : List α) (h_1 : (x : List α) → motive 0 x)
(h_2 : (n : ℕ) → motive n.succ []) (h_3 : (n : ℕ) → (a : α) → (as : List α) → motive n.succ (a :: as)),
(match n.succ, a :: as with
| 0, x => h_1 x
| n.succ, [] => h_2 n
| n.succ, a :: as =>... | null | true |
_private.Mathlib.Topology.Continuous.0.Continuous.tendsto.match_1_1 | Mathlib.Topology.Continuous | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace Y] {f : X → Y} (x : X) (t : Set Y)
(motive : f x ∈ t ∧ IsOpen t → Prop) (x_1 : f x ∈ t ∧ IsOpen t),
(∀ (hxt : f x ∈ t) (ht : IsOpen t), motive ⋯) → motive x_1 | null | false |
AlgebraicGeometry.LocallyRingedSpace.emptyTo._proof_3 | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ (X : AlgebraicGeometry.LocallyRingedSpace) (U : (TopologicalSpace.Opens ↑↑X.toPresheafedSpace)ᵒᵖ), 0 1 = 0 1 | null | false |
Std.DTreeMap.getKey_filterMap | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] {f : (a : α) → β a → Option (γ a)} {k : α} {h' : k ∈ Std.DTreeMap.filterMap f t},
(Std.DTreeMap.filterMap f t).getKey k h' = t.getKey k ⋯ | null | true |
Set.PartiallyWellOrderedOn.imageProdLex | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {s : Set (Lex (α × β))},
s.IsPWO → ((fun x => (ofLex x).1) '' s).IsPWO | null | true |
Std.ExtTreeMap.getKey?_eq_some_iff | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α},
t.getKey? k = some k' ↔ ∃ (h : k ∈ t), t.getKey k h = k' | null | true |
Fin.foldr.loop.congr_simp | Init.Data.Fin.Fold | ∀ {α : Sort u_1} (n : ℕ) (f f_1 : Fin n → α → α),
f = f_1 →
∀ (i i_1 : ℕ) (e_i : i = i_1) (a : i ≤ n) (a_1 a_2 : α),
a_1 = a_2 → Fin.foldr.loop n f i a a_1 = Fin.foldr.loop n f_1 i_1 ⋯ a_2 | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_filter_containsKey_iff.match_1_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (a : α) × β a → Prop) (h : (a : α) × β a),
(∀ (k : α) (v : β k), motive ⟨k, v⟩) → motive h | null | false |
Subring.centralizer._proof_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : Ring R] (s : Set R) {x : R}, x ∈ s.centralizer → -x ∈ s.centralizer | null | false |
ne_iff_lt_iff_le._simp_2 | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a ≠ b ↔ a < b) = (a ≤ b) | null | false |
IsUnit.isSMulRegular | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} (M : Type u_3) {a : R} [inst : Monoid R] [inst_1 : MulAction R M], IsUnit a → IsSMulRegular M a | A unit is `M`-regular. | true |
DirectLimit.instStarAddMonoid._proof_2 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | null | false |
Std.Sat.AIG.denote_not_invert | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {assign : α → Bool} {aig : Std.Sat.AIG α} {gate : ℕ}
{inv : Bool} {hgate : gate < aig.decls.size},
⟦assign, { aig := aig, ref := { gate := gate, invert := !inv, hgate := hgate } }⟧ =
!⟦assign, { aig := aig, ref := { gate := gate, invert := inv, hgate := ... | null | true |
_private.Mathlib.Data.List.Sections.0.List.mem_sections._simp_1_2 | Mathlib.Data.List.Sections | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | null | false |
ContinuousLinearMap.topologicalSpace._proof_2 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜₁ : Type u_3} {𝕜₂ : Type u_4} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_1}
{F : Type u_2} [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜₂ F]
[inst_6 : TopologicalSpace E] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | null | false |
_private.Lean.Meta.Tactic.SplitIf.0.Lean.Meta.SplitKind.considerIte.match_1 | Lean.Meta.Tactic.SplitIf | (motive : Lean.Meta.SplitKind → Sort u_1) →
(x : Lean.Meta.SplitKind) →
(Unit → motive Lean.Meta.SplitKind.ite) →
(Unit → motive Lean.Meta.SplitKind.both) → ((x : Lean.Meta.SplitKind) → motive x) → motive x | null | false |
CategoryTheory.Arrow.rightHomotopy_congruence | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ (V : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} V] [inst_1 : CategoryTheory.Preadditive V],
CategoryTheory.Congruence (CategoryTheory.Arrow.rightHomotopic V) | null | true |
DividedPowerAlgebra.lift | Mathlib.RingTheory.DividedPowerAlgebra.Init | {R : Type u_2} →
{M : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
{A : Type u_4} →
[inst_3 : CommSemiring A] →
[inst_4 : Algebra R A] →
{I : Ideal A} →
DividedPowers I → (g : M →ₗ[R] ... | The weak universal property of a divided power algebra for morphisms to divided power rings | true |
_private.Init.Data.List.Zip.0.List.zip_map.match_1_1 | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : List α → List β → Prop) (x : List α) (x_1 : List β),
(∀ (x : List β), motive [] x) →
(∀ (x : List α), motive x []) →
(∀ (head : α) (tail : List α) (head_1 : β) (tail_1 : List β), motive (head :: tail) (head_1 :: tail_1)) →
motive x x_1 | null | false |
BitVec.toFin_ushiftRight | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, (x >>> n).toFin = x.toFin / Fin.ofNat (2 ^ w) (2 ^ n) | null | true |
CategoryTheory.MonoidalClosed.instIsRightAdjointObjOppositeFunctorInternalHom | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.MonoidalClosed C] (X : Cᵒᵖ), (CategoryTheory.MonoidalClosed.internalHom.obj X).IsRightAdjoint | null | true |
CategoryTheory.Functor.leftOpRightOpEquiv_unitIso_inv_app | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : (CategoryTheory.Functor Cᵒᵖ D)ᵒᵖ),
(CategoryTheory.Functor.leftOpRightOpEquiv C D).unitIso.inv.app X = (Opposite.unop X).rightOpLeftOpIso.inv.op | null | true |
Nat.bijOn_digitsAppend | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b : ℕ}, 1 < b → ∀ (l : ℕ), Set.BijOn (b.digitsAppend l) {n | n < b ^ l} {L | L.length = l ∧ ∀ x ∈ L, x < b} | The map `n ↦ Nat.digitsAppend b L` is bijection between the set of natural integers `< b ^ l`
to the set of lists of natural integers of length `l` with coefficients `< b` to .
| true |
Finset.preimage_map | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} (f : α ↪ β) (s : Finset α), (Finset.map f s).preimage ⇑f ⋯ = s | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.mu_bdd | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R) {x y : R}
(hn : ∀ (n : ℕ), ∃ m < n + 1, μ ((x + y) ^ n) ^ (1 / ↑n) ≤ (μ (x ^ m) * μ (y ^ (n - m))) ^ (1 / ↑n)) (n : ℕ),
↑(mu✝ μ hn n) / ↑n ∈ Set.Icc 0 1 | null | true |
Std.DTreeMap.Internal.Impl.balanceL!_eq_balance! | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
l.Balanced →
r.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond l.size r.size →
Std.DTreeMap.Internal.Impl.balanceL! k v l r = Std.DTreeMap.Internal.Impl.balance! k v l r | null | true |
CategoryTheory.Functor.whiskeringRight._proof_8 | Mathlib.CategoryTheory.Whiskering | ∀ (C : Type u_5) [inst : CategoryTheory.Category.{u_6, u_5} C] (D : Type u_3)
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
{X Y Z : CategoryTheory.Functor D E} (f : X ⟶ Y) (g : Y ⟶ Z),
{ app := fun F => { app := fun c => (CategoryTheory.CategoryStr... | null | false |
Aesop.Script.LazyStep.build | Aesop.Script.Step | {α : Type} → Lean.MVarId → Aesop.Script.LazyStep.BuildInput α → Lean.MetaM (Aesop.Script.LazyStep × α) | null | true |
Multiset.coe_inter | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} [inst : DecidableEq α] (s t : List α), ↑s ∩ ↑t = ↑(s.bagInter t) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.