name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MonoidHom.compLeftContinuousBounded_apply | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {β : Type v} {γ : Type w} (α : Type u_3) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
[inst_2 : Monoid β] [inst_3 : BoundedMul β] [inst_4 : ContinuousMul β] [inst_5 : PseudoMetricSpace γ]
[inst_6 : Monoid γ] [inst_7 : BoundedMul γ] [inst_8 : ContinuousMul γ] (g : β →* γ) {C : NNReal}
(hg : Lipschi... | null | true |
LinearOrderedAddCommMonoidWithTop.toIsOrderedAddMonoid | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_3} [self : LinearOrderedAddCommMonoidWithTop α], IsOrderedAddMonoid α | null | true |
IsAntichain.sperner | Mathlib.Combinatorics.SetFamily.LYM | ∀ {α : Type u_2} [inst : Fintype α] {𝒜 : Finset (Finset α)},
IsAntichain (fun x1 x2 => x1 ⊆ x2) ↑𝒜 → 𝒜.card ≤ (Fintype.card α).choose (Fintype.card α / 2) | **Sperner's theorem**. The size of an antichain in `Finset α` is bounded by the size of the
maximal layer in `Finset α`. This precisely means that `Finset α` is a Sperner order. | true |
Batteries.BinomialHeap.Imp.FindMin.WF.casesOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{le : α → α → Bool} →
{res : Batteries.BinomialHeap.Imp.FindMin α} →
{motive : Batteries.BinomialHeap.Imp.FindMin.WF le res → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin.WF le res) →
((rank : ℕ) →
(before :
∀ {s : Batteries.BinomialHea... | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.angle_eq_angle_add_angle_iff._proof_1_2 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x z : V},
¬InnerProductGeometry.angle x z = Real.pi →
¬InnerProductGeometry.angle x z = 0 → ¬Real.sin (InnerProductGeometry.angle x z) = 0 | null | false |
Std.Iterators.Types.TakeWhile.PlausibleStep.recOn | Std.Data.Iterators.Combinators.Monadic.TakeWhile | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} [inst : Std.Iterator α m β]
{P : β → Std.Iterators.PostconditionT m (ULift.{w, 0} Bool)} {it : Std.IterM m β}
{motive : (step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.TakeWhile.PlausibleStep it step → Prop}
{step : Std.IterStep (Std.IterM m β) β} (... | null | false |
CategoryTheory.uliftFunctor | Mathlib.CategoryTheory.Types.Basic | CategoryTheory.Functor (Type u) (Type (max u v)) | The functor embedding `Type u` into `Type (max u v)`.
Write this as `uliftFunctor.{5, 2}` to get `Type 2 ⥤ Type 5`.
| true |
CategoryTheory.Limits.Types.chosenEnd_def | Mathlib.CategoryTheory.Limits.Types.End | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J]
{F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J (Type (max w u)))},
CategoryTheory.Limits.chosenEnd F = CategoryTheory.Limits.Types.end_ F | null | true |
Rep.standardComplex.forget₂ToModuleCat | Mathlib.RepresentationTheory.Homological.Resolution | (k G : Type u) → [inst : CommRing k] → [Monoid G] → HomologicalComplex (ModuleCat k) (ComplexShape.down ℕ) | The standard resolution of `k` as a trivial representation as a complex of `k`-modules. | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Additive.0.Option.elim'.match_1.eq_2 | Mathlib.Analysis.BoxIntegral.Partition.Additive | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : (a : α) → motive (some a)) (h_2 : Unit → motive none),
(match none with
| some a => h_1 a
| none => h_2 ()) =
h_2 () | null | true |
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD_eq_getD_entryAtIdx? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} {i : ℕ} {fallback : α × β},
Std.DTreeMap.Internal.Impl.Const.entryAtIdxD t i fallback =
(Std.DTreeMap.Internal.Impl.Const.entryAtIdx? t i).getD fallback | null | true |
Int64.le_minValue_iff | Init.Data.SInt.Lemmas | ∀ {a : Int64}, a ≤ Int64.minValue ↔ a = Int64.minValue | null | true |
TensorProduct.instInner | Mathlib.Analysis.InnerProductSpace.TensorProduct | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] → [inst_4 : InnerProductSpace 𝕜 F] → Inner 𝕜 (TensorProduct 𝕜 E F) | null | true |
Mathlib.Tactic.Choose.mkSometimes | Mathlib.Tactic.Choose | Lean.Level →
Lean.Expr → Lean.Expr → Lean.Expr → List Lean.Expr → Lean.Expr × Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr) | Given `α : Sort u`, `nonemp : Nonempty α`, `p : α → Prop`, a context of free variables
`ctx`, and a pair of an element `val : α` and `spec : p val`,
`mkSometimes u α nonemp p ctx (val, spec)` produces another pair `val', spec'`
such that `val'` does not have any free variables from elements of `ctx` whose types are
pro... | true |
LieModule.Weight.equivSetOfPred._proof_3 | Mathlib.Algebra.Lie.Weights.Basic | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] (w : ↑{χ | LieModule.genWeightSpace M χ ≠ ⊥}),
↑w ∈ {χ | LieMod... | null | false |
_private.Lean.Meta.Sym.Arith.Poly.0.Lean.Grind.CommRing.Mon.toExpr.go._f | Lean.Meta.Sym.Arith.Poly | (m : Lean.Grind.CommRing.Mon) →
Lean.Grind.CommRing.Mon.below (motive := fun m => Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr) m →
Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr | null | false |
Nat.le.below.refl | Init.Prelude | ∀ {n : ℕ} {motive : (a : ℕ) → n.le a → Prop}, Nat.le.below ⋯ | null | true |
Batteries.PairingHeapImp.Heap.foldTreeM._unsafe_rec | Batteries.Data.PairingHeap | {m : Type u_1 → Type u_2} →
{β : Type u_1} → {α : Type u_3} → [Monad m] → β → (α → β → β → m β) → Batteries.PairingHeapImp.Heap α → m β | null | false |
Mathlib.Linter.TextBased.UnicodeLinter.replaceDisallowed | Mathlib.Tactic.Linter.TextBased.UnicodeLinter | Char → Option String | Provide default replacement (`String`) for a disallowed character, or `none` if none defined | true |
_private.Mathlib.NumberTheory.Divisors.0.Nat.filter_dvd_eq_properDivisors._simp_1_5 | Mathlib.NumberTheory.Divisors | ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c → (a ↔ b)) | null | false |
invMonoidHom.eq_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α], invMonoidHom = { toFun := Inv.inv, map_one' := ⋯, map_mul' := ⋯ } | null | true |
_private.Mathlib.Data.Nat.Prime.Defs.0.Nat.prime_iff_not_exists_mul_eq._simp_1_6 | Mathlib.Data.Nat.Prime.Defs | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
LeanSearchClient.LoogleResult.recOn | LeanSearchClient.LoogleSyntax | {motive : LeanSearchClient.LoogleResult → Sort u} →
(t : LeanSearchClient.LoogleResult) →
motive LeanSearchClient.LoogleResult.empty →
((a : Array LeanSearchClient.SearchResult) → motive (LeanSearchClient.LoogleResult.success a)) →
((error : String) →
(suggestions : Option (List String))... | null | false |
Std.Tactic.BVDecide.BVPred.rec | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : Std.Tactic.BVDecide.BVPred → Sort u} →
({w : ℕ} →
(lhs : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tactic.BVDecide.BVBinPred) →
(rhs : Std.Tactic.BVDecide.BVExpr w) → motive (Std.Tactic.BVDecide.BVPred.bin lhs op rhs)) →
({w : ℕ} →
(expr : Std.Tactic.BVDecide.BVExpr w) → ... | null | false |
Topology.IsUpperSet.topology_eq_upperSetTopology | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_4} {t : TopologicalSpace α} {inst : Preorder α} [self : Topology.IsUpperSet α], t = Topology.upperSet α | null | true |
_private.Init.Data.UInt.Lemmas.0.USize.pos_iff_ne_zero._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Vector.back? | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → Option α | The last element of a vector, or `none` if the vector is empty. | true |
Units.val_le_val._simp_2 | Mathlib.Algebra.Order.Monoid.Units | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Preorder α] {a b : αˣ}, (↑a ≤ ↑b) = (a ≤ b) | null | false |
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.merge._sparseCasesOn_1 | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} →
(t : Lean.Compiler.LCNF.UnreachableBranches.Value) →
motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.bot →
motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.top →
((vs : List Lean.Compiler.LCNF.UnreachableBranches.Value) ... | null | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.VarInfo.mk._flat_ctor | Lean.Compiler.LCNF.ExplicitRC | Bool → Bool → Bool → ℕ → Option Lean.Compiler.LCNF.CtorInfo → Lean.Compiler.LCNF.VarInfo✝ | null | false |
Int.le_emod_self_add_one_iff | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 < b → (b ≤ a % b + 1 ↔ b ∣ a + 1) | null | true |
CategoryTheory.MonoidalCategory.IsPushout.whiskerLeft_w | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {Z X Y P : C}
{f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P} {inr : Y ⟶ P},
CategoryTheory.IsPushout f g inl inr →
∀ {Q : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Q... | null | true |
Topology.instIsLowerSet | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α], Topology.IsLowerSet α | null | true |
_private.Mathlib.Analysis.Distribution.Distribution.0.Distribution.ofFun_smul._proof_1_1 | Mathlib.Analysis.Distribution.Distribution | ∀ {F : Type u_1} [inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F], SMulCommClass ℝ ℝ F | null | false |
_private.Mathlib.Topology.Algebra.ValuativeRel.Completion.0.Valuation.closure_image_coe_le._simp_1_2 | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {K : Type u_2} {Γ₀ : Type u_3} [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K]
[inst_3 : IsValuativeTopology K] [inst_4 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation K Γ₀)
[inst_5 : v.Compatible] [inst_6 : IsUniformAddGroup K] {x y : UniformSpace.Completion K},
(v.extension x ≤ v.exte... | null | false |
StandardEtalePair.instCommRingRing._aux_8 | Mathlib.RingTheory.Etale.StandardEtale | {R : Type u_1} → [inst : CommRing R] → (P : StandardEtalePair R) → ℕ → P.Ring → P.Ring | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate.0.PartialOrder.mem_nerve_nonDegenerate_iff_strictMono._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialSet.NerveNondegenerate | ∀ {X : Type u_1} [inst : PartialOrder X] {n : ℕ} (s : (CategoryTheory.nerve X).obj (Opposite.op { len := n + 1 }))
(i : Fin (n + 1)),
(s ∈
Set.range ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve X) i))) =
(s.obj i.castSucc = s.obj i.succ) | null | false |
Nat.iSup_le_succ | Mathlib.Order.Lattice.Nat | ∀ {α : Type u_1} [inst : CompleteLattice α] (u : ℕ → α) (n : ℕ),
⨆ k, ⨆ (_ : k ≤ n + 1), u k = (⨆ k, ⨆ (_ : k ≤ n), u k) ⊔ u (n + 1) | null | true |
ContinuousMap.compMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : MulOneClass γ] (g : C(α, β)), ContinuousMap.comp 1 g = 1 | null | false |
CategoryTheory.Pseudofunctor.ObjectProperty.ι | Mathlib.CategoryTheory.Bicategory.Functor.Cat.ObjectProperty | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat} →
(P : F.ObjectProperty) → [inst_1 : P.IsClosedUnderMapObj] → P.fullsubcategory.StrongTrans F | The inclusion of `P.fullsubcategory` in `F`. | true |
Order.exists_series_of_le_coheight | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] (a : α) {n : ℕ}, ↑n ≤ Order.coheight a → ∃ p, RelSeries.head p = a ∧ p.length = n | null | true |
Mathlib.Tactic.Bicategory.evalWhiskerRight_cons_of_of | Mathlib.Tactic.CategoryTheory.Bicategory.Normalize | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f g h i : a ⟶ b} {j : b ⟶ c} {α : f ≅ g} {η : g ⟶ h}
{ηs : h ⟶ i} {ηs₁ : CategoryTheory.CategoryStruct.comp h j ⟶ CategoryTheory.CategoryStruct.comp i j}
{η₁ : CategoryTheory.CategoryStruct.comp g j ⟶ CategoryTheory.CategoryStruct.comp h j}
{η₂ : Ca... | null | true |
MeasureTheory.tendsto_of_uncrossing_lt_top | Mathlib.Probability.Martingale.Convergence | ∀ {Ω : Type u_1} {f : ℕ → Ω → ℝ} {ω : Ω},
Filter.liminf (fun n => ↑‖f n ω‖₊) Filter.atTop < ⊤ →
(∀ (a b : ℚ), a < b → MeasureTheory.upcrossings (↑a) (↑b) f ω < ⊤) →
∃ c, Filter.Tendsto (fun n => f n ω) Filter.atTop (nhds c) | **Alias** of `MeasureTheory.tendsto_of_upcrossings_lt_top`.
---
A realization of a stochastic process with bounded upcrossings and bounded limit inferiors is
convergent.
We use the spelling `< ∞` instead of the standard `≠ ∞` in the assumptions since it is not as easy
to change `<` to `≠` under binders. | true |
Mathlib.Tactic.RingNF.RingMode.recOn | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} →
(t : Mathlib.Tactic.RingNF.RingMode) →
motive Mathlib.Tactic.RingNF.RingMode.SOP → motive Mathlib.Tactic.RingNF.RingMode.raw → motive t | null | false |
Algebra.Generators.toExtendScalars._proof_2 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_4} {S : Type u_3} {ι : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T]
(P : Algebra.Generators R T ι) (i : ι),
(MvPolynomial.aeval (Algebra.Generators.extendSc... | null | false |
Polynomial.natDegree_pow_X_add_C | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] [Nontrivial R] (n : ℕ) (r : R), ((Polynomial.X + Polynomial.C r) ^ n).natDegree = n | null | true |
Substring.Raw.ValidFor.isEmpty | Batteries.Data.String.Lemmas | ∀ {l m r : List Char} {s : Substring.Raw}, Substring.Raw.ValidFor l m r s → (s.isEmpty = true ↔ m = []) | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.step_intermediateZip.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ {α₁ β₁ : Type u_1} [inst : Std.Iterator α₁ Id β₁] {it₁ : Std.Iter β₁} (motive : it₁.Step → Sort u_2)
(it₁' : Std.Iter β₁) (hp : it₁.IsPlausibleStep (Std.IterStep.skip it₁'))
(h_1 :
(it₁' : Std.Iter β₁) →
(out : β₁) → (hp : it₁.IsPlausibleStep (Std.IterStep.yield it₁' out)) → motive ⟨Std.IterStep.yield i... | null | true |
PFun.prodMap_id_id | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2}, (PFun.id α).prodMap (PFun.id β) = PFun.id (α × β) | null | true |
ModularForm.mk.noConfusion | Mathlib.NumberTheory.ModularForms.Basic | {Γ : Subgroup (GL (Fin 2) ℝ)} →
{k : ℤ} →
{P : Sort u} →
{toSlashInvariantForm : SlashInvariantForm Γ k} →
{holo' : MDiff ⇑toSlashInvariantForm} →
{bdd_at_cusps' : ∀ {c : OnePoint ℝ}, IsCusp c Γ → c.IsBoundedAt toSlashInvariantForm.toFun k} →
{toSlashInvariantForm' : SlashInvar... | null | false |
Fin.foldr_congr | Init.Data.Fin.Fold | ∀ {α : Sort u_1} {n k : ℕ} (w : n = k) (f : Fin n → α → α), Fin.foldr n f = Fin.foldr k fun i => f (Fin.cast ⋯ i) | null | true |
topologicalGroup_of_lieGroup | Mathlib.Geometry.Manifold.Algebra.LieGroup | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] (I : ModelWithCorners 𝕜 E H) (n : WithTop ℕ∞)
{G : Type u_4} [inst_4 : TopologicalSpace G] [inst_5 : ChartedSpace H G] [inst_6 : Group G] [Li... | A Lie group is a topological group. This is not an instance for technical reasons,
see note [Design choices about smooth algebraic structures]. | true |
_private.Mathlib.Data.Finset.Prod.0.Finset.subset_product_image_fst._simp_1_1 | Mathlib.Data.Finset.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {b : β},
(b ∈ Finset.image f s) = ∃ a ∈ s, f a = b | null | false |
Finset.prod_bij' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [inst : CommMonoid M] {s : Finset ι} {t : Finset κ} {f : ι → M}
{g : κ → M} (i : (a : ι) → a ∈ s → κ) (j : (a : κ) → a ∈ t → ι) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t)
(hj : ∀ (a : κ) (ha : a ∈ t), j a ha ∈ s),
(∀ (a : ι) (ha : a ∈ s), j (i a ha) ⋯ = a) →
(∀ (a... | Reorder a product.
The difference with `Finset.prod_bij` is that the bijection is specified with an inverse, rather
than as a surjective injection.
The difference with `Finset.prod_nbij'` is that the bijection and its inverse are allowed to use
membership of the domains of the products, rather than being non-dependen... | true |
Lean.Lsp.DependencyBuildMode._sizeOf_inst | Lean.Data.Lsp.Extra | SizeOf Lean.Lsp.DependencyBuildMode | null | false |
CategoryTheory.Limits.Trident.ι | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : J → (X ⟶ Y)} →
(t : CategoryTheory.Limits.Trident f) →
((CategoryTheory.Functor.const (CategoryTheory.Limits.WalkingParallelFamily J)).obj t.pt).obj
CategoryTheory.Limits.... | A trident `t` on the parallel family `f : J → (X ⟶ Y)` consists of two morphisms
`t.π.app zero : t.X ⟶ X` and `t.π.app one : t.X ⟶ Y`. Of these, only the first one is
interesting, and we give it the shorter name `Trident.ι t`. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_mul_toInt_lt_neg_two_pow_iff._proof_1_8 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
((w + 1) * 2 - 2 < (w + 1) * 2 - 1 → 2 ^ ((w + 1) * 2 - 2) < 2 ^ ((w + 1) * 2 - 1)) →
x.toInt * y.toInt ≤ 2 ^ ((w + 1) * 2 - 2) → ¬x.toInt * y.toInt * 2 < 2 ^ ((w + 1) * 2 - 1) * 2 → False | null | false |
AlgebraicGeometry.Scheme.OpenCover.finiteSubcover_X | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [H : CompactSpace ↥X] (x : ↥⋯.choose),
𝒰.finiteSubcover.X x = 𝒰.X (AlgebraicGeometry.Scheme.Cover.idx 𝒰 ↑x) | null | true |
DirectLimit.NonUnitalRing.lift_of | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{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 : (i : ι) → NonUnitalNonA... | null | true |
Multiset.countP_congr | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {s s' : Multiset α},
s = s' →
∀ {p p' : α → Prop} [inst : DecidablePred p] [inst_1 : DecidablePred p'],
(∀ x ∈ s, p x = p' x) → Multiset.countP p s = Multiset.countP p' s' | null | true |
instToStringFloat32 | Init.Data.Float.Float32 | ToString Float32 | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput.lhs | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} → Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.ShiftConcatInput aig len → aig.RefVec len | null | true |
Lean.Server.RequestHandler._sizeOf_inst | Lean.Server.Requests | SizeOf Lean.Server.RequestHandler | null | false |
BddOrd.instConcreteCategoryBoundedOrderHomCarrier._proof_2 | Mathlib.Order.Category.BddOrd | ∀ {X Y : BddOrd} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
Set.coe_snd_biUnionEqSigmaOfDisjoint | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_5} {ι : Type u_6} {s : Set ι} {f : ι → Set α} (h : s.PairwiseDisjoint f) (x : ↑(⋃ i ∈ s, f i)),
↑((Set.biUnionEqSigmaOfDisjoint h) x).snd = ↑x | null | true |
Quaternion.instNormedAddCommGroupReal._proof_3 | Mathlib.Analysis.Quaternion | ∀ (x y : Quaternion ℝ) (r : ℝ), inner ℝ (r • x) y = (starRingEnd ℝ) r * inner ℝ x y | null | false |
Aesop.TraceOption.mk.noConfusion | Aesop.Tracing | {P : Sort u} →
{traceClass : Lean.Name} →
{option : Lean.Option Bool} →
{traceClass' : Lean.Name} →
{option' : Lean.Option Bool} →
{ traceClass := traceClass, option := option } = { traceClass := traceClass', option := option' } →
(traceClass = traceClass' → option = option' → ... | null | false |
_private.Mathlib.Topology.Order.LowerUpperTopology.0.Topology.lower_inf_upper_eq_preorderTopology._simp_1_2 | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
MvPolynomial.killCompl_monomial_eq_monomial_comapDomain_of_subset | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {f : σ → τ} (hf : Function.Injective f)
{s : τ →₀ ℕ} (c : R),
↑s.support ⊆ Set.range f →
(MvPolynomial.killCompl hf) ((MvPolynomial.monomial s) c) = (MvPolynomial.monomial (Finsupp.comapDomain f s ⋯)) c | null | true |
CategoryTheory.Functor.Elements.initialOfCorepresentableBy | Mathlib.CategoryTheory.Elements | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C (Type u_1)} → {X : C} → F.CorepresentableBy X → F.Elements | The initial object in `F.Elements` if `F` is corepresentable. | true |
torusMap_zero_radius | Mathlib.MeasureTheory.Integral.TorusIntegral | ∀ {n : ℕ} (c : Fin n → ℂ), torusMap c 0 = Function.const (Fin n → ℝ) c | null | true |
Ordinal.inductionOnWellOrder | Mathlib.SetTheory.Ordinal.Basic | ∀ {motive : Ordinal.{u_1} → Prop} (o : Ordinal.{u_1}),
(∀ (α : Type u_1) [inst : LinearOrder α] [inst_1 : WellFoundedLT α], motive (Ordinal.type fun x1 x2 => x1 < x2)) →
motive o | To prove a result on ordinals, it suffices to prove it for order types of well-orders. | true |
MeasureTheory.MemLp.exists_boundedContinuous_integral_rpow_sub_le | Mathlib.MeasureTheory.Function.ContinuousMapDense | ∀ {α : Type u_1} [inst : TopologicalSpace α] [NormalSpace α] [inst_2 : MeasurableSpace α] [BorelSpace α] {E : Type u_2}
[inst_4 : NormedAddCommGroup E] {μ : MeasureTheory.Measure α} [NormedSpace ℝ E] [μ.WeaklyRegular] {p : ℝ},
0 < p →
∀ {f : α → E},
MeasureTheory.MemLp f (ENNReal.ofReal p) μ →
∀ {... | Any function in `ℒp` can be approximated by bounded continuous functions when `0 < p < ∞`,
version in terms of `∫`. | true |
ContinuousOpenMap._sizeOf_inst | Mathlib.Topology.Hom.Open | (α : Type u_6) →
(β : Type u_7) →
{inst : TopologicalSpace α} → {inst_1 : TopologicalSpace β} → [SizeOf α] → [SizeOf β] → SizeOf (α →CO β) | null | false |
indicator_ae_eq_zero_of_restrict_ae_eq_zero | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α} {f : α → β}
[inst_1 : Zero β], MeasurableSet s → f =ᵐ[μ.restrict s] 0 → s.indicator f =ᵐ[μ] 0 | null | true |
AlgebraicGeometry.pointEquivClosedPoint._proof_4 | Mathlib.AlgebraicGeometry.AlgClosed.Basic | ∀ {X : AlgebraicGeometry.Scheme} {K : Type u_1} [inst : Field K] [inst_1 : IsAlgClosed K]
(f : X ⟶ AlgebraicGeometry.Spec ↧K) [inst_2 : AlgebraicGeometry.LocallyOfFiniteType f] (x : ↑(closedPoints ↥X)),
(fun p => ⟨↑p (IsLocalRing.closedPoint K), ⋯⟩) ((fun x => ⟨AlgebraicGeometry.pointOfClosedPoint f ↑x ⋯, ⋯⟩) x) = ... | null | false |
_private.Mathlib.CategoryTheory.Abelian.SerreClass.Localization.0.CategoryTheory.ObjectProperty.SerreClassLocalization.preservesFiniteLimits._proof_1_1 | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | 4 ≠ 0 | null | false |
CategoryTheory.CommMon.X | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → C | The underlying object in the ambient monoidal category | true |
CategoryTheory.Limits.WalkingMulticospan.ctorElim | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u} →
(ctorIdx : ℕ) →
(t : CategoryTheory.Limits.WalkingMulticospan J) →
ctorIdx = t.ctorIdx → CategoryTheory.Limits.WalkingMulticospan.ctorElimType ctorIdx → motive t | null | false |
Lean.Doc.Block.brecOn_7 | 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 |
AddMonoidAlgebra.single_mem_grade | Mathlib.Algebra.MonoidAlgebra.Grading | ∀ {M : Type u_1} {R : Type u_4} [inst : CommSemiring R] (i : M) (r : R),
AddMonoidAlgebra.single i r ∈ AddMonoidAlgebra.grade R i | null | true |
Cardinal.SharplyLT.isCardinalAccessibleCategory | Mathlib.CategoryTheory.Presentable.SharplyLT.Basic | ∀ {κ₁ κ₂ : Cardinal.{w}} [inst : Fact κ₁.IsRegular] [inst_1 : Fact κ₂.IsRegular],
κ₁.SharplyLT κ₂ →
∀ (C : Type u) [inst_2 : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCardinalAccessibleCategory C κ₁],
CategoryTheory.IsCardinalAccessibleCategory C κ₂ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.entryAtIdx_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
MeasureTheory.LocallyIntegrable.mono_measure._gcongr_1 | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {ε : Type u_3} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : X → ε} {μ ν : MeasureTheory.Measure X},
ν ≤ μ → MeasureTheory.LocallyIntegrable f μ → MeasureTheory.LocallyIntegrable f ν | null | false |
TopCat.instAbelianPresheaf._proof_4 | Mathlib.Topology.Sheaves.Abelian | ∀ {X : TopCat} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Abelian C],
autoParam
(∀ (P Q R : TopCat.Presheaf C X) (f : P ⟶ Q) (g g' : Q ⟶ R),
CategoryTheory.CategoryStruct.comp f (g + g') =
CategoryTheory.CategoryStruct.comp f g + CategoryTheory.CategoryStru... | null | false |
Equiv.invFun | Mathlib.Logic.Equiv.Defs | {α : Sort u_1} → {β : Sort u_2} → α ≃ β → β → α | The backward map of an equivalence.
Do NOT use `e.invFun` directly. Use the coercion of `e.symm` instead. | true |
Mathlib.TacticAnalysis.Pass._sizeOf_inst | Mathlib.Tactic.TacticAnalysis | SizeOf Mathlib.TacticAnalysis.Pass | null | false |
Matrix.vecMul_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {n' : Type uₙ} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Fintype n'] (v : n' → α)
(B : Matrix n' (Fin 0) α), Matrix.vecMul v B = ![] | null | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_24 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l : List α} (hl : l ≠ []),
l.length - (l.dropLast.length + 1) + 1 ≤ [l.getLast ⋯].dropLast.length →
l.length - (l.dropLast.length + 1) < [l.getLast ⋯].dropLast.length | null | false |
NumberField.basisOfFractionalIdeal._proof_2 | Mathlib.NumberTheory.NumberField.FractionalIdeal | ∀ (K : Type u_1) [inst : Field K] (I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
LinearMap.CompatibleSMul (↥↑↑I) K ℤ (NumberField.RingOfIntegers K) | null | false |
AddUnits.leftOfAdd.eq_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (u : AddUnits M) (a b : M) (hu : a + b = ↑u) (hc : AddCommute a b),
u.leftOfAdd a b hu hc = { val := a, neg := b + ↑(-u), val_neg := ⋯, neg_val := ⋯ } | null | true |
_private.Mathlib.Tactic.Widget.Calc.0.suggestSteps.match_22 | Mathlib.Tactic.Widget.Calc | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((rel lhs rhs : Lean.Expr) → motive (some (rel, lhs, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive __x | null | false |
Subring.instField._proof_13 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (x : ℚ≥0) (x_1 : ↥(Subring.center K)), ↑x * x_1 = ↑x * x_1 | null | false |
List.prod_inv_reverse | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : Group G] (L : List G), L.prod⁻¹ = (List.map (fun x => x⁻¹) L).reverse.prod | This is the `List.prod` version of `mul_inv_rev` | true |
Equiv.prodAssoc.match_3 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_1) (β : Type u_3) (γ : Type u_2) (motive : α × β × γ → Prop) (x : α × β × γ),
(∀ (fst : α) (fst_1 : β) (snd : γ), motive (fst, fst_1, snd)) → motive x | null | false |
NumberField.finite_setOfPred_mulHeight_nat_le | Mathlib.NumberTheory.Height.NumberField | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] {n : ℕ},
n ≠ 0 → ∀ (B : ℝ), {a | Height.mulHeight ![↑a, ↑n] ≤ B}.Finite | The set of `a : 𝓞 K` such that `mulHeight₁ (a / n) = mulHeight ![a, n]` is bounded
(for some given nonzero `n : ℕ`) is finite. | true |
Lean.Meta.Sym.Arith.ClassifyResult.commRing | Lean.Meta.Sym.Arith.Types | ℕ → Lean.Meta.Sym.Arith.ClassifyResult | null | true |
Ordinal.CNF.rec_pos | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (b : Ordinal.{u_2}) {o : Ordinal.{u_2}} {C : Ordinal.{u_2} → Sort u_1} (ho : o ≠ 0) (H0 : C 0)
(H : (o : Ordinal.{u_2}) → o ≠ 0 → C (o % b ^ Ordinal.log b o) → C o),
Ordinal.CNF.rec b H0 H o = H o ho (Ordinal.CNF.rec b H0 H (o % b ^ Ordinal.log b o)) | null | true |
Bundle.TotalSpace.toProd._proof_1 | Mathlib.Data.Bundle | ∀ (B : Type u_1) (F : Type u_2), Function.LeftInverse (fun x => ⟨x.1, x.2⟩) fun x => (x.proj, x.snd) | null | false |
Affine.Simplex.isCompact_closedInterior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_3} {V : Type u_4} {P : Type u_5} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : TopologicalSpace 𝕜] [OrderClosedTopology 𝕜] [CompactIccSpace 𝕜] [IsTopologicalRing 𝕜]
[inst_7 : AddCommGroup V] [inst_8 : TopologicalSpace V] [IsTopologicalAddGroup V] [inst_10 : Module... | The closed interior of a simplex is compact. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.