name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Multiset.powerset._proof_1 | Mathlib.Data.Multiset.Powerset | ∀ {α : Type u_1} (x x_1 : List α),
(List.isSetoid α) x x_1 →
Quot.mk (⇑(List.isSetoid (Multiset α))) (Multiset.powersetAux x) =
Quot.mk (⇑(List.isSetoid (Multiset α))) (Multiset.powersetAux x_1) | null | false |
CategoryTheory.Limits.HasCountableCoproducts.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Countable | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Limits.HasCountableCoproducts C → Sort u} →
(t : CategoryTheory.Limits.HasCountableCoproducts C) →
((out : ∀ (J : Type) [Countable J], CategoryTheory.Limits.HasCoproductsOfShape J C) → motive ⋯) → motive t | null | false |
_private.Mathlib.Geometry.Manifold.Instances.Real.0.modelWithCornersEuclideanHalfSpace._simp_6 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (𝕜 : Type u_3) [h : RCLike 𝕜], IsRCLikeNormedField 𝕜 = True | null | false |
ZFSet.Insert.match_5 | Mathlib.SetTheory.ZFC.Basic | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (A_1 : α_1 → PSet.{u_1}) (b : (PSet.mk α_1 A_1).Type)
(motive : (∃ a, (A a).Equiv (A_1 b)) → Prop) (x : ∃ a, (A a).Equiv (A_1 b)),
(∀ (a : α) (ha : (A a).Equiv (A_1 b)), motive ⋯) → motive x | null | false |
List.Sublist.flatMap | Mathlib.Data.List.Flatten | ∀ {α : Type u_1} {β : Type u_2} {l₁ l₂ : List α},
l₁.Sublist l₂ → ∀ (f : α → List β), (List.flatMap f l₁).Sublist (List.flatMap f l₂) | null | true |
TrivSqZeroExt.invertibleFstOfInvertible._proof_2 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : AddCommGroup M] [inst_1 : Semiring R] [inst_2 : Module Rᵐᵒᵖ M]
[inst_3 : Module R M] (x : TrivSqZeroExt R M) [inst_4 : Invertible x], x.fst * (⅟x).fst = 1 | null | false |
Ring.zsmul | Mathlib.Algebra.Ring.Defs | {R : Type u} → [self : Ring R] → ℤ → R → R | Multiplication by an integer.
Set this to `zsmulRec` unless `Module` diamonds are possible. | true |
PNat.natPred_eq_pred | Mathlib.Data.PNat.Defs | ∀ {n : ℕ} (h : 0 < n), PNat.natPred ⟨n, h⟩ = n.pred | null | true |
List.modify_succ_cons | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (a : α) (l : List α) (i : ℕ), (a :: l).modify (i + 1) f = a :: l.modify i f | null | true |
MeasureTheory.StronglyAdapted.progMeasurable_of_continuous | Mathlib.Probability.Process.Adapted | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} [inst : Preorder ι] {f : MeasureTheory.Filtration ι m}
{β : Type u_3} [inst_1 : TopologicalSpace β] {u : ι → Ω → β} [inst_2 : TopologicalSpace ι]
[TopologicalSpace.MetrizableSpace ι] [SecondCountableTopology ι] [inst_5 : MeasurableSpace ι] [OpensMeasurableSpac... | **Alias** of `MeasureTheory.StronglyAdapted.isStronglyProgressive_of_continuous`.
---
A continuous and strongly adapted process is strongly progressive. | true |
Equiv.simpleGraph | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → {W : Type u_2} → V ≃ W → SimpleGraph V ≃ SimpleGraph W | Equivalent types have equivalent simple graphs. | true |
Finset.card_le_of_interleaved | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {s t : Finset α},
(∀ x ∈ s, ∀ y ∈ s, x < y → (∀ z ∈ s, z ∉ Set.Ioo x y) → ∃ z ∈ t, x < z ∧ z < y) → s.card ≤ t.card + 1 | If finsets `s` and `t` are interleaved, then `Finset.card s ≤ Finset.card t + 1`. | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope.0.IntervalIntegrable.intervalIntegrable_slope._proof_1_3 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Slope | ∀ {a b c : ℝ}, a ≤ b → 0 ≤ c → Set.uIcc a b ⊆ Set.uIcc a (b + c) | null | false |
Std.Internal.List.minKey!_insertEntryIfNew_le_minKey! | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {k : α} {v : β k},
(compare (Std.Internal.List.minKey! (Std.Internal.List.insertEntryIfN... | null | true |
DyckWord.toTree | Mathlib.Combinatorics.Enumerative.DyckWord | DyckWord → BinaryTree Unit | Convert a Dyck word to a binary rooted tree.
`f(0) = nil`. For a nonzero word find the `D` that matches the initial `U`,
which has index `p.firstReturn`, then let `x` be everything strictly between said `U` and `D`,
and `y` be everything strictly after said `D`. `p = x.nest + y` with `x, y` (possibly empty)
Dyck words... | true |
QuadraticAlgebra.instNonUnitalNonAssocSemiring | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} → {a b : R} → [NonUnitalNonAssocSemiring R] → NonUnitalNonAssocSemiring (QuadraticAlgebra R a b) | null | true |
AddEquiv.ext | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N] {f g : M ≃+ N}, (∀ (x : M), f x = g x) → f = g | Two additive isomorphisms agree if they are defined by the same underlying function. | true |
CompactlySupportedContinuousMap.smulc_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : Zero β] [inst_3 : TopologicalSpace γ] [inst_4 : SMulZeroClass γ β] [inst_5 : ContinuousSMul γ β]
{F : Type u_5} [inst_6 : FunLike F α γ] [inst_7 : ContinuousMapClass F α γ] (f : F)
(g : CompactlySupp... | null | true |
Lean.Meta.Grind.SplitInfo.arg | Lean.Meta.Tactic.Grind.Types | Lean.Expr → Lean.Expr → ℕ → Lean.Expr → Lean.Meta.Grind.SplitSource → Lean.Meta.Grind.SplitInfo | Given applications `a` and `b`, case-split on whether the corresponding
`i`-th arguments are equal or not. The split is only performed if all other
arguments are already known to be equal or are also tagged as split candidates.
| true |
_private.Mathlib.Data.PFun.0.PFun.mem_prodLift._simp_1_6 | Mathlib.Data.PFun | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | null | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeftIsLimit | Mathlib.Geometry.RingedSpace.OpenImmersion | {X Y Z : AlgebraicGeometry.LocallyRingedSpace} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f] →
CategoryTheory.Limits.IsLimit (AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeft f g) | The constructed `pullbackConeOfLeft` is indeed limiting. | true |
List.dropWhile.eq_def | Init.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (x : List α),
List.dropWhile p x =
match x with
| [] => []
| a :: l =>
match p a with
| true => List.dropWhile p l
| false => a :: l | null | true |
IsLocalMax.norm_add_self | Mathlib.Analysis.Normed.Module.Extr | ∀ {X : Type u_2} {E : Type u_3} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] [inst_2 : TopologicalSpace X]
{f : X → E} {c : X}, IsLocalMax (norm ∘ f) c → IsLocalMax (fun x => ‖f x + f c‖) c | If `f : α → E` is a function such that `norm ∘ f` has a local maximum at a point `c`, then the
function `fun x => ‖f x + f c‖` has a local maximum at `c`. | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.mk._flat_ctor | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Int.Linear.Poly → Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Lean.Meta.Grind.Arith.Cutsat.LeCnstr | null | false |
Finsupp.mem_submodule_iff | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_5}
(S : α → Submodule R M) (x : α →₀ M), x ∈ Finsupp.submodule S ↔ ∀ (i : α), x i ∈ S i | null | true |
Submonoid.val_mem_of_mem_units | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ}, x ∈ S.units → ↑x ∈ S | null | true |
_private.Mathlib.Analysis.Normed.Module.FiniteDimension.0.continuousOn_clm_apply._simp_1_2 | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {α : Type u_3} {p : Prop} {q : α → Prop}, (p → ∀ (x : α), q x) = ∀ (x : α), p → q x | null | false |
Aesop.UnsafeQueue.instEmptyCollection | Aesop.Tree.UnsafeQueue | EmptyCollection Aesop.UnsafeQueue | null | true |
Finsupp.mem_neLocus | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N] {f g : α →₀ N}
{a : α}, a ∈ f.neLocus g ↔ f a ≠ g a | null | true |
Std.DTreeMap.isSome_minKey?_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t → t.minKey?.isSome = true | null | true |
CategoryTheory.Functor.mapTriangleCommShiftIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : Ca... | null | true |
Nat.Partrec.Code.ofNatCode.eq_4 | Mathlib.Computability.PartrecCode | Nat.Partrec.Code.ofNatCode 3 = Nat.Partrec.Code.right | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_fmod_unique'._proof_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℤ}, b < 0 → ¬0 < -b → False | null | false |
_private.Init.Data.List.MapIdx.0.Option.getD.match_1.splitter | Init.Data.List.MapIdx | {α : Type u_1} →
(motive : Option α → Sort u_2) → (opt : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive opt | null | true |
String.Slice.Pattern.Model.IsRevMatch | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} → (pat : ρ) → [String.Slice.Pattern.Model.PatternModel pat] → {s : String.Slice} → s.Pos → Prop | Predicate stating that the region between the position `startPos` and the end of the slice
`s` matches the pattern `pat`. Note that there might be a longer match.
| true |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.filter._proof_1 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} (f : (a : α) → β a → Bool) (m m' : Std.DHashMap α β),
m.Equiv m' → Std.ExtDHashMap.mk (Std.DHashMap.filter f m) = Std.ExtDHashMap.mk (Std.DHashMap.filter f m') | null | false |
ArchimedeanClass.mk_nonneg_of_le_of_le_of_archimedean | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {S : Type u_3}
[inst_3 : LinearOrder S] [inst_4 : CommRing S] [IsStrictOrderedRing S] [Archimedean S] (f : S →+*o R) {x : R}
{r s : S}, f r ≤ x → x ≤ f s → 0 ≤ ArchimedeanClass.mk x | null | true |
MeasureTheory.SimpleFunc.bind._proof_2 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : MeasurableSpace α] (f : MeasureTheory.SimpleFunc α β)
(g : β → MeasureTheory.SimpleFunc α γ) (c : γ), MeasurableSet {a | (g (f a)) a = c} | null | false |
CommRingCat.Colimits.instCommRingColimitType._proof_9 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(x : CommRingCat.Colimits.ColimitType F), x * 1 = x | null | false |
Tropical.instLinearOrderTropical._proof_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : LinearOrder R] (a b : Tropical R),
Tropical.untrop (a + b) = Tropical.untrop (if a ≤ b then a else b) | null | false |
CategoryTheory.CommGrp.forget₂CommMon_map_hom | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {A B : CategoryTheory.CommGrp C} (f : A ⟶ B),
((CategoryTheory.CommGrp.forget₂CommMon C).map f).hom = f.hom.hom | null | true |
CategoryTheory.prodComonad._proof_10 | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C)
[inst_1 : CategoryTheory.Limits.HasBinaryProducts C] (X_1 : C),
CategoryTheory.CategoryStruct.comp
({
app := fun x =>
CategoryTheory.Limits.prod.lift CategoryTheory.Limits.prod.fst
(CategoryTheory.... | null | false |
UInt64.toUInt8_or | Init.Data.UInt.Bitwise | ∀ (a b : UInt64), (a ||| b).toUInt8 = a.toUInt8 ||| b.toUInt8 | null | true |
Quaternion.imJ_star | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), (star a).imJ = -a.imJ | null | true |
List.splitAtD.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → α → ℕ → List α → List α → List α × List α | null | false |
_private.Lean.Meta.Tactic.Grind.Anchor.0.Lean.Meta.Grind.getAnchor.match_4 | Lean.Meta.Tactic.Grind.Anchor | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((data : Lean.MData) → (b : Lean.Expr) → motive (Lean.Expr.mdata data b)) →
((n : Lean.... | null | false |
Lean.Meta.LazyDiscrTree.recOn | Lean.Meta.LazyDiscrTree | {α : Type} →
{motive : Lean.Meta.LazyDiscrTree α → Sort u} →
(t : Lean.Meta.LazyDiscrTree α) →
((tries : Array (Lean.Meta.LazyDiscrTree.Trie α)) →
(roots : Std.HashMap Lean.Meta.LazyDiscrTree.Key Lean.Meta.LazyDiscrTree.TrieIndex) →
motive { tries := tries, roots := roots }) →
... | null | false |
Mathlib.Tactic.Ring.ringCleanupRef | Mathlib.Tactic.Ring.Basic | IO.Ref (Lean.Expr → Lean.MetaM Lean.Expr) | This is a routine which is used to clean up the unsolved subgoal
of a failed `ring1` application. It is overridden in `Mathlib/Tactic/Ring/RingNF.lean`
to apply the `ring_nf` simp set to the goal.
| true |
VitaliFamily.FineSubfamilyOn.index | Mathlib.MeasureTheory.Covering.VitaliFamily | {X : Type u_1} →
[inst : PseudoMetricSpace X] →
{m0 : MeasurableSpace X} →
{μ : MeasureTheory.Measure X} →
{v : VitaliFamily μ} → {f : X → Set (Set X)} → {s : Set X} → v.FineSubfamilyOn f s → Set (X × Set X) | Given `h : v.FineSubfamilyOn f s`, then `h.index` is a set parametrizing a disjoint
covering of almost every `s`. | true |
SimpleGraph.Walk.IsHamiltonian.fintype._proof_1 | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a b : α} {p : G.Walk a b},
p.IsHamiltonian → ∀ (x : α), x ∈ p.support.toFinset | null | false |
Nat.odd_sub._simp_1 | Mathlib.Algebra.Ring.Parity | ∀ {m n : ℕ}, n ≤ m → Odd (m - n) = (Odd m ↔ Even n) | null | false |
CategoryTheory.Functor.elementsFunctor_map | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Functor C (Type w)} (n : X ⟶ Y),
CategoryTheory.Functor.elementsFunctor.map n = (CategoryTheory.NatTrans.mapElements n).toCatHom | null | true |
WithZeroMulInt.toNNReal_le_one_iff | Mathlib.Data.Int.WithZero | ∀ {e : NNReal} {m : WithZero (Multiplicative ℤ)} (he : 1 < e), (WithZeroMulInt.toNNReal ⋯) m ≤ 1 ↔ m ≤ 1 | null | true |
Algebra.transcendental_ringHom_iff_of_comp_eq | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] {B : Type u_2} [inst_4 : Ring B] [inst_5 : Algebra S B] {FRS : Type u_3} {FAB : Type u_4}
[inst_6 : EquivLike FRS R S] [inst_7 : RingEquivClass FRS R S] [inst_8 : EquivLike FAB A B]
[inst_... | null | true |
padicValRat.of_int | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} {z : ℤ}, padicValRat p ↑z = ↑(padicValInt p z) | The `p`-adic value of an integer `z ≠ 0` is its `p`-adic value as a rational. | true |
Lean.SCC.State.recOn | Lean.Util.SCC | {α : Type} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.SCC.State α → Sort u} →
(t : Lean.SCC.State α) →
((stack : List α) →
(nextIndex : ℕ) →
(data : Std.HashMap α Lean.SCC.Data) →
(sccs : List (List α)) →
mo... | null | false |
orderBornology_isBounded._simp_1 | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} {s : Set α} [inst : Lattice α] [inst_1 : Nonempty α], Bornology.IsBounded s = (BddBelow s ∧ BddAbove s) | null | false |
_private.Mathlib.RingTheory.Unramified.Finite.0.Algebra.FormallyUnramified.finite_of_free_aux._simp_1_6 | Mathlib.RingTheory.Unramified.Finite | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | null | false |
Std.Tactic.BVDecide.LRAT.Internal.Formula.rupAdd_sound | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | ∀ {α : outParam (Type u)} {β : outParam (Type v)} {inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} {σ : Type w}
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} [self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(f : σ) (c : β) (rupHints : Array ℕ) (f' : σ),
Std.Tactic.BVDecide.LRAT.Internal.Fo... | null | true |
FirstOrder.Language.LEquiv.symm_invLHom | Mathlib.ModelTheory.LanguageMap | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} (e : L ≃ᴸ L'), e.symm.invLHom = e.toLHom | null | true |
CategoryTheory.Precoherent.recOn | Mathlib.CategoryTheory.Sites.Coherent.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Precoherent C → Sort u} →
(t : CategoryTheory.Precoherent C) →
((pullback :
∀ {B₁ B₂ : C} (f : B₂ ⟶ B₁) (α : Type) [Finite α] (X₁ : α → C) (π₁ : (a : α) → X₁ a ⟶ B₁),
CategoryTheor... | null | false |
CommGroup.toDistribLattice.eq_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_2) [inst : Lattice α] [inst_1 : CommGroup α] [inst_2 : MulLeftMono α],
CommGroup.toDistribLattice α = { toLattice := inst, le_sup_inf := ⋯ } | null | true |
ProbabilityTheory.Kernel.ae_compProd_iff | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ]
{η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} {p : β × γ → Prop},
MeasurableSe... | null | true |
max_mul_mul_left | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α] [MulLeftMono α] (a b c : α), max (a * b) (a * c) = a * max b c | null | true |
Equiv.forall_congr' | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β),
(∀ (b : β), p (e.symm b) ↔ q b) → ((∀ (a : α), p a) ↔ ∀ (b : β), q b) | null | true |
Ctop.Realizer.id._proof_1 | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [inst : TopologicalSpace α] (x x_1 : { x // IsOpen x }) (_a : α) (h : _a ∈ ↑x ∩ ↑x_1),
_a ∈
↑(match x, h with
| ⟨_x, h₁⟩, _h₃ =>
match x_1, _h₃ with
| ⟨_y, h₂⟩, _h₃ => ⟨_x ∩ _y, ⋯⟩) | null | false |
Lean.Lsp.CompletionClientCapabilities.casesOn | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.CompletionClientCapabilities → Sort u} →
(t : Lean.Lsp.CompletionClientCapabilities) →
((completionItem? : Option Lean.Lsp.CompletionItemCapabilities) → motive { completionItem? := completionItem? }) →
motive t | null | false |
CategoryTheory.congr_app | Mathlib.CategoryTheory.NatTrans | ∀ {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} {α β : CategoryTheory.NatTrans F G}, α = β → ∀ (X : C), α.app X = β.app X | null | true |
Fintype.linearIndependent_iffₛ | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Fintype ι],
LinearIndependent R v ↔ ∀ (f g : ι → R), ∑ i, f i • v i = ∑ i, g i • v i → ∀ (i : ι), f i = g i | null | true |
not_or._simp_3 | Mathlib.Tactic.Push | ∀ {p q : Prop}, (¬p ∧ ¬q) = ¬(p ∨ q) | null | false |
Group.nilpotencyClass_of_not_nilpotent | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G], ¬Group.IsNilpotent G → Group.nilpotencyClass G = 0 | null | true |
Vector.finRev?_push | Init.Data.Vector.Find | ∀ {α : Type} {n : ℕ} {p : α → Bool} {a : α} {xs : Vector α n},
Vector.findRev? p (xs.push a) = (Option.guard p a).or (Vector.findRev? p xs) | null | true |
CategoryTheory.Functor.PreservesLeftKanExtension.mk._flat_ctor | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] {G : CategoryTheory.Functor B D} {F : CategoryTheory.Functor A B... | null | false |
NumberField.Units.finrank_eq | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
Module.finrank ℤ (Additive (NumberField.RingOfIntegers K)ˣ) = NumberField.Units.rank K | null | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_7 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α},
a ∈ l →
∀ (hl : l ≠ []),
¬(List.idxOf a l + 1) % l.length + 1 ≤ l.dropLast.length →
(List.idxOf a l + 1) % l.length - l.dropLast.length < [l.getLast ⋯].length | null | false |
_private.Mathlib.Algebra.IsPrimePow.0.not_isPrimePow_zero._simp_1_4 | Mathlib.Algebra.IsPrimePow | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Finset.sup_inf_sup | Mathlib.Data.Finset.Lattice.Prod | ∀ {α : Type u_2} {ι : Type u_5} {κ : Type u_6} [inst : DistribLattice α] [inst_1 : OrderBot α] (s : Finset ι)
(t : Finset κ) (f : ι → α) (g : κ → α), s.sup f ⊓ t.sup g = (s ×ˢ t).sup fun i => f i.1 ⊓ g i.2 | null | true |
List.cons_sublist_iff | Init.Data.List.Sublist | ∀ {α : Type u_1} {a : α} {l l' : List α}, (a :: l).Sublist l' ↔ ∃ r₁ r₂, l' = r₁ ++ r₂ ∧ a ∈ r₁ ∧ l.Sublist r₂ | null | true |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.cocone_ι_transitionMap_assoc | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Ca... | null | true |
Real.expPartialHomeomorph_target | Mathlib.Analysis.SpecialFunctions.Log.Basic | Real.expPartialHomeomorph.target = Set.Ioi 0 | null | true |
Subring.toRing | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u_1} → [inst : Ring R] → (s : Subring R) → Ring ↥s | A subring of a ring inherits a ring structure | true |
IsCompl.compl_eq_iff | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : BooleanAlgebra α], IsCompl x y → (zᶜ = y ↔ z = x) | null | true |
_private.Lean.Elab.Tactic.ElabTerm.0.Lean.Elab.Tactic.refineCore._sparseCasesOn_1 | Lean.Elab.Tactic.ElabTerm | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Filter.monoid._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : Monoid α] (x : Filter α), npowRecAuto 0 x = 1 | null | false |
Array.all_iff_forall | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α} {start stop : ℕ},
as.all p start stop = true ↔ ∀ (i : ℕ) (x : i < as.size), start ≤ i ∧ i < stop → p as[i] = true | null | true |
AddAction.sigmaFixedByEquivOrbitsProdAddGroup._proof_1 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ (α : Type u_1) (β : Type u_2) [inst : AddGroup α] [inst_1 : AddAction α β] (x : α × β),
x.1 +ᵥ x.2 = x.2 ↔ x.1 +ᵥ x.2 = x.2 | null | false |
Lean.Meta.kabstract | Lean.Meta.KAbstract | Lean.Expr → Lean.Expr → optParam Lean.Meta.Occurrences Lean.Meta.Occurrences.all → Lean.MetaM Lean.Expr | Abstract occurrences of `p` in `e`. We detect subterms equivalent to `p` using key-matching.
That is, only perform `isDefEq` tests when the head symbol of subterm is equivalent to head symbol of `p`.
By default, all occurrences are abstracted,
but this behavior can be controlled using the `occs` parameter.
All matche... | true |
_private.Mathlib.Data.Rat.Sqrt.0.Rat.exists_mul_self.match_1_1 | Mathlib.Data.Rat.Sqrt | ∀ (x : ℚ) (motive : (∃ q, q * q = x) → Prop) (x_1 : ∃ q, q * q = x), (∀ (n : ℚ) (hn : n * n = x), motive ⋯) → motive x_1 | null | false |
Mathlib.Tactic._aux_Mathlib_Tactic_Core___macroRules_Mathlib_Tactic_tacticRepeat1__1 | Mathlib.Tactic.Core | Lean.Macro | `repeat1 tac` applies `tac` to main goal at least once. If the application succeeds,
the tactic is applied recursively to the generated subgoals until it eventually fails.
| false |
AlgebraicGeometry.instAddCommGroupObjOppositeOpensCarrierTopObjFunctorTypeIsSheafGrothendieckTopologyStructureSheafInType | Mathlib.AlgebraicGeometry.StructureSheaf | {R M : Type u} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(U : (TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))ᵒᵖ) →
AddCommGroup ((AlgebraicGeometry.structureSheafInType R M).obj.obj U) | null | true |
AlgebraicGeometry.LocallyOfFiniteType.isLocallyNoetherian | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.LocallyOfFiniteType f]
[AlgebraicGeometry.IsLocallyNoetherian Y], AlgebraicGeometry.IsLocallyNoetherian X | null | true |
HahnSeries.toOrderTopSubOnePos | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : LinearOrder Γ] →
[inst_2 : IsOrderedCancelAddMonoid Γ] →
[inst_3 : CommRing R] → {x : HahnSeries Γ R} → 0 < (x - 1).orderTop → ↥(HahnSeries.orderTopSubOnePos Γ R) | Make an element of `orderTopSubOnePos` | true |
MDifferentiableWithinAt.clm_bundle_apply | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {M : Type u_6} [inst : NontriviallyNormedField 𝕜]
{E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)] [inst_2 : (x : B) → Module 𝕜 (E₁ x)]
[inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁] [inst_5 : TopologicalSpace (Bundle.Tota... | Consider a differentiable map `v : M → E₁` to a vector bundle, over a base map `b : M → B`, and
linear maps `ϕ m : E₁ (b m) → E₂ (b m)` depending smoothly on `m`.
One can apply `ϕ m` to `v m`, and the resulting map is differentiable.
We give here a version of this statement within a set at a point. | true |
infEDist_inv | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (x : E) (s : Set E), Metric.infEDist x⁻¹ s = Metric.infEDist x s⁻¹ | null | true |
instBornologyPUnit._proof_1 | Mathlib.Topology.Bornology.Basic | ⊥ ≤ Filter.cofinite | null | false |
Lean.SerialMessage.ctorIdx | Lean.Message | Lean.SerialMessage → ℕ | null | false |
Char.lt | Init.Data.Char.Basic | Char → Char → Prop | One character is less than another if its code point is strictly less than the other's.
| true |
Lean.Grind.CommRing.Stepwise.div_cert.eq_1 | Init.Grind.Ring.CommSolver | ∀ (p₁ : Lean.Grind.CommRing.Poly) (k : ℤ) (p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Stepwise.div_cert p₁ k p = (!k.beq' 0).and' ((Lean.Grind.CommRing.Poly.mulConst_k k p).beq' p₁) | null | true |
UInt64.ofFin_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : Fin UInt64.size), ↑b < 64 → UInt64.ofFin (a <<< b) = UInt64.ofFin a <<< UInt64.ofFin b | null | true |
_private.Mathlib.Combinatorics.Hall.Finite.0.HallMarriageTheorem.hall_cond_of_compl._simp_1_9 | Mathlib.Combinatorics.Hall.Finite | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.