name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Turing.ToPartrec.Cont.eval.eq_4 | Mathlib.Computability.TuringMachine.Config | ∀ (f : Turing.ToPartrec.Code) (k : Turing.ToPartrec.Cont),
(Turing.ToPartrec.Cont.comp f k).eval = fun v => f.eval v >>= k.eval | true |
Real.two_mul_cos_mul_cos | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), 2 * Real.cos x * Real.cos y = Real.cos (x - y) + Real.cos (x + y) | true |
Multiset.pairwise_zero._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (r : α → α → Prop), Multiset.Pairwise r 0 = True | false |
Module.Relations.Solution.IsPresentationCore | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} →
[inst : Ring A] →
{relations : Module.Relations A} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] → relations.Solution M → Type (max (max (max u v) (w' + 1)) w₀) | true |
continuous_multiset_sum | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {M : Type u_3} {X : Type u_5} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace M]
[inst_2 : AddCommMonoid M] [ContinuousAdd M] {f : ι → X → M} (s : Multiset ι),
(∀ i ∈ s, Continuous (f i)) → Continuous fun a => (Multiset.map (fun i => f i a) s).sum | true |
CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono'_ι | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (h : S₂.RightHomologyData) [inst_2 : CategoryTheory.Epi φ.τ₁]
[inst_3 : CategoryTheory.IsIso φ.τ₂] [inst_4 : CategoryTheory.Mono φ.τ₃],
(Category... | true |
MDifferentiableAt.sum_section | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {E : B → Type u_6} [inst : TopologicalSpace B]
[inst_1 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_2 : (x : B) → TopologicalSpace (E x)]
[inst_3 : NormedAddCommGroup F] [inst_4 : NontriviallyNormedField 𝕜] [inst_5 : NormedSpace 𝕜 F]
[inst_6 : FiberBundle F E... | true |
ShowMessageRequestParams.noConfusion | Lean.Data.Lsp.Window | {P : Sort u} → {t t' : ShowMessageRequestParams} → t = t' → ShowMessageRequestParams.noConfusionType P t t' | false |
Lean.Lsp.instFromJsonDefinitionParams.fromJson | Lean.Data.Lsp.LanguageFeatures | Lean.Json → Except String Lean.Lsp.DefinitionParams | true |
_private.Mathlib.NumberTheory.Padics.MahlerBasis.0.bojanic_mahler_step1 | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {M : Type u_1} {G : Type u_2} [inst : AddCommMonoidWithOne M] [inst_1 : AddCommGroup G] (f : M → G) (n : ℕ) {R : ℕ},
1 ≤ R →
(fwdDiff 1)^[n + R] f 0 =
-∑ j ∈ Finset.range (R - 1), R.choose (j + 1) • (fwdDiff 1)^[n + (j + 1)] f 0 +
∑ k ∈ Finset.range (n + 1), ((-1) ^ (n - k) * ↑(n.choose k)) • (f (... | true |
sameRay_neg_iff._simp_1 | Mathlib.LinearAlgebra.Ray | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R] {M : Type u_2}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] {x y : M}, SameRay R (-x) (-y) = SameRay R x y | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_390 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
ModuleCat.free_hom_ext | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ {R : Type u} [inst : Ring R] {X : Type u} {M : ModuleCat R} {f g : (ModuleCat.free R).obj X ⟶ M},
(∀ (x : X),
(CategoryTheory.ConcreteCategory.hom f) (ModuleCat.freeMk x) =
(CategoryTheory.ConcreteCategory.hom g) (ModuleCat.freeMk x)) →
f = g | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._proof_8 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ (r₀ r : ℤ), autoParam (r₀ ≤ r) CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_5 → r₀ ≤ r | false |
CategoryTheory.Under.mapId_eq | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] (Y : T),
CategoryTheory.Under.map (CategoryTheory.CategoryStruct.id Y) = CategoryTheory.Functor.id (CategoryTheory.Under Y) | true |
Lean.Meta.Grind.Arith.CommRing.State.typeIdOf | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.State → Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ) | true |
Std.Net.SocketAddress.v6.inj | Std.Net.Addr | ∀ {addr addr_1 : Std.Net.SocketAddressV6},
Std.Net.SocketAddress.v6 addr = Std.Net.SocketAddress.v6 addr_1 → addr = addr_1 | true |
Submodule.submodule_torsionBy_orderIso._proof_5 | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | false |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.reduceCoefficientwise.match_9 | Mathlib.Tactic.Module | {u v : Lean.Level} →
{M : Q(Type v)} →
{R : Q(Type u)} →
{x : Q(AddCommMonoid «$M»)} →
{x_1 : Q(Semiring «$R»)} →
(iRM : Q(Module «$R» «$M»)) →
(l₁ : Mathlib.Tactic.Module.qNF R M) →
(L₂ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ) →
(motive :... | false |
Std.DTreeMap.Internal.Const.toList_ric | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : Type v} [inst : Ord α] [Std.TransOrd α] (t : Std.DTreeMap.Internal.Impl α fun x => β),
t.Ordered →
∀ (bound : α),
Std.Slice.toList (Std.Ric.Sliceable.mkSlice t *...=bound) =
List.filter (fun e => (compare e.1 bound).isLE) (Std.DTreeMap.Internal.Impl.Const.toList t) | true |
Lean.Elab.Command.elabReduce._regBuiltin.Lean.Elab.Command.elabReduce.declRange_3 | Lean.Elab.BuiltinCommand | IO Unit | false |
CategoryTheory.Limits.CokernelCofork.π_mapOfIsColimit | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {X Y : C}
{f : X ⟶ Y} {X' Y' : C} {f' : X' ⟶ Y'} {cc : CategoryTheory.Limits.CokernelCofork f}
(hf : CategoryTheory.Limits.IsColimit cc) (cc' : CategoryTheory.Limits.CokernelCofork f')
(φ : CategoryTheory.... | true |
Std.DTreeMap.Internal.Impl.Equiv.minKeyD_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t₁ t₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ {fallback : α}, t₁.minKeyD fallback = t₂.minKeyD fallback | true |
Std.TreeSet.le_min | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α} {he : t.isEmpty = false},
(cmp k (t.min he)).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | true |
Array.replace_extract | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α} {xs : Array α} {i : ℕ},
(xs.extract 0 i).replace a b = (xs.replace a b).extract 0 i | true |
CategoryTheory.Comma.post | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{C : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C] →
... | true |
CategoryTheory.CommMon.equivLaxBraidedFunctorPUnit_functor | 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.equivLaxBraidedFunctorPUnit.functor =
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon C | true |
Aesop.GoalUnsafe.rec_6 | Aesop.Tree.Data | {motive_1 : Aesop.GoalUnsafe → Sort u} →
{motive_2 : Aesop.MVarClusterUnsafe → Sort u} →
{motive_3 : Aesop.RappUnsafe → Sort u} →
{motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u} →
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u} →
... | false |
AbsoluteValue.coe_toMonoidWithZeroHom | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {R : Type u_5} {S : Type u_6} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : PartialOrder S]
(abv : AbsoluteValue R S) [inst_3 : IsDomain S] [inst_4 : Nontrivial R], ⇑abv.toMonoidWithZeroHom = ⇑abv | true |
CategoryTheory.TransfiniteCompositionOfShape.F | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
{X Y : C} →
{f : X ⟶ Y} →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
CategoryTheory.Transfinit... | true |
SchwartzMap.toBoundedContinuousFunctionCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | (𝕜 : Type u_2) →
(E : Type u_5) →
(F : Type u_6) →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] →
[inst_2 : NormedAddCommGroup F] →
[inst_3 : NormedSpace ℝ F] →
[inst_4 : RCLike 𝕜] →
[inst_5 : NormedSpace 𝕜 F] →
[... | true |
FloatArray.mk | Init.Data.FloatArray.Basic | Array Float → FloatArray | true |
PartialEquiv.IsImage.of_symm_preimage_eq | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {e : PartialEquiv α β} {s : Set α} {t : Set β},
e.target ∩ ↑e.symm ⁻¹' s = e.target ∩ t → e.IsImage s t | true |
KaehlerDifferential.derivationQuotKerTotal | Mathlib.RingTheory.Kaehler.Basic | (R : Type u) →
(S : Type v) →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → Derivation R S ((S →₀ S) ⧸ KaehlerDifferential.kerTotal R S) | true |
AlgHom.coeOutAddMonoidHom | Mathlib.Algebra.Algebra.Hom | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] → [inst_3 : Algebra R A] → [inst_4 : Algebra R B] → CoeOut (A →ₐ[R] B) (A →+ B) | true |
_private.Lean.DocString.Add.0.Lean.parseVersoDocString._sparseCasesOn_1 | Lean.DocString.Add | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | false |
Lean.instHashableImport.hash | Lean.Setup | Lean.Import → UInt64 | true |
MeasureTheory.measure_univ_of_isMulLeftInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] [inst_3 : Group G]
[IsTopologicalGroup G] [WeaklyLocallyCompactSpace G] [NoncompactSpace G] (μ : MeasureTheory.Measure G)
[μ.IsOpenPosMeasure] [μ.IsMulLeftInvariant], μ Set.univ = ⊤ | true |
ContinuousMultilinearMap.seminormedAddCommGroup._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(x x_1 : ContinuousMultilinearMap ... | false |
Mathlib.Tactic.BicategoryLike.MkEvalComp.ctorIdx | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} → Mathlib.Tactic.BicategoryLike.MkEvalComp m → ℕ | false |
_private.Mathlib.NumberTheory.PythagoreanTriples.0.circleEquivGen._simp_4 | Mathlib.NumberTheory.PythagoreanTriples | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
Std.DHashMap.Internal.AssocList.Const.toList_alter | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {a : α} {f : Option β → Option β}
{l : Std.DHashMap.Internal.AssocList α fun x => β},
(Std.DHashMap.Internal.AssocList.Const.alter a f l).toList.Perm (Std.Internal.List.Const.alterKey a f l.toList) | true |
Std.DHashMap.Raw.instRepr | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [Repr α] → [(a : α) → Repr (β a)] → Repr (Std.DHashMap.Raw α β) | true |
Std.TreeMap.maxKey!_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.maxKey! ∈ t | true |
ValuativeRel.Rel.rfl | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x : R}, x ≤ᵥ x | true |
Lean.Core.modifyCache | Lean.CoreM | (Lean.Core.Cache → Lean.Core.Cache) → Lean.CoreM Unit | true |
controlled_closure_of_complete | Mathlib.Analysis.Normed.Group.ControlledClosure | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [CompleteSpace G] {H : Type u_2} [inst_2 : NormedAddCommGroup H]
{f : NormedAddGroupHom G H} {K : AddSubgroup H} {C ε : ℝ},
0 < C → 0 < ε → f.SurjectiveOnWith K C → f.SurjectiveOnWith K.topologicalClosure (C + ε) | true |
instSMulDistribClassAlgEquiv | Mathlib.RingTheory.Invariant.Basic | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Field K] [inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : IsFractionRing A K]
[inst_7 : Algebra A B] [inst_8 : Algebra K L] [inst_9 : Algebra A L] [inst_10 : IsScalarTower A K ... | true |
UpperSet.instCommMonoid.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.instCommMonoid =
{ toSemigroup := UpperSet.commSemigroup.toSemigroup, toOne := UpperSet.instOne, one_mul := ⋯, mul_one := ⋯,
npow := npowRecAuto, npow_zero := ⋯, npow_succ := ⋯, mul_comm := ⋯ } | true |
BoundedContinuousFunction.isBounded_range | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
(f : BoundedContinuousFunction α β), Bornology.IsBounded (Set.range ⇑f) | true |
Matrix.superFactorial_dvd_vandermonde_det | Mathlib.LinearAlgebra.Vandermonde | ∀ {n : ℕ} (v : Fin (n + 1) → ℤ), ↑n.superFactorial ∣ (Matrix.vandermonde v).det | true |
Filter.Germ.instRightCancelSemigroup | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → [RightCancelSemigroup M] → RightCancelSemigroup (l.Germ M) | true |
_private.Mathlib.NumberTheory.Fermat.0.Nat.prod_fermatNumber._proof_1_3 | Mathlib.NumberTheory.Fermat | ∀ (n : ℕ), 2 ^ (2 ^ n * 2) - 1 = 1 + 2 ^ (2 ^ n * 2) - 2 | false |
IsMinOn.bddBelow | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMinOn f s a → BddBelow (f '' s) | true |
Lean.Parser.ParserCategory.mk | Lean.Parser.Basic | Lean.Name →
Lean.Parser.SyntaxNodeKindSet →
Lean.Parser.PrattParsingTables → Lean.Parser.LeadingIdentBehavior → Lean.Parser.ParserCategory | true |
Affine.Simplex.restrict_points_coe | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n) (S : AffineSubspace k P)
(hS : affineSpan k (Set.range s.points) ≤ S) (i : Fin (n + 1)), ↑((s.restrict S hS).points i) = s.points i | true |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory._aux_Mathlib_CategoryTheory_Bicategory_Free___unexpand_CategoryTheory_FreeBicategory_Hom₂_right_unitor_inv_1 | Mathlib.CategoryTheory.Bicategory.Free | Lean.PrettyPrinter.Unexpander | false |
IsRelPrime.mul_add_left_left_iff | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y z : R}, IsRelPrime (y * z + x) y ↔ IsRelPrime x y | true |
Module.Relations.Solution.postcomp_var | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(f : M →ₗ[A] N) (g : relations.G), (solution.postcomp f).var g = f (solution.var g) | true |
PiTensorProduct.lift._proof_7 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {E : Type u_4} [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
(φ : MultilinearMap R s E) (x y : PiTensorProduct R fun i => s i),
(↑(PiTensorProduct.liftAux φ)).... | false |
Lean.LeanOptionValue.ofString | Lean.Util.LeanOptions | String → Lean.LeanOptionValue | true |
CategoryTheory.Comonad.Coalgebra.eilenbergMoore._proof_2 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : CategoryTheory.Comonad C} {X Y : G.Coalgebra}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f | false |
Set.principalSegIio._proof_8 | Mathlib.Order.Interval.Set.InitialSeg | ∀ {α : Type u_1} [inst : Preorder α] (j b : α),
b ∈
Set.range
⇑{
toFun := fun x =>
match x with
| ⟨j_1, hj⟩ => j_1,
inj' := ⋯, map_rel_iff' := ⋯ } ↔
b < j | false |
MeasureTheory.measureReal_mono | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
s₁ ⊆ s₂ → autoParam (μ s₂ ≠ ⊤) MeasureTheory.measureReal_mono._auto_1 → μ.real s₁ ≤ μ.real s₂ | true |
upperBounds_Ioo | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeInf γ] [DenselyOrdered γ] {a b : γ}, a < b → upperBounds (Set.Ioo a b) = Set.Ici b | true |
CategoryTheory.Pretriangulated.shiftFunctorCompIsoId_op_inv_app._auto_1 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | Lean.Syntax | false |
Std.HashMap.Raw.contains_insert_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β}, (m.insert k v).contains k = true | true |
List.iSup_mem_map_of_exists_sSup_empty_le | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {l : List ι} (f : ι → α),
(∃ x ∈ l, sSup ∅ ≤ f x) → ⨆ x ∈ l, f x ∈ List.map f l | true |
UpperHalfPlane.metricSpaceAux._proof_3 | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | uniformity UpperHalfPlane = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε} | false |
DecidableLT._to_dual_cast_4 | Mathlib.Tactic.ToDual | (α : Type u) → [inst : LT α] → (DecidableRel fun a a_1 => a_1 < a) → DecidableLT α | false |
AddMonoid.Coprod.clift_apply_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : FreeAddMonoid (M ⊕ N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0)
(hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0)
(hM :
∀ (x y : M),
f (FreeAddMonoid.of (Sum.inl (x + y))) ... | true |
UpperSet.instCompleteLinearOrder._proof_3 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LinearOrder α] (a b c : UpperSet α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c | false |
PMF.toMeasure_bindOnSupport_apply | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {β : Type u_2} {p : PMF α} (f : (a : α) → a ∈ p.support → PMF β) (s : Set β)
[inst : MeasurableSpace β],
MeasurableSet s → (p.bindOnSupport f).toMeasure s = ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h).toMeasure s | true |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_nhdsNE._simp_1_2 | Mathlib.Analysis.Calculus.LHopital | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y = (Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) | false |
Polynomial.IsUnitTrinomial.irreducible_aux2 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {p q : Polynomial ℤ} {k m m' n : ℕ},
k < m →
m < n →
k < m' →
m' < n →
∀ (u v w : ℤˣ),
p = Polynomial.trinomial k m n ↑u ↑v ↑w →
q = Polynomial.trinomial k m' n ↑u ↑v ↑w → p * p.mirror = q * q.mirror → q = p ∨ q = p.mirror | true |
Filter.sup_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g : Filter β), (f₁ ⊔ f₂) ×ˢ g = f₁ ×ˢ g ⊔ f₂ ×ˢ g | true |
Ring.DirectLimit.of._proof_2 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j) (i : ι),
(Ideal.Quotient.mk
(Ideal.span
{a |
(∃ i j, ∃ (H : i ≤ j), ∃ x, FreeCommRing.of ⟨j, f i j H x⟩ - FreeCommRing.of ⟨i, x⟩ = a) ∨
(∃ i, Fr... | false |
LieAlgebra.isNilpotent_range_ad_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieRing.IsNilpotent ↥(LieAlgebra.ad R L).range = LieRing.IsNilpotent L | false |
ProbabilityTheory.Kernel.Invariant.eq_1 | Mathlib.Probability.Kernel.Invariance | ∀ {α : Type u_1} {mα : MeasurableSpace α} (κ : ProbabilityTheory.Kernel α α) (μ : MeasureTheory.Measure α),
κ.Invariant μ = (μ.bind ⇑κ = μ) | true |
_private.Lean.Meta.Tactic.Try.Collect.0.Lean.Meta.Try.Collector.saveFunInd.match_1 | Lean.Meta.Tactic.Try.Collect | (motive : Option Lean.Meta.FunIndInfo → Sort u_1) →
(__do_lift : Option Lean.Meta.FunIndInfo) →
((funIndInfo : Lean.Meta.FunIndInfo) → motive (some funIndInfo)) →
((x : Option Lean.Meta.FunIndInfo) → motive x) → motive __do_lift | false |
Lean.Elab.Term.SyntheticMVarDecl.noConfusion | Lean.Elab.Term.TermElabM | {P : Sort u} →
{t t' : Lean.Elab.Term.SyntheticMVarDecl} → t = t' → Lean.Elab.Term.SyntheticMVarDecl.noConfusionType P t t' | false |
CategoryTheory.MonoidalSingleObj.endMonoidalStarFunctorEquivalence | Mathlib.CategoryTheory.Bicategory.SingleObj | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.EndMonoidal (CategoryTheory.MonoidalSingleObj.star C) ≌ C | true |
Stream'.Seq.lt_length_iff | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α} {n : ℕ} {h : s.Terminates}, n < s.length h ↔ ∃ a, a ∈ s.get? n | true |
Lean.IR.LocalContext.isParam | Lean.Compiler.IR.Basic | Lean.IR.LocalContext → Lean.IR.Index → Bool | true |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Sieve.pullback_comp._simp_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {R S : CategoryTheory.Sieve X},
(R = S) = ∀ ⦃Y : C⦄ (f : Y ⟶ X), R.arrows f ↔ S.arrows f | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.integrable_gaussianPDFReal._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {q : NNReal}, (0 ≤ ↑q) = True | false |
PiNat.mem_cylinder_iff_dist_le | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, y ∈ PiNat.cylinder x n ↔ dist y x ≤ (1 / 2) ^ n | true |
TangentBundle.chartAt | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_6}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : IsManifold I 1 M] (p : Tangen... | true |
Fin2.fz.noConfusion | Mathlib.Data.Fin.Fin2 | {P : Sort u} → {n n' : ℕ} → n + 1 = n' + 1 → Fin2.fz ≍ Fin2.fz → (n = n' → P) → P | false |
_private.Mathlib.RingTheory.Unramified.LocalStructure.0.Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn_of_exists_adjoin_singleton_eq_top_aux₂._simp_1_2 | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (b : B), 1 ⊗ₜ[R] b = (algebraMap B (TensorProduct R A B)) b | false |
dotProduct_self_star_nonneg._simp_1 | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : PartialOrder R] [inst_2 : NonUnitalRing R]
[inst_3 : StarRing R] [StarOrderedRing R] (v : n → R), (0 ≤ v ⬝ᵥ star v) = True | false |
Matroid.RankFinite.exists_finite_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [self : M.RankFinite], ∃ B, M.IsBase B ∧ B.Finite | true |
CategoryTheory.Limits.Cocone.toCostructuredArrowCocone._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
{K : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone K) (F : CategoryTheory.Functor C D) {X : D}
(f : F.obj c.p... | false |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.recOn | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{X Y : C} →
... | false |
_private.Mathlib.Order.BooleanAlgebra.Set.0.Set.ssubset_iff_sdiff_singleton._proof_1_1 | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a} | false |
CategoryTheory.Limits.MultispanIndex.sndSigmaMapOfIsColimit.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left}
(d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c),
I.sndSigmaMapOfIsColimit d hc =
Catego... | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_717 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card) + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)]... | false |
_private.Mathlib.Dynamics.TopologicalEntropy.Semiconj.0.Dynamics.IsDynCoverOf.preimage._simp_1_4 | Mathlib.Dynamics.TopologicalEntropy.Semiconj | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) | false |
SimpleGraph.Subgraph.coe._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G' : G.Subgraph) (x x_1 : ↑G'.verts), G'.Adj ↑x ↑x_1 → G'.Adj ↑x_1 ↑x | false |
_private.Mathlib.FieldTheory.KummerExtension.0.isSplittingField_X_pow_sub_C_of_root_adjoin_eq_top.match_1_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : (primitiveRoots (Module.finrank K L) K).Nonempty → Prop)
(hK : (primitiveRoots (Module.finrank K L) K).Nonempty),
(∀ (w : K) (hζ : w ∈ primitiveRoots (Module.finrank K L) K), motive ⋯) → motive hK | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.