name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.Sym.Arith.ClassifyResult.ctorElimType | Lean.Meta.Sym.Arith.Types | {motive : Lean.Meta.Sym.Arith.ClassifyResult → Sort u} → ℕ → Sort (max 1 u) | null | false |
Mathlib.Tactic.MkIff.compactRelation._unsafe_rec | Mathlib.Tactic.MkIffOfInductiveProp | List Lean.Expr →
List (Lean.Expr × Lean.Expr) → List (Option Lean.Expr) × List (Lean.Expr × Lean.Expr) × (Lean.Expr → Lean.Expr) | null | false |
AlgCat.limitSemiring._aux_43 | Mathlib.Algebra.Category.AlgCat.Limits | {R : Type u_4} →
[inst : CommRing R] →
{J : Type u_3} →
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J (AlgCat R)) →
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections] →
ℤ → (CategoryTheory.Limits.Types.Sma... | null | false |
CategoryTheory.instFinalDiscreteOfIsConnected | Mathlib.CategoryTheory.Limits.Final.Connected | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {T : Type w} [Unique T]
(F : CategoryTheory.Functor C (CategoryTheory.Discrete T)) [CategoryTheory.IsConnected C], F.Final | null | true |
lt_or_antisymmRel_or_gt_or_incompRel | Mathlib.Order.Comparable | ∀ {α : Type u_1} [inst : Preorder α] (a b : α),
a < b ∨ AntisymmRel (fun x1 x2 => x1 ≤ x2) a b ∨ b < a ∨ IncompRel (fun x1 x2 => x1 ≤ x2) a b | Exactly one of the following is true. | true |
Float.toRatParts' | Batteries.Data.Float.Basic | Float → Option (ℤ × ℤ) | Returns `v, exp` integers such that `f = v * 2^exp`.
Like `toRatParts`, but `e` is guaranteed to be minimal (`v` is always odd), unless `v = 0`.
`v.abs` will be at most `2^53 - 1` because `Float` has 53 bits of precision.
Returns `none` when `f` is not finite (i.e. `inf`, `-inf` or a `nan`). | true |
OrderAddMonoidIso.mk.injEq | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_6} {β : Type u_7} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β]
(toAddEquiv : α ≃+ β) (map_le_map_iff' : ∀ {a b : α}, toAddEquiv.toFun a ≤ toAddEquiv.toFun b ↔ a ≤ b)
(toAddEquiv_1 : α ≃+ β) (map_le_map_iff'_1 : ∀ {a b : α}, toAddEquiv_1.toFun a ≤ toAddEquiv_1.toFun b ↔ a... | null | true |
Bundle.Trivial.trivialization.isLinear | Mathlib.Topology.VectorBundle.Constructions | ∀ (𝕜 : Type u_1) (B : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace B],
Bundle.Trivialization.IsLinear 𝕜 (Bundle.Trivial.trivialization B F) | null | true |
Lean.Elab.Do.DoElemCont.recOn | Lean.Elab.Do.Basic | {motive : Lean.Elab.Do.DoElemCont → Sort u} →
(t : Lean.Elab.Do.DoElemCont) →
((resultName : Lean.Name) →
(resultType : Lean.Expr) →
(k : Lean.Elab.Do.DoElabM Lean.Expr) →
(kind : Lean.Elab.Do.DoElemContKind) →
motive { resultName := resultName, resultType := resultType... | null | false |
Monoid.CoprodI.Word.mem_rcons_iff | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] {i j : ι}
(p : Monoid.CoprodI.Word.Pair M i) (m : M j),
⟨j, m⟩ ∈ (Monoid.CoprodI.Word.rcons p).toList ↔ ⟨j, m⟩ ∈ p.tail.toList ∨ m ≠ 1 ∧ ∃ (h : i = j), m = h ▸ p.head | null | true |
Function.Exact.linearEquivOfSurjective_apply | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {P : Type u_6} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (h : Function.Exact ⇑f ⇑g) (hg : Function.Surjective ⇑g) (x : ... | null | true |
Finset.mem_of_max | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {a : α}, s.max = ↑a → a ∈ s | null | true |
UInt64.add_sub_cancel | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a + b - b = a | null | true |
Filter.lift'_mono | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {h₁ h₂ : Set α → Set β},
f₁ ≤ f₂ → h₁ ≤ h₂ → f₁.lift' h₁ ≤ f₂.lift' h₂ | null | true |
Std.TreeSet.all | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet α cmp → (α → Bool) → Bool | Check if any element satisfies the predicate, short-circuiting if a predicate succeeds. | true |
CategoryTheory.Functor.congruence_homRel | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_2, u_2} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} D] (F : CategoryTheory.Functor C D), CategoryTheory.Congruence F.homRel | For `F : C ⥤ D`, `F.homRel` is a congruence. | true |
Algebra.PreSubmersivePresentation.ofHasCoeffs_algebra_algebraMap_apply | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ) (R₀ : Type u_5) [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S] [inst_7 : P.HasCoeffs ... | null | true |
CategoryTheory.Limits.pushoutCoconeOfRightIso_inl | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.IsIso g],
(CategoryTheory.Limits.pushoutCoconeOfRightIso f g).inl = CategoryTheory.CategoryStruct.id Y | null | true |
Subsemigroup.comap_sup_map_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f →
∀ (S T : Subsemigroup M), Subsemigroup.comap f (Subsemigroup.map f S ⊔ Subsemigroup.map f T) = S ⊔ T | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_inter_of_contains_eq_false_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Lean.Parser.OrElseOnAntiquotBehavior.noConfusionType | Lean.Parser.Basic | Sort v✝ → Lean.Parser.OrElseOnAntiquotBehavior → Lean.Parser.OrElseOnAntiquotBehavior → Sort v✝ | null | true |
_private.Mathlib.CategoryTheory.Monoidal.Mon.0.CategoryTheory.MonObj.ext._simp_1_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C],
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tenso... | null | false |
Vector.extract_push._proof_2 | Init.Data.Vector.Extract | ∀ {n start stop : ℕ}, stop ≤ n → min stop n - start = min stop (n + 1) - start | null | false |
CategoryTheory.Endofunctor.Algebra.Hom.h | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} (self : A₀.Hom A₁),
CategoryTheory.CategoryStruct.comp (F.map self.f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str self.f | compatibility condition | true |
WeierstrassCurve.Jacobian.dblZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Jacobian R → (Fin 3 → R) → R | The `Z`-coordinate of a representative of `2 • P` for a Jacobian point representative `P` on a
Weierstrass curve. | true |
SimpleGraph.Copy.toSubgraph_surjOn | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W},
Set.SurjOn SimpleGraph.Copy.toSubgraph Set.univ {G' | Nonempty (H ≃g G'.coe)} | null | true |
CategoryTheory.Functor.IsDenseSubsite.faithful_sheafPushforwardContinuous | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (J : CategoryTheory.GrothendieckTopology C)
(K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D) {A : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] [ins... | null | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getQuotKind.match_3 | Lean.Elab.Quotation | (motive : Lean.SyntaxNodeKind → Sort u_1) →
(x : Lean.SyntaxNodeKind) →
(Unit → motive `Lean.Parser.Command.quot) →
(Unit → motive `Lean.Parser.Term.quot) →
(Unit → motive `Lean.Parser.Tactic.quot) →
(Unit → motive `Lean.Parser.Tactic.quotSeq) →
((kind : Lean.Name) → motive (ki... | null | false |
_private.Std.Sat.CNF.Negation.0.Std.Sat.CNF.isNegationOf_append_comm_right._simp_1_2 | Std.Sat.CNF.Negation | ∀ {a b : Prop}, (a ∨ b) = (b ∨ a) | null | false |
_private.Mathlib.Order.Iterate.0.Function.Commute.iterate_pos_le_iff_map_le'._simp_1_1 | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator.mk._flat_ctor | Lean.PrettyPrinter.Delaborator.SubExpr | ℕ → ℕ → Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator | null | false |
HomotopicalAlgebra.Cylinder.symm_i | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.Cylinder A)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C],
P.symm.i = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.braiding A A).hom P.... | null | true |
_private.Init.Data.Array.Basic.0.Array.allDiffAux | Init.Data.Array.Basic | {α : Type u} → [BEq α] → Array α → ℕ → Bool | null | true |
CategoryTheory.Bicategory.Adj.id_adj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (a : CategoryTheory.Bicategory.Adj B),
(CategoryTheory.CategoryStruct.id a).adj = CategoryTheory.Bicategory.Adjunction.id a.obj | null | true |
Finset.finset_congr_piAntidiag_eq_antidiag | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {μ : Type u_2} [inst : AddCommMonoid μ] [inst_1 : Finset.HasAntidiagonal μ] [inst_2 : DecidableEq μ] (n : μ),
(Equiv.boolArrowEquivProd μ).finsetCongr (Finset.univ.piAntidiag n) = Finset.HasAntidiagonal.antidiagonal n | null | true |
Finset.vadd.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : VAdd α β],
Finset.vadd = { vadd := Finset.image₂ fun x1 x2 => x1 +ᵥ x2 } | null | true |
RingEquiv.ofRingHom_apply | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (g : S →+* R)
(h₁ : f.comp g = RingHom.id S) (h₂ : g.comp f = RingHom.id R) (a : R), (RingEquiv.ofRingHom f g h₁ h₂) a = f a | null | true |
Fin.map_succEmb_Ico | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (i j : Fin n), Finset.map (Fin.succEmb n) (Finset.Ico i j) = Finset.Ico i.succ j.succ | null | true |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.ofNatLT | Lean.Compiler.LCNF.Simp.ConstantFold | (ℕ → Lean.Compiler.LCNF.LitValue) →
Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) →
Lean.Compiler.LCNF.Simp.ConstantFold.FolderM (Option (Lean.Compiler.LCNF.LetValue Lean.Compiler.LCNF.Purity.pure)) | Folder for `ofNatLT` operations on fixed-sized integer types. The bound is a proof and carries no
runtime content, so only the numeral matters.
| true |
CategoryTheory.Functor.mapGrp_obj_grp_one | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (A : CategoryTheory.Grp C),
Cat... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.not_sshiftRight._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {n : ℕ}, ∀ i < w, ¬0 < w → False | null | false |
CategoryTheory.Monad.PreservesColimitOfIsSplitPair.casesOn | Mathlib.CategoryTheory.Monad.Monadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{G : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Monad.PreservesColimitOfIsSplitPair G → Sort u} →
(t : CategoryTheory.Monad.PreservesColimit... | null | false |
Real.rpow_le_one | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x z : ℝ}, 0 ≤ x → x ≤ 1 → 0 ≤ z → x ^ z ≤ 1 | null | true |
LinearEquiv.restrictScalars_toLinearMap | Mathlib.Algebra.Module.Equiv.Basic | ∀ (R : Type u_1) {S : Type u_4} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module S M] [inst_7 : Module S M₂] [inst_8 : LinearMap.CompatibleSMul M M₂ R S] (f : M ≃ₗ[S] M₂),
↑... | null | true |
AddSubmonoid.topologicalClosure._proof_1 | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] [SeparatelyContinuousAdd M] (s : AddSubmonoid M)
{a b : M}, a ∈ closure ↑s → b ∈ closure ↑s → a + b ∈ closure ↑s | null | false |
QuaternionAlgebra.instMulAction._proof_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R}, Function.Injective ⇑(QuaternionAlgebra.equivProd c₁ c₂ c₃) | null | false |
Preord.Hom._mkInternal.injEq | Mathlib.Order.Category.Preord | ∀ {X Y : Preord} (hom' hom'_1 : ↑X →o ↑Y), ({ hom' := hom' } = { hom' := hom'_1 }) = (hom' = hom'_1) | null | false |
Representation.IntertwiningMap.instSub._proof_1 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_3} {G : Type u_4} [inst : Semiring A] [inst_1 : Monoid G] {V : Type u_1} {W : Type u_2}
[inst_2 : AddCommMonoid V] [inst_3 : AddCommGroup W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (f g : ρ.IntertwiningMap σ) (g_1 : G),
(f.toLinearMap - g.toL... | null | false |
AlgebraicGeometry.Scheme.Modules.pushforward_map_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} {M N : X.Modules} (f : X ⟶ Y) (φ : M ⟶ N) (U : Y.Opens),
AlgebraicGeometry.Scheme.Modules.Hom.app ((AlgebraicGeometry.Scheme.Modules.pushforward f).map φ) U =
AlgebraicGeometry.Scheme.Modules.Hom.app φ ((TopologicalSpace.Opens.map f.base).obj U) | null | true |
Array.toList_ofFnM | Init.Data.Array.OfFn | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Type u_1} [inst : Monad m] [LawfulMonad m] {f : Fin n → m α},
Array.toList <$> Array.ofFnM f = List.ofFnM f | null | true |
MeasureTheory.measureReal_eq_measureReal_larger_of_between_null_diff | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ s₃ : Set α},
s₁ ⊆ s₂ →
s₂ ⊆ s₃ →
μ.real (s₃ \ s₁) = 0 →
autoParam (μ (s₃ \ s₁) ≠ ⊤) MeasureTheory.measureReal_eq_measureReal_larger_of_between_null_sdiff._auto_1 →
μ.real s₂ = μ.real s₃ | **Alias** of `MeasureTheory.measureReal_eq_measureReal_larger_of_between_null_sdiff`. | true |
Finset.odd_sum_iff_odd_card_odd | Mathlib.Algebra.BigOperators.Ring.Nat | ∀ {ι : Type u_1} {s : Finset ι} (f : ι → ℕ), Odd (∑ i ∈ s, f i) ↔ Odd {x ∈ s | Odd (f x)}.card | null | true |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeUsingDefaultPrio.match_3 | Lean.Elab.SyntheticMVars | (motive : List (Lean.Name × ℕ) → Sort u_1) →
(__do_lift : List (Lean.Name × ℕ)) →
(Unit → motive []) → ((defaultInstances : List (Lean.Name × ℕ)) → motive defaultInstances) → motive __do_lift | null | false |
_private.ImportGraph.Shake.DeclNeeds.0.ImportGraph.Shake.instReprComptimeDependency.repr.match_1 | ImportGraph.Shake.DeclNeeds | (motive : ImportGraph.Shake.ComptimeDependency → Sort u_1) →
(x : ImportGraph.Shake.ComptimeDependency) →
((a : Lean.IndirectModUse) →
(a_1 : Array Lean.Name) → motive (ImportGraph.Shake.ComptimeDependency.indirect a a_1)) →
((a : Lean.SyntaxNodeKind) →
(a_1 : Option Lean.Syntax.Range) → m... | null | false |
Lean.Parser.Command.notationItem | Lean.Parser.Syntax | Lean.Parser.Parser | null | true |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.getRecommendedSpellingString.indentLine | Lean.Parser.Term.Doc | String → String | null | true |
Std.DTreeMap.Internal.Impl.minEntry?_eq_minEntry? | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {l : Std.DTreeMap.Internal.Impl α β},
l.Ordered → l.minEntry? = Std.Internal.List.minEntry? l.toListModel | null | true |
String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.instIteratorIdSearchStepOfBackwardPattern._proof_9 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) [inst : String.Slice.Pattern.BackwardPattern pat]
(it : Std.IterM Id (String.Slice.Pattern.SearchStep s)) (h : ¬it.internalState.currPos = s.startPos)
(pos : (s.sliceTo it.internalState.currPos).Pos),
String.Slice.Pattern.BackwardPattern.skipSuffixOfNonempty? pat (s.slice... | null | false |
Matrix.toRows₁_apply | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} (A : Matrix (m₁ ⊕ m₂) n R) (i : m₁) (j : n),
A.toRows₁ i j = A (Sum.inl i) j | null | true |
Ordering.compares_lt | Mathlib.Data.Ordering.Basic | ∀ {α : Type u_1} [inst : LT α] (a b : α), Ordering.lt.Compares a b = (a < b) | null | true |
ClosedSubmodule.toSubmodule_bot | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] [inst_4 : T1Space M], ↑⊥ = ⊥ | null | true |
Diffeology.dSmooth_iff | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : DiffeologicalSpace X] [inst_1 : DiffeologicalSpace Y] {f : X → Y},
Diffeology.DSmooth f ↔ ∀ (n : ℕ) (p : EuclideanSpace ℝ (Fin n) → X), Diffeology.IsPlot p → Diffeology.IsPlot (f ∘ p) | null | true |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.lcm_mul_left.match_1_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : StrongNormalizedGCDMonoid α] (a b c : α)
(motive : a ∣ lcm (a * b) (a * c) → Prop) (this : a ∣ lcm (a * b) (a * c)),
(∀ (w : α) (eq : lcm (a * b) (a * c) = a * w), motive ⋯) → motive this | null | false |
MeasureTheory.setLIntegral_le_iSup_mul | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal) {s : Set α},
MeasurableSet s → ∫⁻ (x : α) in s, f x ∂μ ≤ (⨆ x ∈ s, f x) * μ s | null | true |
_private.Std.Http.Data.Body.Full.0.Std.Http.Body.Full.State | Std.Http.Data.Body.Full | Type | null | true |
Lean.hasPPNoDotAttribute | Lean.PrettyPrinter.Delaborator.Attributes | Lean.Environment → Lean.Name → Bool | Returns whether or not the given declaration has the `@[pp_nodot]` attribute.
| true |
CategoryTheory.Abelian.SpectralObject.πE_d_ιE | Mathlib.Algebra.Homology.SpectralObject.Differentials | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (n₀ n... | null | true |
Set.Ioo._proof_3 | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), {x | b < x ∧ x < a} = {x | x < a ∧ b < x} | null | false |
CategoryTheory.LocalizerMorphism.localizedFunctor_isEquivalence | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {D₁ : Type u₄} {D₂ : Type u₅} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₄, u₄} D₁]
[inst_3 : CategoryTheory.Category.{v₅, u₅} D₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.Mor... | If a `LocalizerMorphism` is a localized equivalence, then the induced functor on
the localized categories is an equivalence | true |
Lean.Parser.Term.paren.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
HomologicalComplex.comp_f_assoc | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ C₃ : HomologicalComplex V c}
(f : C₁ ⟶ C₂) (g : C₂ ⟶ C₃) (i : ι) {Z : V} (h : C₃.X i ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.comp... | null | true |
NumberField.mixedEmbedding.convexBodyLTFactor.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.convexBodyLTFactor K = NumberField.mixedEmbedding.convexBodyLTFactor K | null | true |
Nonneg.commMonoidWithZero | Mathlib.Algebra.Order.Nonneg.Basic | {α : Type u_1} →
[inst : CommSemiring α] →
[inst_1 : PartialOrder α] → [ZeroLEOneClass α] → [AddLeftMono α] → [PosMulMono α] → CommMonoidWithZero (Nonneg α) | null | true |
Std.Iterators.HetT.operation | Std.Data.Iterators.Lemmas.Equivalence.HetT | {m : Type w → Type w'} →
{α : Type v} → (self : Std.Iterators.HetT m α) → m (Std.Internal.USquash (Subtype self.Property)) | The actual monadic operation. Its return value is bundled together with a proof that
it satisfies `Property` and squashed so that it fits into the monad `m`.
| true |
FreeCommRing.map | Mathlib.RingTheory.FreeCommRing | {α : Type u} → {β : Type v} → (α → β) → FreeCommRing α →+* FreeCommRing β | A map `f : α → β` produces a ring homomorphism `FreeCommRing α →+* FreeCommRing β`. | true |
Lean.instInhabitedImport.default | Lean.Setup | Lean.Import | null | true |
SymbolicDynamics.FullShift.Subshift.mk.noConfusion | Mathlib.Dynamics.SymbolicDynamics.Basic | {A : Type u_1} →
{inst : TopologicalSpace A} →
{G : Type u_2} →
{inst_1 : AddMonoid G} →
{P : Sort u} →
{carrier : Set (G → A)} →
{isClosed : IsClosed carrier} →
{mapsTo : ∀ (g : G), Set.MapsTo (SymbolicDynamics.FullShift.shift g) carrier carrier} →
... | null | false |
_private.Mathlib.SetTheory.Ordinal.Family.0.Ordinal.iSup_Iio_eq_bsup._simp_1_4 | Mathlib.SetTheory.Ordinal.Family | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | null | false |
Lean.Level.PP.Result.max | Lean.Level | Lean.Level.PP.Result → Lean.Level.PP.Result → Lean.Level.PP.Result | null | true |
String.instLinearOrder._proof_12 | Mathlib.Data.String.Basic | ∀ (a b : String), compare a b = compareOfLessAndEq a b | null | false |
Finset.powerset_empty | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1}, ∅.powerset = {∅} | null | true |
SimpleGraph.Iso.coe_comp | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {X : Type u_3} {G : SimpleGraph V} {G' : SimpleGraph W} {G'' : SimpleGraph X}
(f' : G' ≃g G'') (f : G ≃g G'), ⇑(f'.comp f) = ⇑f' ∘ ⇑f | null | true |
Std.TreeMap.Equiv.of_forall_getKey_eq_of_forall_constGet?_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
(∀ (k : α) (hk : k ∈ t₁) (hk' : k ∈ t₂), t₁.getKey k hk = t₂.getKey k hk') →
(∀ (k : α), t₁[k]? = t₂[k]?) → t₁.Equiv t₂ | null | true |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeSomeUsingDefaultPrio.visit._sparseCasesOn_1 | Lean.Elab.SyntheticMVars | {motive : Lean.Elab.Term.SyntheticMVarKind → Sort u} →
(t : Lean.Elab.Term.SyntheticMVarKind) →
((extraErrorMsg? : Option Lean.MessageData) → motive (Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg?)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
GeneralSchauderBasis.basis | Mathlib.Analysis.Normed.Module.Bases | {β : Type u_3} →
{𝕜 : Type u_4} →
{X : Type u_5} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup X] →
[inst_2 : NormedSpace 𝕜 X] → {L : SummationFilter β} → GeneralSchauderBasis β 𝕜 X L → β → X | The basis vectors. | true |
_private.Mathlib.SetTheory.Ordinal.Basic.0.Cardinal.isNormal_ord._simp_1_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | null | false |
Set.union_empty_iff | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ∪ t = ∅ ↔ s = ∅ ∧ t = ∅ | null | true |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.cmp.match_1.eq_4 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → PosNum → Sort u_1) (a b : PosNum) (h_1 : Unit → motive PosNum.one PosNum.one)
(h_2 : (x : PosNum) → motive x PosNum.one) (h_3 : (x : PosNum) → motive PosNum.one x)
(h_4 : (a b : PosNum) → motive a.bit0 b.bit0) (h_5 : (a b : PosNum) → motive a.bit0 b.bit1)
(h_6 : (a b : PosNum) → motive a.bit1... | null | true |
instAddGroupUniformFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup β],
instAddGroupUniformFun =
{ toAddMonoid := instAddMonoidUniformFun, toNeg := instNegUniformFun, toSub := instSubUniformFun,
toZSMul := ZSMul.ofSMul, sub_eq_add_neg := ⋯, zsmul_zero' := ⋯, zsmul_succ' := ⋯, zsmul_neg' := ⋯,
neg_add_cancel := ⋯ } | null | true |
ValuativeRel._aux_Mathlib_Topology_Algebra_Valued_ValuativeRel___unexpand_IsLocalRing_maximalIdeal_1 | Mathlib.Topology.Algebra.Valued.ValuativeRel | Lean.PrettyPrinter.Unexpander | null | false |
BotHom.instLattice._proof_3 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Bot α] [inst_1 : Lattice β] [inst_2 : OrderBot β] {x y : BotHom α β},
⇑y < ⇑x ↔ ⇑y < ⇑x | null | false |
isBigO_norm_restrict_cocompact | Mathlib.Analysis.Fourier.PoissonSummation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : C(ℝ, E)) {b : ℝ},
0 < b →
(⇑f =O[Filter.cocompact ℝ] fun x => |x| ^ (-b)) →
∀ (K : TopologicalSpace.Compacts ℝ),
(fun x => ‖ContinuousMap.restrict (↑K) (f.comp (ContinuousMap.addRight x))‖) =O[Filter.cocompact ℝ] fun x =>
|x| ^ (-b) | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_def'_assoc | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {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] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {x₁ y₁ : D} {x₂ y₂ : C} (f : x₁ ⟶ y₁) (g : x₂ ⟶ y₂)
{Z : D} (h : CategoryThe... | null | true |
Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData.ctorIdx | Lean.Elab.Tactic.Omega.Core | Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData → ℕ | null | false |
AddCommGroup.freeRank_eq_zero_of_finite | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : Finite G], AddCommGroup.freeRank G = 0 | null | true |
AddMonCat.ctorIdx | Mathlib.Algebra.Category.MonCat.Basic | AddMonCat → ℕ | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiffWithinAt_insert_self.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ (motive : WithTop ℕ∞ → Prop) (n : WithTop ℕ∞), (∀ (_ : Unit), motive none) → (∀ (n : ℕ∞), motive (some n)) → motive n | null | false |
Lean.instInhabitedModuleSetup | Lean.Setup | Inhabited Lean.ModuleSetup | null | true |
_private.Mathlib.RingTheory.PowerSeries.Restricted.0.PowerSeries.isRestricted_comp_uniqueEquiv._proof_1_1 | Mathlib.RingTheory.PowerSeries.Restricted | ∀ (t : Unit →₀ ℕ), (fun₀ | PUnit.unit => t PUnit.unit) = t | null | false |
Lean.Grind.Preorder.ne_of_gt | Init.Grind.Ordered.Order | ∀ {α : Type u} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] {a b : α}, a > 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.