name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.Roo._sizeOf_1 | Init.Data.Range.Polymorphic.PRange | {α : Type u} → [SizeOf α] → Std.Roo α → ℕ | null | false |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementFun._proof_2 | Mathlib.Tactic.Translate.Core | ∀ (t : Mathlib.Tactic.Translate.TranslateData) (args : Array Lean.Expr) (n₀ : Lean.Name),
t.changeNumeral = true ∧
(match n₀ with
| `OfNat => true
| `OfNat.ofNat => true
| x => false) =
true ∧
2 ≤ args.size →
¬0 < args.size → False | null | false |
_private.Mathlib.SetTheory.Cardinal.SchroederBernstein.0.Function.Embedding.total.match_1_3 | Mathlib.SetTheory.Cardinal.SchroederBernstein | ∀ (α : Type u_1) (β : Type u_2)
(motive :
((bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) →
Prop)
(x :
(bif false then ULift.{u_2, u_1} α else ULift.{max u_1 u_2, u_2} β) ↪
bif true then ULift.{u_2, ... | null | false |
IsPrimitiveRoot.powerBasis_dim | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {n : ℕ} [inst : NeZero n] (K : Type u) {L : Type v} [inst_1 : Field K] [inst_2 : CommRing L] [inst_3 : IsDomain L]
[inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L] {ζ : L} (hζ : IsPrimitiveRoot ζ n),
(IsPrimitiveRoot.powerBasis K hζ).dim = (minpoly K ζ).natDegree | null | true |
ApplicativeTransformation.mk.inj | Mathlib.Control.Traversable.Basic | ∀ {F : Type u → Type v} {inst : Applicative F} {G : Type u → Type w} {inst_1 : Applicative G}
{app : (α : Type u) → F α → G α} {preserves_pure' : ∀ {α : Type u} (x : α), app α (pure x) = pure x}
{preserves_seq' : ∀ {α β : Type u} (x : F (α → β)) (y : F α), app β (x <*> y) = app (α → β) x <*> app α y}
{app_1 : (α ... | null | true |
Pi.instCeilDiv._proof_3 | Mathlib.Algebra.Order.Floor.Div | ∀ {ι : Type u_3} {α : Type u_1} {π : ι → Type u_2} [inst : AddCommMonoid α] [inst_1 : PartialOrder α]
[inst_2 : (i : ι) → AddCommMonoid (π i)] [inst_3 : (i : ι) → PartialOrder (π i)]
[inst_4 : (i : ι) → SMulZeroClass α (π i)] [inst_5 : (i : ι) → CeilDiv α (π i)] (_a : α),
0 < _a → ∀ (_f _g : (i : ι) → π i), (∀ (a... | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs_sub._proof_1_36 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {i : ℕ} (s : ℕ),
i < (List.filter p (head :: tail)).length → ¬p head = true → i < (List.findIdxs p tail (s + 1)).length | null | false |
_private.Mathlib.Geometry.Manifold.IntegralCurve.Basic.0.IsMIntegralCurveAt.hasMFDerivAt.match_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {γ : ℝ → M}
{v : (x : M) → TangentSpace I x} {t₀ : ℝ} (motive : (∃ s ∈ nhds t₀, IsMIntegralCurv... | null | false |
FormalMultilinearSeries.congr_simp | Mathlib.Analysis.Analytic.Basic | ∀ (𝕜 : Type u_1) (E : Type u_2) (F : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd ... | null | true |
Representation.apply_eq_of_coe_eq | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Group G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (S : Subgroup G)
[Representation.IsTrivial (MonoidHom.comp ρ S.subtype)] (g h : G), ↑g = ↑h → ρ g = ρ h | null | true |
Combinatorics.Line.ColorFocused.distinct_colors | Mathlib.Combinatorics.HalesJewett | ∀ {α : Type u_5} {ι : Type u_6} {κ : Type u_7} {C : (ι → Option α) → κ} (self : Combinatorics.Line.ColorFocused C),
(Multiset.map Combinatorics.Line.AlmostMono.color self.lines).Nodup | The proposition that all lines in a color-focused collection of lines have distinct colors. | true |
WittVector.IsPoly₂.comp | Mathlib.RingTheory.WittVector.IsPoly | ∀ {p : ℕ} {h : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R → WittVector p R}
{f g : ⦃R : Type u_2⦄ → [CommRing R] → WittVector p R → WittVector p R} [hh : WittVector.IsPoly₂ p h]
[hf : WittVector.IsPoly p f] [hg : WittVector.IsPoly p g], WittVector.IsPoly₂ p fun x _Rcr x_1 y => h (f x_1) (g y) | The composition of polynomial functions is polynomial. | true |
String.Slice.Pos.prev?_eq_some_prev | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : s.Pos} (h : p ≠ s.startPos), p.prev? = some (p.prev h) | null | true |
Topology.RelCWComplex.iUnion_skeleton_eq_complex | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D],
⋃ n, ↑(Topology.RelCWComplex.skeleton C ↑n) = C | null | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Initialize.0.Lean.Meta.RefinedDiscrTree.ImportFailure.mk._flat_ctor | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | Lean.Name → Lean.Name → Lean.Exception → Lean.Meta.RefinedDiscrTree.ImportFailure✝ | null | false |
Matrix.rank_mul_eq_left_of_isUnit_det | Mathlib.LinearAlgebra.Matrix.Rank | ∀ {m : Type um} {n : Type un} [inst : Fintype n] {R : Type u_1} [inst_1 : CommRing R] [inst_2 : DecidableEq n]
(A : Matrix n n R) (B : Matrix m n R), IsUnit A.det → (B * A).rank = B.rank | Right multiplying by an invertible matrix does not change the rank | true |
CategoryTheory.Adjunction.commShiftIso_hom_app_counit_app_shift_assoc | Mathlib.CategoryTheory.Shift.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
(adj : F ⊣ G) (A : Type u_3) [inst_2 : AddMonoid A] [inst_3 : CategoryTheory.HasShift C A]
[inst_4 : CategoryTheory.HasShi... | null | true |
mvfderivWithin_neg | Mathlib.Geometry.Manifold.MFDeriv.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_8} [inst_6 : NormedAddCommG... | null | true |
Topology.WithUpper | Mathlib.Topology.Order.LowerUpperTopology | Type u_3 → Type u_3 | Type synonym for a preorder equipped with the upper topology. | true |
PFunctor.M.Agree'.recOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : ℕ) → (a_1 a_2 : F.M) → PFunctor.M.Agree' a a_1 a_2 → Prop} {a : ℕ}
{a_1 a_2 : F.M} (t : PFunctor.M.Agree' a a_1 a_2),
(∀ (x y : F.M), motive 0 x y ⋯) →
(∀ {n : ℕ} {a : F.A} (x y : F.B a → F.M) {x' y' : F.M} (a_3 : x' = PFunctor.M.mk ⟨a, x⟩)
(a_4 : y' = PFunctor.M... | null | false |
_private.Mathlib.Topology.Algebra.Valued.NormedValued.0.Valued.toNormedField._simp_21 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ (r₁ r₂ : NNReal), ↑r₁ * ↑r₂ = ↑(r₁ * r₂) | null | false |
Option.merge_none_left | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {f : α → α → α} {b : Option α}, Option.merge f none b = b | null | true |
RingHom.map_rat_algebraMap | Mathlib.Algebra.Algebra.Rat | ∀ {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Algebra ℚ R] [inst_3 : Algebra ℚ S]
(f : R →+* S) (r : ℚ), f ((algebraMap ℚ R) r) = (algebraMap ℚ S) r | null | true |
Prod.instTorsor._proof_1 | Mathlib.Algebra.Torsor.Basic | ∀ {G : Type u_1} {G' : Type u_2} {P : Type u_3} {P' : Type u_4} [inst : Group G] [inst_1 : Group G']
[inst_2 : Torsor G P] [inst_3 : Torsor G' P'] (x x_1 : G × G') (x_2 : P × P'), (x * x_1) • x_2 = x • x_1 • x_2 | null | false |
DirectLimit.instDivisionRing._proof_18 | 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 |
CategoryTheory.Pi.instBraidedForallEval._proof_2 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_3} {C : I → Type u_2} [inst : (i : I) → CategoryTheory.Category.{u_1, u_2} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] [inst_2 : (i : I) → CategoryTheory.BraidedCategory (C i)]
(i : I) (X Y : (i : I) → C i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal... | null | false |
Aesop.BaseRuleSet.mk.injEq | Aesop.RuleSet | ∀ (normRules : Aesop.Index Aesop.NormRuleInfo) (unsafeRules : Aesop.Index Aesop.UnsafeRuleInfo)
(safeRules : Aesop.Index Aesop.SafeRuleInfo) (unfoldRules : Lean.PHashMap Lean.Name (Option Lean.Name))
(forwardRules : Aesop.ForwardIndex) (forwardRuleNames : Lean.PHashSet Aesop.RuleName)
(rulePatterns : Aesop.RulePa... | null | true |
_private.Mathlib.RingTheory.HahnSeries.Multiplication.0.HahnModule.coeff_smul_right._simp_1_1 | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
_private.Lean.Meta.MethodSpecs.0.Lean.getMethodSpecsInfo._sparseCasesOn_1 | Lean.Meta.MethodSpecs | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.LinearAlgebra.Transvection.Basic.0.LinearEquiv.dilatransvection._simp_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.disjoint_swap_swap._proof_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] {x y z t : α},
[x, y, z, t].Nodup → ∀ (x_1 : α), (Equiv.swap x y) x_1 = x_1 ∨ (Equiv.swap z t) x_1 = x_1 | null | false |
Nat.getElem!_toList_roo_eq_zero | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, n ≤ i + (m + 1) → (m<...n).toList[i]! = 0 | null | true |
LieIdeal.mem_comap._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {J : LieIdeal R L'} {x : L},
(x ∈ LieIdeal.comap f J) = (f x ∈ J) | null | false |
PadicInt.zmodRepr_eq_zero_iff_dvd | Mathlib.NumberTheory.Padics.RingHoms | ∀ {p : ℕ} [hp_prime : Fact (Nat.Prime p)] {x : ℤ_[p]}, x.zmodRepr = 0 ↔ ↑p ∣ x | null | true |
Aesop.ScopeName.global | Aesop.Rule.Name | Aesop.ScopeName | null | true |
_private.Mathlib.Util.Notation3.0.Mathlib.Notation3.exprToMatcher.match_12 | Mathlib.Util.Notation3 | (motive : List Mathlib.Notation3.DelabKey × Lean.TSyntax `term → Sort u_1) →
(__discr : List Mathlib.Notation3.DelabKey × Lean.TSyntax `term) →
((keys : List Mathlib.Notation3.DelabKey) → (matchF : Lean.TSyntax `term) → motive (keys, matchF)) → motive __discr | null | false |
_private.Lean.Parser.Do.0.Lean.Parser.Term.do._regBuiltin.Lean.Parser.Term.do.declRange_3 | Lean.Parser.Do | IO Unit | null | false |
Std.Time.Month.instLawfulEqOrdOffset | Std.Time.Date.Unit.Month | Std.LawfulEqOrd Std.Time.Month.Offset | null | true |
BitVec.instRxcIsAlwaysFinite | Init.Data.Range.Polymorphic.BitVec | ∀ {n : ℕ}, Std.Rxc.IsAlwaysFinite (BitVec n) | null | true |
nnnormHom_apply | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] [inst_1 : NormOneClass α] [inst_2 : NormMulClass α] (x : α),
nnnormHom x = ‖x‖₊ | null | true |
BddOrd.Iso.mk | Mathlib.Order.Category.BddOrd | {α β : BddOrd} → ↑α.toPartOrd ≃o ↑β.toPartOrd → (α ≅ β) | Constructs an equivalence between bounded orders from an order isomorphism between them. | true |
Real.pow_div_factorial_le_exp | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), 0 ≤ x → ∀ (n : ℕ), x ^ n / ↑n.factorial ≤ Real.exp x | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Basic.0.Matrix.det_fromBlocks_zero₂₁._simp_1_8 | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
Lean.Sym.dite_false | Init.Sym.Lemmas | ∀ {α : Sort u} (c : Prop) {inst : Decidable c} (a : c → α) (b : ¬c → α) {ht : ¬c}, dite c a b = b ht | null | true |
Lean.Elab.Tactic.ElimTargetView.ctorIdx | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimTargetView → ℕ | null | false |
Bialgebra.toCoalgebra | Mathlib.RingTheory.Bialgebra.Basic | {R : Type u} → {A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → [self : Bialgebra R A] → Coalgebra R A | null | true |
Finset.prod_inv_index | Mathlib.Algebra.Group.Pointwise.Finset.BigOperators | ∀ {α : Type u_1} {ι : Type u_2} [inst : CommMonoid α] [inst_1 : DecidableEq ι] [inst_2 : InvolutiveInv ι] (s : Finset ι)
(f : ι → α), ∏ i ∈ s⁻¹, f i = ∏ i ∈ s, f i⁻¹ | null | true |
Neg.rec | Init.Prelude | {α : Type u} → {motive : Neg α → Sort u_1} → ((neg : α → α) → motive { neg := neg }) → (t : Neg α) → motive t | null | false |
MeasureTheory.SimpleFunc.instCommRing._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : CommRing β],
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
CategoryTheory.effectiveEpiFamilyStructOfComp._proof_3 | Mathlib.CategoryTheory.EffectiveEpi.Comp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {Z Y : I → C} {X : C}
(g : (i : I) → Z i ⟶ Y i) (f : (i : I) → Y i ⟶ X) {W : C} (φ : (a : I) → Y a ⟶ W) (m : X ⟶ W),
(∀ (a : I), CategoryTheory.CategoryStruct.comp (f a) m = φ a) →
∀ (i : I),
CategoryTheory.CategoryStruct.comp (... | null | false |
_private.Mathlib.RingTheory.Smooth.StandardSmoothCotangent.0.Algebra.SubmersivePresentation.sectionCotangent_zero_of_notMem_range._proof_1_1 | Mathlib.RingTheory.Smooth.StandardSmoothCotangent | ∀ {R : Type u_3} {S : Type u_4} {ι : Type u_1} {σ : Type u_2} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (i : ι),
(¬∀ (i_1 : σ), (if i = P.map i_1 then 1 else 0) = 0) → i ∈ Set.range P.map | null | false |
fderivWithin_finsetProd | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_5} {𝔸' : Type u_7} [inst_3 : NormedCommRing 𝔸']
[inst_4 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {g : ι → E → 𝔸'} [inst_5 : DecidableEq ι] {x : E},
UniqueDiffWi... | null | true |
IsDiscrete.mono | Mathlib.Topology.Constructions | ∀ {X : Type u} [inst : TopologicalSpace X] {s t : Set X}, IsDiscrete s → t ⊆ s → IsDiscrete t | Let `s, t ⊆ X` be two subsets of a topological space `X`. If `t ⊆ s` and `s` is discrete,
then `t` is discrete.
(Compare `DiscreteTopology.of_subset` which is the same thing stated in terms of subtypes.) | true |
_private.Std.Time.Date.Basic.0.Std.Time.Millisecond.Offset.ofDays._proof_1 | Std.Time.Date.Basic | 86400 / ↑86400000 = 1 / 1000 | null | false |
Option.bind_eq_none' | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {o : Option α} {f : α → Option β},
o.bind f = none ↔ ∀ (b : β) (a : α), o = some a → f a ≠ some b | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst.go_denote_eq._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.ShiftRight | ∀ {w : ℕ} (distance curr idx : ℕ), idx < w → w - 1 < w | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.weakRankFunction._proof_11 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} (k : Fin (m + 1)) (n d : ℕ)
(s :
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { len := m + 1 })
(SSet.stdSimplex.obj { len := n })).obj
(Opposite.op { len := d + 1 }))
(hs₁ :
s ∈
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { ... | null | false |
Lean.Meta.SynthInstance.Instance.ctorIdx | Lean.Meta.SynthInstance | Lean.Meta.SynthInstance.Instance → ℕ | null | false |
FreeMonoid.freeMonoidCongr_of | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_6} {β : Type u_7} (e : α ≃ β) (a : α),
(FreeMonoid.freeMonoidCongr e) (FreeMonoid.of a) = FreeMonoid.of (e a) | null | true |
Equiv.ofUnique._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ (α : Sort u_2) (β : Sort u_1) [inst : Unique α] [inst_1 : Unique β] (x : β), default (default x) = x | null | false |
MvQPF.Comp | Mathlib.Data.QPF.Multivariate.Constructions.Comp | {n m : ℕ} → (TypeVec.{u} n → Type u_1) → (Fin2 n → TypeVec.{u} m → Type u) → TypeVec.{u} m → Type u_1 | Composition of an `n`-ary functor with `n` `m`-ary
functors gives us one `m`-ary functor | true |
String.toList_map | Init.Data.String.Lemmas.Modify | ∀ {f : Char → Char} {s : String}, (String.map f s).toList = List.map f s.toList | null | true |
Finset.compl_eq_univ_iff._simp_1 | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] (s : Finset α), (sᶜ = Finset.univ) = (s = ∅) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.addZ_smul._simp_1_4 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 2 = u * P 2 | null | false |
Lean.Attribute.Builtin.getPrio | Lean.Attributes | Lean.Syntax → Lean.AttrM ℕ | null | true |
AddMonoidHom.toMultiplicative | Mathlib.Algebra.Group.TypeTags.Hom | {α : Type u_3} →
{β : Type u_4} →
[inst : AddZeroClass α] → [inst_1 : AddZeroClass β] → (α →+ β) ≃ (Multiplicative α →* Multiplicative β) | Reinterpret `α →+ β` as `Multiplicative α →* Multiplicative β`. | true |
Lean.Meta.CaseValuesSubgoal._sizeOf_inst | Lean.Meta.Match.CaseValues | SizeOf Lean.Meta.CaseValuesSubgoal | null | false |
CategoryTheory.MonoidalCategory.DayConvolution.unit_naturality | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {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]
(F G : CategoryTheory.Functor C V) [inst_4 : CategoryTheory.MonoidalCategory.DayConvolution F G] {x x' y y... | null | true |
AddMonoidHom.instDomMulActModule._proof_2 | Mathlib.Algebra.Module.Hom | ∀ {S : Type u_3} {M : Type u_1} {M₂ : Type u_2} [inst : Semiring S] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module S M] (x : M →+ M₂), 0 • x = 0 | null | false |
CategoryTheory.Limits.colimitCurrySwapCompColimIsoColimitCurryCompColim_ι_ι_hom | 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]
(G : CategoryTheory.Functor (J × K) C) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 : CategoryTheory.Limit... | null | true |
ContinuousGeneratedByCat._sizeOf_inst | Mathlib.Topology.Convenient.Category | {ι : Type t} →
(X : ι → Type u) →
{inst : (i : ι) → TopologicalSpace (X i)} →
[SizeOf ι] → [(a : ι) → SizeOf (X a)] → SizeOf (ContinuousGeneratedByCat X) | null | false |
CategoryTheory.BasedFunctor.mk | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{𝒳 : CategoryTheory.BasedCategory 𝒮} →
{𝒴 : CategoryTheory.BasedCategory 𝒮} →
(toFunctor : CategoryTheory.Functor 𝒳.obj 𝒴.obj) →
autoParam (toFunctor.comp 𝒴.p = 𝒳.p) CategoryTheory.BasedFunctor.w._autoParam →
... | null | true |
Squarefree.dvd_of_squarefree_of_mul_dvd_mul_left | Mathlib.Algebra.Squarefree.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [IsCancelMulZero R] {x y d : R} [DecompositionMonoid R],
Squarefree y → d * d ∣ x * y → d ∣ x | null | true |
ExpChar.congr | Mathlib.Algebra.CharP.Defs | ∀ (R : Type u_1) [inst : AddMonoidWithOne R] {p : ℕ} (q : ℕ) [hq : ExpChar R q], q = p → ExpChar R p | null | true |
Std.HashMap.getElem_filterMap'._proof_1 | Std.Data.HashMap.Lemmas | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : LawfulBEq α]
{f : α → β → Option γ} {k : α} {h : k ∈ Std.HashMap.filterMap f m}, (f k m[k]).isSome = true | null | false |
Std.DTreeMap.Const.get?_eq_some_iff_exists_compare_eq_eq_and_mem_toList | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k : α}
{v : β}, Std.DTreeMap.Const.get? t k = some v ↔ ∃ k', cmp k k' = Ordering.eq ∧ (k', v) ∈ Std.DTreeMap.Const.toList t | null | true |
Relation.map_apply | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {r : α → β → Prop} {f : α → γ} {g : β → δ} {c : γ}
{d : δ}, Relation.Map r f g c d ↔ ∃ a b, r a b ∧ f a = c ∧ g b = d | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.expandShow._regBuiltin.Lean.Elab.Term.expandShow_1 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
List.Vector.traverse_def | Mathlib.Data.Vector.Basic | ∀ {n : ℕ} {F : Type u → Type u} [inst : Applicative F] {α β : Type u} (f : α → F β) (x : α) (xs : List.Vector α n),
List.Vector.traverse f (x ::ᵥ xs) = List.Vector.cons <$> f x <*> List.Vector.traverse f xs | null | true |
CategoryTheory.Enriched.Functor.functorHom_whiskerLeft_natTransEquiv_symm_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(K L : CategoryTheory.Functor C D) (X : C) (f : L ⟶ L)
(x :
CategoryTheory.MonoidalCategoryStruct.tensorObj ((K.functorHom L).obj X)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (Type ... | null | true |
CovBy.lt_iff_le_right | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α}, y ⋖ x → ∀ {z : α}, y < z ↔ x ≤ z | null | true |
Std.Async.TCP.Socket.Server.recOn | Std.Async.TCP | {motive : Std.Async.TCP.Socket.Server → Sort u} →
(t : Std.Async.TCP.Socket.Server) → ((native : Std.Internal.UV.TCP.Socket) → motive { native := native }) → motive t | null | false |
String.utf8Len_le_of_infix | Batteries.Data.String.Lemmas | ∀ {cs₁ cs₂ : List Char}, cs₁ <:+: cs₂ → String.utf8Len cs₁ ≤ String.utf8Len cs₂ | null | true |
FiniteAddGrp.of.eq_1 | Mathlib.Algebra.Category.Grp.FiniteGrp | ∀ (G : Type u) [inst : AddGroup G] [inst_1 : Finite G],
FiniteAddGrp.of G = { toAddGrp := AddGrpCat.of G, isFinite := inst_1 } | null | true |
CategoryTheory.CategoryOfElements.map_map_coe | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)} (α : F₁ ⟶ F₂)
{t₁ t₂ : F₁.Elements} (k : t₁ ⟶ t₂), ↑((CategoryTheory.CategoryOfElements.map α).map k) = ↑k | null | true |
ArchimedeanClass.instFieldFiniteResidueField._proof_64 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K], 0⁻¹ = 0 | null | false |
_private.Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites.0.CategoryTheory.Limits.createsLimitLeftOp._proof_1 | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
(K : CategoryTheory.Functor J Cᵒᵖ) (F : CategoryTheory.Functor C Dᵒᵖ) [CategoryTheory.CreatesColimit K.leftOp F],
CategoryThe... | null | false |
_private.Mathlib.Order.Partition.Finpartition.0.Finpartition.mem_part_ofSetSetoid_iff_rel._simp_1_1 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} (P : Finpartition s) {a b : α},
(a ∈ P.part b) = ∃ p ∈ P.parts, a ∈ p ∧ b ∈ p | null | false |
MonoidHom.snd._proof_1 | Mathlib.Algebra.Group.Prod | ∀ (M : Type u_2) (N : Type u_1) [inst : MulOneClass M] [inst_1 : MulOneClass N], 1.2 = 1.2 | null | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.negThm?._default | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Option (Option Lean.Expr) | null | false |
CategoryTheory.Subgroupoid.IsNormal.mk._flat_ctor | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] {S : CategoryTheory.Subgroupoid C},
(∀ (c : C), CategoryTheory.CategoryStruct.id c ∈ S.arrows c c) →
(∀ {c d : C} (p : c ⟶ d) {γ : c ⟶ c},
γ ∈ S.arrows c c →
CategoryTheory.CategoryStruct.comp (CategoryTheory.Groupoid.inv p) (CategoryTheory.Categ... | null | false |
MonoidHom.inr_apply | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : MulOneClass M] [inst_1 : MulOneClass N] (y : N), (MonoidHom.inr M N) y = (1, y) | null | true |
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs : Lean.Meta.Grind.Arith.Linear.LinExpr}
{c_1 : Lean.Meta.Grind.Arith.Linear.RingEqCnstr} {lhs_1 : Lean.Meta.Grind.Arith.Linear.LinExpr},
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c lhs =
Lean.Meta.Grind.Arith.Linear.IneqCnstrProof.ringEq c_1 lhs_1... | null | true |
Std.HashMap.unitOfList_cons | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {hd : α} {tl : List α},
Std.HashMap.unitOfList (hd :: tl) = (∅.insertIfNew hd ()).insertManyIfNewUnit tl | null | true |
Std.DTreeMap.Internal.Impl.Equiv.minEntry_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → ∀ (h : t₁.Equiv t₂) {he : t₁.isEmpty = false}, t₁.minEntry he = t₂.minEntry ⋯ | null | true |
constFormalMultilinearSeries.match_1 | Mathlib.Analysis.Calculus.FormalMultilinearSeries | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((x : ℕ) → motive x) → motive x | null | false |
_private.Mathlib.Order.SuccPred.InitialSeg.0.InitialSeg.isSuccLimit_apply_iff._simp_1_1 | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] (a : α), Order.IsSuccLimit a = (¬IsMin a ∧ Order.IsSuccPrelimit a) | null | false |
Lean.Doc.Block.rec_5 | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{motive_1 : Lean.Doc.Block i b → Sort u_1} →
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1} →
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1} →
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1... | null | false |
MeasureTheory.AEStronglyMeasurable.iUnion | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [Countable ι] [inst : TopologicalSpace β] {m₀ : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {f : α → β} [TopologicalSpace.PseudoMetrizableSpace β] {s : ι → Set α},
(∀ (i : ι), MeasureTheory.AEStronglyMeasurable f (μ.restrict (s i))) →
MeasureTheory.AEStronglyM... | null | true |
_private.Lean.Server.InfoUtils.0.Lean.Elab.Info.type?._sparseCasesOn_1 | Lean.Server.InfoUtils | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.TermInfo) → motive (Lean.Elab.Info.ofTermInfo i)) →
((i : Lean.Elab.FieldInfo) → motive (Lean.Elab.Info.ofFieldInfo i)) →
((i : Lean.Elab.DelabTermInfo) → motive (Lean.Elab.Info.ofDelabTermInfo i)) →
(Nat.hasNotBit... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.