name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Finset.erase_val | Mathlib.Data.Finset.Erase | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α) (a : α), (s.erase a).val = s.val.erase a | null | true |
BddDistLat.Iso.mk._proof_3 | Mathlib.Order.Category.BddDistLat | ∀ {α β : BddDistLat} (e : ↑α.toDistLat ≃o ↑β.toDistLat),
CategoryTheory.CategoryStruct.comp
(BddDistLat.ofHom
(let __src := { toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯ };
{ toFun := ⇑e, map_sup' := ⋯, map_inf' := ⋯, map_top' := ⋯, map_bot' := ⋯ }))
(BddDistLat.ofHom
(let __src := {... | null | false |
Vector.mem_attach | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n) (x : { x // x ∈ xs }), x ∈ xs.attach | null | true |
Lean.Elab.Tactic.iterateExactly' | Mathlib.Tactic.Core | {m : Type → Type u} → [Monad m] → ℕ → m Unit → m Unit | `iterateExactly' n t` executes `t` `n` times. If any iteration fails, the whole tactic fails.
| true |
BoundedLatticeHom.dual._proof_2 | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : BoundedOrder α] [inst_2 : Lattice β]
[inst_3 : BoundedOrder β],
Function.RightInverse (fun f => { toLatticeHom := LatticeHom.dual.symm f.toLatticeHom, map_top' := ⋯, map_bot' := ⋯ })
fun f => { toLatticeHom := LatticeHom.dual f.toLatticeHom, map_top' ... | null | false |
Std.DTreeMap.head?_keys | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] [inst : Min α]
[inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.keys.head? = t.minKey? | null | true |
Set.encard_pos | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, 0 < s.encard ↔ s.Nonempty | null | true |
SSet.Subcomplex.N.opEquiv._proof_5 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | ∀ {X : SSet} {A : X.Subcomplex} (x : A.N),
{ toN := SSet.N.opEquiv { toN := SSet.N.opEquiv.symm x.toN, notMem := ⋯ }.toN, notMem := ⋯ } =
{ toN := SSet.N.opEquiv { toN := SSet.N.opEquiv.symm x.toN, notMem := ⋯ }.toN, notMem := ⋯ } | null | false |
_private.Mathlib.Geometry.Convex.Cone.Basic.0.ConvexCone.Flat.mono.match_1_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_1} {G : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup G]
[inst_3 : SMul R G] {C₁ : ConvexCone R G} (motive : C₁.Flat → Prop) (x : C₁.Flat),
(∀ (x : G) (hxS : x ∈ C₁) (hx : x ≠ 0) (hnxS : -x ∈ C₁), motive ⋯) → motive x | null | false |
Lean.Grind.Linarith.eq_eq_subst | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} [inst : Lean.Grind.IntModule α] (ctx : Lean.Grind.Linarith.Context α) (x : Lean.Grind.Linarith.Var)
(p₁ p₂ p₃ : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.eq_eq_subst_cert x p₁ p₂ p₃ = true →
Lean.Grind.Linarith.Poly.denote' ctx p₁ = 0 →
Lean.Grind.Linarith.Poly.denote' ctx p₂ = 0 → L... | null | true |
AddCommMonCat.addCommMonoidObj._aux_4 | Mathlib.Algebra.Category.MonCat.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddCommMonCat) → (j : J) → Zero ((F.comp (CategoryTheory.forget AddCommMonCat)).obj j) | null | false |
SSet.PtSimplex.relStructCastSuccEquivMulStruct._proof_6 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op { len := 0 })} {f g : X.PtSimplex n x} {i : Fin n}
(h : f.RelStruct g i.castSucc),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.succ.succ) h.map = SSet.RelativeMorphism.const.map | null | false |
SimpleGraph.Walk.ofBoxProdLeft._proof_2 | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {α : Type u_1} {β : Type u_2} {H : SimpleGraph β} {x : α × β} (v : α × β), H.Adj x.2 v.2 ∧ x.1 = v.1 → v.1 = x.1 | null | false |
List.isEqv.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u} (x : α → α → Bool) (a : α) (as : List α) (b : α) (bs : List α),
(a :: as).isEqv (b :: bs) x = (x a b && as.isEqv bs x) | null | true |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.instHashableKey.hash.match_1 | Lean.Meta.Tactic.Grind.MBTC | (motive : Lean.Meta.Grind.Key✝ → Sort u_1) →
(x : Lean.Meta.Grind.Key✝) → ((a : Lean.Expr) → motive { mask := a }) → motive x | null | false |
AffineBasis.instInhabitedPUnit._proof_1 | Mathlib.LinearAlgebra.AffineSpace.Basis | ∀ {k : Type u_2} [inst : Ring k], affineSpan k (Set.range id) = ⊤ | null | false |
CategoryTheory.Abelian.im | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Abelian C] → CategoryTheory.Functor (CategoryTheory.Arrow C) C | `Abelian.image` as a functor from the arrow category. | true |
CategoryTheory.ShortComplex.exact_iff_isZero_leftHomology | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology], S.Exact ↔ CategoryTheory.Limits.IsZero S.leftHomology | null | true |
MonoidHom.exists_nhds_isBounded | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {G : Type u_1} {H : Type u_2} [inst : MeasurableSpace G] [inst_1 : Group G] [inst_2 : TopologicalSpace G]
[IsTopologicalGroup G] [BorelSpace G] [LocallyCompactSpace G] [inst_6 : MeasurableSpace H]
[inst_7 : SeminormedGroup H] [OpensMeasurableSpace H] (f : G →* H),
Measurable ⇑f → ∀ (x : G), ∃ s ∈ nhds x, Bornol... | null | true |
FormalMultilinearSeries.unshift_shift | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E (E →L[𝕜] F)} {z : F}, (p.unshift z).shift = p | null | true |
QuotientGroup.equivQuotientZPowOfEquiv_symm | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {A B : Type u} [inst : CommGroup A] [inst_1 : CommGroup B] (e : A ≃* B) (n : ℤ),
(QuotientGroup.equivQuotientZPowOfEquiv e n).symm = QuotientGroup.equivQuotientZPowOfEquiv e.symm n | null | true |
Measure.eq_prod_of_integral_prod_mul_boundedContinuousFunction | Mathlib.MeasureTheory.Measure.HasOuterApproxClosedProd | ∀ {ι : Type u_1} {T : Type u_4} {X : ι → Type u_5} {mX : (i : ι) → MeasurableSpace (X i)}
[inst : (i : ι) → TopologicalSpace (X i)] [∀ (i : ι), BorelSpace (X i)] [∀ (i : ι), HasOuterApproxClosed (X i)]
{mT : MeasurableSpace T} [inst_3 : TopologicalSpace T] [BorelSpace T] [HasOuterApproxClosed T] [inst_6 : Fintype ι... | null | true |
Lean.Lsp.RpcConnected.casesOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.RpcConnected → Sort u} →
(t : Lean.Lsp.RpcConnected) → ((sessionId : UInt64) → motive { sessionId := sessionId }) → motive t | null | false |
IsApproximateSubgroup.subgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : Group G] {S : Type u_2} [inst_1 : SetLike S G] [SubgroupClass S G] {H : S},
IsApproximateSubgroup 1 ↑H | null | true |
HomotopicalAlgebra.FibrantObject.HoCat.ιCompResolutionNatTrans._proof_3 | Mathlib.AlgebraicTopology.ModelCategory.FibrantObjectHomotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C]
(x x_1 : HomotopicalAlgebra.FibrantObject C) (f : x ⟶ x_1),
HomotopicalAlgebra.FibrantObject.toHoCat.map
(CategoryTheory.CategoryStruct.comp f
{ hom := HomotopicalAlgebra.FibrantObject.HoCat.iR... | null | false |
CategoryTheory.WithInitial.Hom.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithInitial C),
CategoryTheory.WithInitial.star.Hom x = PUnit.{v + 1} | null | true |
Std.Http.Protocol.H1.Reader.remainingBytes | Std.Http.Protocol.H1.Reader | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Reader dir → ℕ | Gets the number of bytes remaining in the input buffer.
| true |
Sylow.mulEquivIteratedWreathProduct._proof_3 | Mathlib.GroupTheory.RegularWreathProduct | ∀ (n : ℕ) (G : Type u_1) [Finite G], Finite (Fin n → G) | null | false |
LocallyFiniteOrder.toLocallyFiniteOrderBot._proof_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : OrderBot α] (a x : α),
x ∈ Finset.Ico ⊥ a ↔ x < a | null | false |
OreLocalization.instMul | Mathlib.GroupTheory.OreLocalization.Basic | {R : Type u_1} → [inst : Monoid R] → {S : Submonoid R} → [inst_1 : OreLocalization.OreSet S] → Mul (OreLocalization S R) | null | true |
_private.Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous.0.MvPolynomial.weightedTotalDegree'_eq_bot_iff._simp_1_4 | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | ∀ {α : Type u_1} {a : α}, (↑a = ⊥) = False | null | false |
Std.HashSet.Raw.get_diff | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} {h_mem : k ∈ m₁ \ m₂},
(m₁ \ m₂).get k h_mem = m₁.get k ⋯ | null | true |
PadicInt.norm_intCast_lt_one_iff | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ}, ‖↑z‖ < 1 ↔ ↑p ∣ z | null | true |
HasCompactMulSupport.submonoid.eq_1 | Mathlib.Topology.Algebra.Support | ∀ (α : Type u_2) (β : Type u_4) [inst : TopologicalSpace α] [inst_1 : MulOneClass β],
HasCompactMulSupport.submonoid α β = { carrier := {f | HasCompactMulSupport f}, mul_mem' := ⋯, one_mem' := ⋯ } | null | true |
_private.Lean.Widget.UserWidget.0.Lean.Widget.builtinModulesRef | Lean.Widget.UserWidget | IO.Ref (Std.TreeMap UInt64 (Lean.Name × Lean.Widget.Module) compare) | null | true |
LieSubalgebra.span_univ | Mathlib.Algebra.Lie.Subalgebra | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieSubalgebra.lieSpan R L Set.univ = ⊤ | null | true |
CategoryTheory.Lax.OplaxTrans.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) → F.obj a ⟶ G.obj a)
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (F.... | null | true |
Batteries.BinomialHeap.merge.match_1 | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
(motive : Batteries.BinomialHeap α le → Batteries.BinomialHeap α le → Sort u_2) →
(x x_1 : Batteries.BinomialHeap α le) →
((b₁ : Batteries.BinomialHeap.Imp.Heap α) →
(h₁ : Batteries.BinomialHeap.Imp.Heap.WF le 0 b₁) →
(b₂ : Batteries.B... | null | false |
List.min_replicate | Init.Data.List.MinMax | ∀ {α : Type u_1} [inst : Min α] [Std.MinEqOr α] {n : ℕ} {a : α} (h : List.replicate n a ≠ []),
(List.replicate n a).min h = a | null | true |
_private.Aesop.Tree.Tracing.0.Aesop.Goal.traceMetadata.match_1 | Aesop.Tree.Tracing | (motive : Option (Lean.MVarId × Lean.Meta.SavedState) → Sort u_1) →
(x : Option (Lean.MVarId × Lean.Meta.SavedState)) →
(Unit → motive none) →
((goal : Lean.MVarId) → (state : Lean.Meta.SavedState) → motive (some (goal, state))) → motive x | null | false |
Multiset.toList_eq_nil | Mathlib.Data.Multiset.Basic | ∀ {α : Type u_1} {s : Multiset α}, s.toList = [] ↔ s = 0 | null | true |
CategoryTheory.unmopFunctor._proof_1 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] (X : Cᴹᵒᵖ),
(CategoryTheory.CategoryStruct.id X).unmop = CategoryTheory.CategoryStruct.id X.unmop | null | false |
CategoryTheory.ShortComplex.gFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C), CategoryTheory.ShortComplex.gFunctor.obj S = CategoryTheory.Arrow.mk S.g | null | true |
TopCat.piFanIsLimit._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ {ι : Type u_2} (α : ι → TopCat) (S : CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor α)),
Continuous fun s i => (CategoryTheory.ConcreteCategory.hom (S.π.app { as := i })) s | null | false |
Valuation.IsEquiv.orderRingIso.congr_simp | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {R : Type u_4} {Γ₀ : Type u_5} {Γ₀' : Type u_6} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
[inst_2 : LinearOrderedCommGroupWithZero Γ₀'] {v : Valuation R Γ₀} {w : Valuation R Γ₀'} (h : v.IsEquiv w),
h.orderRingIso = h.orderRingIso | null | true |
_private.Mathlib.Algebra.Group.TypeTags.Basic.0.isRegular_toMul._simp_1_2 | Mathlib.Algebra.Group.TypeTags.Basic | ∀ {R : Type u_1} [inst : Mul R] {c : R}, IsRegular c = (IsLeftRegular c ∧ IsRightRegular c) | null | false |
Nat.mul_pos_iff_of_pos_left | Init.Data.Nat.Lemmas | ∀ {a b : ℕ}, 0 < a → (0 < a * b ↔ 0 < b) | null | true |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_15 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (lhs rhs : Std.Sat.AIG.Fanin), lhs.gate < upper ∧ rhs.gate < upper → lhs.gate < aig.decls.size | null | false |
_private.Mathlib.Topology.Maps.Basic.0.Topology.IsInducing.dense_iff._simp_1_1 | Mathlib.Topology.Maps.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
LinOrd.instConcreteCategoryOrderHomCarrier._proof_4 | Mathlib.Order.Category.LinOrd | ∀ {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X), (CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | null | false |
Bipointed.Hom.mk.noConfusion | Mathlib.CategoryTheory.Category.Bipointed | {X Y : Bipointed} →
{P : Sort u_1} →
{toFun : X.X → Y.X} →
{map_fst : toFun X.toProd.1 = Y.toProd.1} →
{map_snd : toFun X.toProd.2 = Y.toProd.2} →
{toFun' : X.X → Y.X} →
{map_fst' : toFun' X.toProd.1 = Y.toProd.1} →
{map_snd' : toFun' X.toProd.2 = Y.toProd.2} →
... | null | false |
HomologicalComplex.monoidalCategoryStruct._proof_4 | Mathlib.Algebra.Homology.Monoidal | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Preadditive C] {I : Type u_1} [inst_3 : AddMonoid I] (c : ComplexShape I)
[∀ (X₁ X₂ X₃ : CategoryTheory.GradedObject I C), X₁.HasGoodTensor₁₂Tensor X₂ X₃] (K₁ K₂ K₃ : HomologicalCompl... | null | false |
CommAlgCat.instMonoidalCategory._proof_20 | Mathlib.Algebra.Category.CommAlgCat.Monoidal | ∀ {R : Type u_1} [inst : CommRing R] (X Y : CommAlgCat R),
CategoryTheory.CategoryStruct.comp
(CommAlgCat.isoMk (Algebra.TensorProduct.assoc R R R ↑X ↑(CommAlgCat.of R R) ↑Y)).hom
(CommAlgCat.ofHom
(Algebra.TensorProduct.map (AlgHom.id R ↑X)
(CommAlgCat.Hom.hom (CommAlgCat.isoMk (Algebra... | null | false |
cfcₙHomSuperset_apply | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | null | true |
_private.Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty.0.CategoryTheory.MorphismProperty.ofObjectProperty_map_le.match_1_1 | Mathlib.CategoryTheory.MorphismProperty.OfObjectProperty | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P Q : CategoryTheory.ObjectProperty C) {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) ⦃X Y : D⦄ (f : X ⟶ Y)
(motive : (CategoryTheory.MorphismProperty.ofObjectProperty P Q).map F f → Prop)
(h : (Catego... | null | false |
_private.Init.Data.Order.Ord.0.Std.instOrientedOrdProd._proof_1 | Init.Data.Order.Ord | ∀ {α : Type u_2} {β : Type u_1} [inst : Ord α] [inst_1 : Ord β] [Std.OrientedOrd α] [Std.OrientedOrd β],
Std.OrientedOrd (α × β) | null | false |
conjneg_one | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R], conjneg 1 = 1 | null | true |
CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtension.isIso_hom | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} {E : L.LeftExtension F}
(h : E.IsPointwiseLeftKanExtension)... | null | true |
CategoryTheory.Functor.CoconeTypes.IsColimitCore.fac_apply | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimitCore) (c' : F.CoconeTypes) (j : J) (x : F.obj j), hc.desc c' (c.ι j x) = c'.ι j x | null | true |
VAddCommClass.op_left | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {N : Type u_2} {α : Type u_5} [inst : VAdd M α] [inst_1 : VAdd Mᵃᵒᵖ α] [IsCentralVAdd M α]
[inst_3 : VAdd N α] [VAddCommClass M N α], VAddCommClass Mᵃᵒᵖ N α | null | true |
Std.TreeSet.mk._flat_ctor | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : autoParam (α → α → Ordering) Std.TreeSet._auto_1} → Std.TreeMap α Unit cmp → Std.TreeSet α cmp | null | false |
CategoryTheory.NatIso.ofComponents'_hom_app | Mathlib.CategoryTheory.NatIso | ∀ {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} (app : (X : C) → F.obj X ≅ G.obj X)
(naturality :
autoParam
(∀ {X Y : C} (f : Y ⟶ X),
CategoryTheory.CategoryStruct.comp (app Y).inv (F.map f) ... | null | true |
lp.normedAddCommGroup._proof_21 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u_1} {E : α → Type u_2} {p : ENNReal} [inst : (i : α) → NormedAddCommGroup (E i)] [hp : Fact (1 ≤ p)],
Filter.comk
(fun x =>
x ∈
{s |
∃ C,
∀ ⦃x : ↥(lp E p)⦄,
x ∈ s →
∀ ⦃y : ↥(lp E p)⦄,
y ∈ s →
... | null | false |
CategoryTheory.Functor.PreOneHypercoverDenseData._sizeOf_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
{inst : CategoryTheory.Category.{v₀, u₀} C₀} →
{inst_1 : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C₀ C} → {S : C} → [SizeOf C₀] → [SizeOf C] → F.PreOneHypercoverDenseData S → ℕ | null | false |
USize.decEq | Init.Prelude | (a b : USize) → Decidable (a = b) | Decides whether two word-sized unsigned integers are equal. Usually accessed via the
`DecidableEq USize` instance.
This function is overridden at runtime with an efficient implementation.
Examples:
* `USize.decEq 123 123 = .isTrue rfl`
* `(if (6 : USize) = 7 then "yes" else "no") = "no"`
* `show (7 : USize) = 7 by... | true |
OrderIso.symm_image_image | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : LE α] [inst_1 : LE β] (e : α ≃o β) (s : Set α), ⇑e.symm '' ⇑e '' s = s | null | true |
ContDiffMapSupportedIn.topologicalSpace._proof_4 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (i : ℕ), IsBoundedSMul ℝ (E [×i]→L[ℝ] F) | null | false |
spinGroup.mul_star_self_of_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 ∈ spinGroup Q → x * star x = 1 | null | true |
SimpleGraph.Walk.support_prefix_support_append | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (q : G.Walk v w), p.support <+: (p.append q).support | null | true |
MonoidHom.cancel_right | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : MulOne M] [inst_1 : MulOne N] [inst_2 : MulOne P]
{g₁ g₂ : N →* P} {f : M →* N}, Function.Surjective ⇑f → (g₁.comp f = g₂.comp f ↔ g₁ = g₂) | null | true |
Subfield.relfinrank_eq_of_inf_eq | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {A B C : Subfield E}, A ⊓ C = B ⊓ C → A.relfinrank C = B.relfinrank C | null | true |
Lean.Elab.Term.withDeprecationContextFromAttrs | Lean.Elab.DeclModifiers | {m : Type → Type u_1} →
{α : Type} → [MonadWithReaderOf Lean.Elab.Term.Context m] → Array Lean.Elab.Attribute → m α → m α | If `attrs` contains an `@[deprecated]` attribute, runs the action with `Term.Context.checkDeprecated`
disabled, suppressing the `linter.deprecated` warning that would otherwise fire when a deprecated
constant is referenced. Otherwise, runs the action unchanged.
This implements the suppression rule from RFC #8942: depr... | true |
_private.Mathlib.Order.Interval.Set.Fin.0.Fin.preimage_rev_Ioc._simp_1_3 | Mathlib.Order.Interval.Set.Fin | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
_private.Mathlib.Algebra.GroupWithZero.NonZeroDivisors.0.associatesNonZeroDivisorsEquiv._simp_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] {r : M₀},
(r ∈ nonZeroDivisors M₀) = ((∀ (x : M₀), r * x = 0 → x = 0) ∧ ∀ (x : M₀), x * r = 0 → x = 0) | null | false |
Lean.Parser.sepByElemParser.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → String → Lean.PrettyPrinter.Formatter | null | true |
Submodule.finite_iSup | Mathlib.RingTheory.Finiteness.Lattice | ∀ {R : Type u_2} {V : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {ι : Sort u_1}
[Finite ι] (S : ι → Submodule R V) [∀ (i : ι), Module.Finite R ↥(S i)], Module.Finite R ↥(⨆ i, S i) | The submodule generated by a supremum of finite-dimensional submodules, indexed by a finite
sort is finite-dimensional. | true |
Std.Iterators.Types.Flatten.it₂ | Init.Data.Iterators.Combinators.Monadic.FlatMap | {α α₂ β : Type w} → {m : Type w → Type u_1} → Std.Iterators.Types.Flatten α α₂ β m → Option (Std.IterM m β) | null | true |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.ofLE? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Option (Option Lean.Expr) | null | true |
Std.Internal.List.isEmpty_replaceEntry | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {k : α} {v : β k},
(Std.Internal.List.replaceEntry k v l).isEmpty = l.isEmpty | null | true |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocContext.closeAll | Lean.DocString.Extension | Lean.VersoModuleDocs.DocContext✝ → Except String Lean.VersoModuleDocs.DocContext✝ | null | true |
Lean.NameHashSet | Lean.Data.NameMap.Basic | Type | null | true |
Std.LawfulOrderLT.mk | Init.Data.Order.Classes | ∀ {α : Type u} [inst : LT α] [inst_1 : LE α], (∀ (a b : α), a < b ↔ a ≤ b ∧ ¬b ≤ a) → Std.LawfulOrderLT α | null | true |
Lean.Elab.Command.Scope.mk._flat_ctor | Lean.Elab.Command.Scope | String →
Lean.Options →
Lean.Name →
List Lean.OpenDecl →
List Lean.Name →
Array (Lean.TSyntax `Lean.Parser.Term.bracketedBinder) →
Array Lean.Name →
List Lean.Name →
List Lean.Name →
Bool → Bool → Bool → List (Lean.TSyntax `Lean.P... | null | false |
Lean.Meta.DefEqContext.mk.sizeOf_spec | Lean.Meta.Basic | ∀ (lhs rhs : Lean.Expr) (lctx : Lean.LocalContext) (localInstances : Lean.LocalInstances),
sizeOf { lhs := lhs, rhs := rhs, lctx := lctx, localInstances := localInstances } =
1 + sizeOf lhs + sizeOf rhs + sizeOf lctx + sizeOf localInstances | null | true |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.ofComapInteger._simp_1_2 | Mathlib.RingTheory.Valuation.Extension | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] {s : Subring S} {f : R →+* S} {x : R},
(x ∈ Subring.comap f s) = (f x ∈ s) | null | false |
List.prefix_iff_getElem? | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ ↔ ∀ (i : ℕ) (h : i < l₁.length), l₂[i]? = some l₁[i] | null | true |
TensorProduct.instBialgebra._proof_2 | Mathlib.RingTheory.Bialgebra.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
SMulCommClass R S S | null | false |
_private.Mathlib.Topology.NoetherianSpace.0.TopologicalSpace.NoetherianSpace.exists_finite_set_closeds_irreducible._simp_1_3 | Mathlib.Topology.NoetherianSpace | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
UniformConvergenceCLM.«_aux_Mathlib_Topology_Algebra_Module_Spaces_UniformConvergenceCLM___delab_app_UniformConvergenceCLM_term_→SLᵤ[_,_]__1» | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
Polynomial.smeval_neg | Mathlib.Algebra.Polynomial.Smeval | ∀ (R : Type u_1) [inst : Ring R] {S : Type u_2} [inst_1 : AddCommGroup S] [inst_2 : Pow S ℕ] [inst_3 : Module R S]
(p : Polynomial R) (x : S), (-p).smeval x = -p.smeval x | null | true |
_private.Init.Data.Int.Order.0.Int.instLawfulOrderLT._simp_2 | Init.Data.Int.Order | ∀ {a b : Prop} [Decidable a], (a → b) = (¬a ∨ b) | null | false |
TopCat.Presheaf.stalkSpecializes_comp_apply | 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 z : ↑X} (h : x ⤳ y) (h' : y ⤳ z) {F_1 : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) → FunLike (F_1 X Y) (carrier X) (carrier Y)} [inst_2 : Category... | null | true |
ContinuousMultilinearMap.zero_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
(m : (i : ι) → M₁ i), 0 m ... | null | true |
Prop.instCompleteLinearOrder._proof_5 | Mathlib.Order.CompleteLattice.Basic | ∀ (a : Prop), a ⇨ ⊥ = aᶜ | null | false |
Order.height_eq_krullDim_Iic | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (x : α), ↑(Order.height x) = Order.krullDim ↑(Set.Iic x) | null | true |
Lean.Elab.WF.GuessLex.RecCallCache.callerName | Lean.Elab.PreDefinition.WF.GuessLex | Lean.Elab.WF.GuessLex.RecCallCache → Lean.Name | null | true |
ExceptCpsT.runK | Init.Control.ExceptCps | {m : Type u → Type u_1} → {β ε α : Type u} → ExceptCpsT ε m α → ε → (α → m β) → (ε → m β) → m β | Use a monadic action that may throw an exception by providing explicit success and failure
continuations.
| true |
_private.Mathlib.Order.KrullDimension.0.Order.height_le_of_krullDim_preimage_le._proof_1_4 | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] {m : ℕ} (p : LTSeries α),
p.length ≤ m + (p.length - (m + 1)) → p.length > m → False | null | false |
List.eraseP_replicate_of_pos | Init.Data.List.Erase | ∀ {α : Type u_1} {p : α → Bool} {n : ℕ} {a : α},
p a = true → List.eraseP p (List.replicate n a) = List.replicate (n - 1) a | null | true |
Batteries.PairingHeap.tail._proof_1 | Batteries.Data.PairingHeap | ∀ {α : Type u_1} {le : α → α → Bool} (b : Batteries.PairingHeap α le),
Batteries.PairingHeapImp.Heap.WF le (Batteries.PairingHeapImp.Heap.tail le ↑b) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.