name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ContractingWith.aposteriori_dist_iterate_fixedPoint_le | Mathlib.Topology.MetricSpace.Contracting | ∀ {α : Type u_1} [inst : MetricSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f) [inst_1 : Nonempty α]
[inst_2 : CompleteSpace α] (x : α) (n : ℕ),
dist (f^[n] x) (ContractingWith.fixedPoint f hf) ≤ dist (f^[n] x) (f^[n + 1] x) / (1 - ↑K) | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Split.0.BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany._simp_1_1 | Mathlib.Analysis.BoxIntegral.Partition.Split | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (insert a s ⊆ t) = (a ∈ t ∧ s ⊆ t) | false |
Perfection.lift_apply_apply_coe | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] (R : Type u₁) [inst : CommSemiring R] [inst_1 : CharP R p]
[inst_2 : PerfectRing R p] (S : Type u₂) [inst_3 : CommSemiring S] [inst_4 : CharP S p] (f : R →+* S) (r : R) (n : ℕ),
↑(((Perfection.lift p R S) f) r) n = f ((⇑↑(frobeniusEquiv R p).symm)^[n] r) | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.toUInt64_le._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
HomotopicalAlgebra.Precylinder.inl_i | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A)
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct A A],
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.coprod.inl P.i = P.i₀ | true |
FP.Float.instAdd | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → Add FP.Float | true |
rightLim_rightLim | Mathlib.Topology.Order.LeftRightLim | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace β] [inst_2 : TopologicalSpace α]
[OrderTopology α] [T3Space β] {f : α → β} {a : α},
Filter.Tendsto f (nhdsWithin a (Set.Ioi a)) (nhds (Function.rightLim f a)) →
Function.rightLim (Function.rightLim f) a = Function.rightLim f a | true |
SetSemiring.imageHom_def | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} {β : Type u_2} [inst : MulOneClass α] [inst_1 : MulOneClass β] (f : α →* β) (s : SetSemiring α),
(SetSemiring.imageHom f) s = Set.up (⇑f '' SetSemiring.down s) | true |
Topology.IsConstructible.compl | Mathlib.Topology.Constructible | ∀ {X : Type u_2} [inst : TopologicalSpace X] {s : Set X}, Topology.IsConstructible s → Topology.IsConstructible sᶜ | true |
Padic.valuation._proof_2 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (f g : CauSeq ℚ (padicNorm p)), f ≈ g → PadicSeq.valuation f = PadicSeq.valuation g | false |
Lean.Server.Test.Runner.Client.InteractiveTermGoal.mk.injEq | Lean.Server.Test.Runner | ∀ (toInteractiveGoalCore : Lean.Server.Test.Runner.Client.InteractiveGoalCore) (range : Lean.Lsp.Range)
(term : Lean.Lsp.RpcRef) (toInteractiveGoalCore_1 : Lean.Server.Test.Runner.Client.InteractiveGoalCore)
(range_1 : Lean.Lsp.Range) (term_1 : Lean.Lsp.RpcRef),
({ toInteractiveGoalCore := toInteractiveGoalCore, range := range, term := term } =
{ toInteractiveGoalCore := toInteractiveGoalCore_1, range := range_1, term := term_1 }) =
(toInteractiveGoalCore = toInteractiveGoalCore_1 ∧ range = range_1 ∧ term = term_1) | true |
UInt16.not_ne_self | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, ~~~a ≠ a | true |
Metric.unitSphere.instInv._proof_1 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : NormedDivisionRing 𝕜] (x : ↑(Metric.sphere 0 1)), ‖(↑x)⁻¹‖ = 1 | false |
CategoryTheory.ShortComplex.SnakeInput.op._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.Epi S.L₂.op.g | false |
Localization.instLinearOrderOfIsOrderedCancelMonoid._proof_3 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedCancelMonoid α] {s : Submonoid α}
(a b : Localization s), compareOfLessAndEq a b = compareOfLessAndEq a b | false |
Polynomial.Monic.degree_mul | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, q.Monic → (p * q).degree = p.degree + q.degree | true |
MeasureTheory.Measure.ae_integrable_of_integrable_comp | Mathlib.Probability.Kernel.Composition.IntegralCompProd | ∀ {α : Type u_5} {β : Type u_6} {E : Type u_7} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
[inst : NormedAddCommGroup E] {κ : ProbabilityTheory.Kernel α β} {μ : MeasureTheory.Measure α} {f : β → E},
MeasureTheory.Integrable f (μ.bind ⇑κ) → ∀ᵐ (x : α) ∂μ, MeasureTheory.Integrable f (κ x) | true |
OneHom.mulSingle_apply | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {I : Type u} {f : I → Type v} [inst : DecidableEq I] [inst_1 : (i : I) → One (f i)] (i : I) (x : f i),
(OneHom.mulSingle f i) x = Pi.mulSingle i x | true |
_private.Mathlib.Probability.Martingale.BorelCantelli.0.MeasureTheory.Submartingale.exists_tendsto_of_abs_bddAbove_aux._simp_1_3 | Mathlib.Probability.Martingale.BorelCantelli | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | false |
IsBaseChange.rank_eq_of_le_nonZeroDivisors | Mathlib.LinearAlgebra.Dimension.Localization | ∀ {R : Type uR} (S : Type uS) {M : Type uM} {N : Type uN} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Algebra R S]
[inst_7 : Module S N] [IsScalarTower R S N] {p : Submonoid R} [IsLocalization p S] (f : M →ₗ[R] N)
[IsLocalizedModule p f],
p ≤ nonZeroDivisors R →
∀ [Module.Free S N] [StrongRankCondition S] {T : Type uT} [inst_13 : CommRing T] [inst_14 : Algebra R T],
Algebra.algebraMapSubmonoid T p ≤ nonZeroDivisors T →
∀ [StrongRankCondition (TensorProduct R S T)] {P : Type uM} [inst_16 : AddCommGroup P] [inst_17 : Module R P]
[inst_18 : Module T P] [inst_19 : IsScalarTower R T P] {g : M →ₗ[R] P},
IsBaseChange T g → Module.rank T P = Module.rank R M | true |
DoubleCentralizer.intCast_snd | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (n : ℤ), (↑n).toProd.2 = ↑n | true |
_private.Batteries.Data.List.Lemmas.0.List.IsChain.imp._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {S : α → α → Prop} (a : α), List.IsChain S [a] | false |
CategoryTheory.PrelaxFunctor.map₂_hom_inv | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.PrelaxFunctor B C) {a b : B} {f g : a ⟶ b} (η : f ≅ g),
CategoryTheory.CategoryStruct.comp (F.map₂ η.hom) (F.map₂ η.inv) = CategoryTheory.CategoryStruct.id (F.map f) | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.runSimplexAlgorithm | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.SimplexAlgorithm | {matType : ℕ → ℕ → Type} →
[inst : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm matType] →
Mathlib.Tactic.Linarith.SimplexAlgorithm.SimplexAlgorithmM matType Unit | true |
Aesop.StatsExtensionEntry.position? | Aesop.Stats.Extension | Aesop.StatsExtensionEntry → Option Lean.Position | true |
MeasureTheory.AEStronglyMeasurable.const_vadd' | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{f : α → β} {𝕜 : Type u_5} [inst_1 : VAdd 𝕜 β] [ContinuousConstVAdd 𝕜 β],
MeasureTheory.AEStronglyMeasurable f μ → ∀ (c : 𝕜), MeasureTheory.AEStronglyMeasurable (fun x => c +ᵥ f x) μ | true |
EquivLike.surjective_comp._simp_1 | Mathlib.Data.FunLike.Equiv | ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [inst : EquivLike E α β] (e : E) (f : β → γ),
Function.Surjective (f ∘ ⇑e) = Function.Surjective f | false |
_private.Mathlib.FieldTheory.Finite.GaloisField.0.FiniteField.nonempty_algHom_iff_finrank_dvd.match_1_1 | Mathlib.FieldTheory.Finite.GaloisField | ∀ {F : Type u_3} {K : Type u_2} {L : Type u_1} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K]
[inst_3 : Field L] [inst_4 : Algebra F L] (motive : Nonempty (K →ₐ[F] L) → Prop) (x : Nonempty (K →ₐ[F] L)),
(∀ (f : K →ₐ[F] L), motive ⋯) → motive x | false |
LinearIsometryEquiv.casesOn | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] →
{E : Type u_11} →
{E₂ : Type u_12} →
[inst_4 : SeminormedAddCommGroup E] →
[inst_5 : SeminormedAddCommGroup E₂] →
[inst_6 : Module R E] →
[inst_7 : Module R₂ E₂] →
{motive : (E ≃ₛₗᵢ[σ₁₂] E₂) → Sort u} →
(t : E ≃ₛₗᵢ[σ₁₂] E₂) →
((toLinearEquiv : E ≃ₛₗ[σ₁₂] E₂) →
(norm_map' : ∀ (x : E), ‖toLinearEquiv x‖ = ‖x‖) →
motive { toLinearEquiv := toLinearEquiv, norm_map' := norm_map' }) →
motive t | false |
NonUnitalAlgHom.recOn | Mathlib.Algebra.Algebra.NonUnitalHom | {R : Type u} →
{S : Type u₁} →
[inst : Monoid R] →
[inst_1 : Monoid S] →
{φ : R →* S} →
{A : Type v} →
{B : Type w} →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : DistribMulAction R A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : DistribMulAction S B] →
{motive : (A →ₛₙₐ[φ] B) → Sort u_1} →
(t : A →ₛₙₐ[φ] B) →
((toDistribMulActionHom : A →ₑ+[φ] B) →
(map_mul' :
∀ (x y : A),
toDistribMulActionHom.toFun (x * y) =
toDistribMulActionHom.toFun x * toDistribMulActionHom.toFun y) →
motive { toDistribMulActionHom := toDistribMulActionHom, map_mul' := map_mul' }) →
motive t | false |
Specialization.toEquiv | Mathlib.Topology.Specialization | {α : Type u_1} → α ≃ Specialization α | true |
CauSeq.const_mul | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x y : β),
CauSeq.const abv (x * y) = CauSeq.const abv x * CauSeq.const abv y | true |
CategoryTheory.Limits.Types.Pushout.Rel'.rec | Mathlib.CategoryTheory.Limits.Types.Pushouts | ∀ {S X₁ X₂ : Type u} {f : S ⟶ X₁} {g : S ⟶ X₂}
{motive : (a a_1 : X₁ ⊕ X₂) → CategoryTheory.Limits.Types.Pushout.Rel' f g a a_1 → Prop},
(∀ (x : X₁ ⊕ X₂), motive x x ⋯) →
(∀ (x₀ y₀ : S) (h : g x₀ = g y₀), motive (Sum.inl (f x₀)) (Sum.inl (f y₀)) ⋯) →
(∀ (s : S), motive (Sum.inl (f s)) (Sum.inr (g s)) ⋯) →
(∀ (s : S), motive (Sum.inr (g s)) (Sum.inl (f s)) ⋯) →
∀ {a a_1 : X₁ ⊕ X₂} (t : CategoryTheory.Limits.Types.Pushout.Rel' f g a a_1), motive a a_1 t | false |
CategoryTheory.MonoOver.mk_obj | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X A : C} (f : A ⟶ X) [hf : CategoryTheory.Mono f],
(CategoryTheory.MonoOver.mk f).obj = CategoryTheory.Over.mk f | true |
Lean.Elab.Tactic.GuardMsgs.FilterSpec.pass.sizeOf_spec | Lean.Elab.GuardMsgs | sizeOf Lean.Elab.Tactic.GuardMsgs.FilterSpec.pass = 1 | true |
Equiv.Perm.support_swap | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {x y : α}, x ≠ y → (Equiv.swap x y).support = {x, y} | true |
_private.Std.Sat.AIG.RefVecOperator.Zip.0.Std.Sat.AIG.RefVec.zip._proof_7 | Std.Sat.AIG.RefVecOperator.Zip | ∀ {len : ℕ}, ¬0 ≤ len → False | false |
_private.Mathlib.Algebra.Ring.Int.Defs.0.Int.cast_mul_eq_zsmul_cast._simp_1_1 | Mathlib.Algebra.Ring.Int.Defs | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | false |
CategoryTheory.Sum.functorEquivFunctorCompSndIso | Mathlib.CategoryTheory.Sums.Products | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{A' : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} A'] →
{B : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} B] →
(CategoryTheory.Sum.functorEquiv A A' B).functor.comp
(CategoryTheory.Prod.snd (CategoryTheory.Functor A B) (CategoryTheory.Functor A' B)) ≅
(CategoryTheory.Functor.whiskeringLeft A' (A ⊕ A') B).obj (CategoryTheory.Sum.inr_ A A') | true |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraided_map_hom_hom_app | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y : CategoryTheory.CommMon C} (f : X ⟶ Y)
(x : CategoryTheory.Discrete PUnit.{u + 1}),
((CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.commMonToLaxBraided C).map f).hom.hom.app x = f.hom.hom | true |
Submodule.Quotient.distribSMul' | Mathlib.LinearAlgebra.Quotient.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : Ring R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{S : Type u_3} →
[inst_3 : SMul S R] →
[inst_4 : DistribSMul S M] → [IsScalarTower S R M] → (P : Submodule R M) → DistribSMul S (M ⧸ P) | true |
RingCat.instCoeSortType | Mathlib.Algebra.Category.Ring.Basic | CoeSort RingCat (Type u) | true |
AffineMap.coe_comp | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} {V3 : Type u_6} {P3 : Type u_7}
[inst : Ring k] [inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1]
[inst_4 : AddCommGroup V2] [inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2] [inst_7 : AddCommGroup V3]
[inst_8 : Module k V3] [inst_9 : AddTorsor V3 P3] (f : P2 →ᵃ[k] P3) (g : P1 →ᵃ[k] P2), ⇑(f.comp g) = ⇑f ∘ ⇑g | true |
smoothSheafCommRing.ι_forgetStalk_inv | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {EM : Type u_2} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_3} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_4} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_5} [inst_6 : TopologicalSpace H]
(I : ModelWithCorners 𝕜 E H) (M : Type u) [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace HM M] (R : Type u)
[inst_9 : TopologicalSpace R] [inst_10 : ChartedSpace H R] [inst_11 : CommRing R] [inst_12 : ContMDiffRing I (↑⊤) R]
(x : ↑(TopCat.of M)) (U : (TopologicalSpace.OpenNhds x)ᵒᵖ),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.colimit.ι ((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheaf IM I M R).presheaf)
U)
(smoothSheafCommRing.forgetStalk IM I M R x).inv =
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.Limits.colimit.ι
((TopologicalSpace.OpenNhds.inclusion x).op.comp (smoothSheafCommRing IM I M R).presheaf) U)) | true |
Lean.instHashableModuleIdx | Lean.Environment | Hashable Lean.ModuleIdx | true |
CategoryTheory.Oplax.StrongTrans.Hom.of.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} {η θ : F ⟶ G} [inst_2 : SizeOf B] [inst_3 : SizeOf C]
(as : CategoryTheory.Oplax.StrongTrans.Modification η θ), sizeOf { as := as } = 1 + sizeOf as | true |
CategoryTheory.tensorClosed | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : C} →
CategoryTheory.Closed X →
CategoryTheory.Closed Y → CategoryTheory.Closed (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) | true |
CategoryTheory.Bicategory.LeftLift.whiskering._proof_6 | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a} {x : B} (h : x ⟶ c)
{X Y Z : CategoryTheory.Bicategory.LeftLift f g} (f_1 : X ⟶ Y) (g_1 : Y ⟶ Z),
CategoryTheory.Bicategory.LeftLift.homMk
(CategoryTheory.Bicategory.whiskerLeft h (CategoryTheory.CategoryStruct.comp f_1 g_1).right) ⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.LeftLift.homMk (CategoryTheory.Bicategory.whiskerLeft h f_1.right) ⋯)
(CategoryTheory.Bicategory.LeftLift.homMk (CategoryTheory.Bicategory.whiskerLeft h g_1.right) ⋯) | false |
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go.eq_2 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] (k : α) (best : Option (α × β)) (size : ℕ) (k' : α) (v' : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k best (Std.DTreeMap.Internal.Impl.inner size k' v' l r) =
match compare k k' with
| Ordering.gt => Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k (some (k', v')) r
| x => Std.DTreeMap.Internal.Impl.Const.getEntryLT?.go k best l | true |
MeasureTheory.SimpleFunc.extend_apply | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
(f₁ : MeasureTheory.SimpleFunc α γ) {g : α → β} (hg : MeasurableEmbedding g) (f₂ : MeasureTheory.SimpleFunc β γ)
(x : α), (f₁.extend g hg f₂) (g x) = f₁ x | true |
USize.and_self | Init.Data.UInt.Bitwise | ∀ {a : USize}, a &&& a = a | true |
Lean.Lsp.InlayHintTooltip.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintTooltip → Sort u} →
(t : Lean.Lsp.InlayHintTooltip) →
((text : String) → motive (Lean.Lsp.InlayHintTooltip.plaintext text)) →
((markup : Lean.Lsp.MarkupContent) → motive (Lean.Lsp.InlayHintTooltip.markdown markup)) → motive t | false |
Std.DTreeMap.Internal.Const.instSliceableImplRcoSlice | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.Rco.Sliceable (Std.DTreeMap.Internal.Impl α fun x => β) α (Std.DTreeMap.Internal.Const.RcoSlice α β) | true |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_artanh._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ x ∈ Set.Ioo (-1) 1, 0 < 1 + x | false |
DividedPowers.SubDPIdeal.instTop | Mathlib.RingTheory.DividedPowers.SubDPIdeal | {A : Type u_1} → [inst : CommSemiring A] → {I : Ideal A} → {hI : DividedPowers I} → Top hI.SubDPIdeal | true |
Std.DTreeMap.getKeyLT? | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → α → Option α | true |
CategoryTheory.StructuredArrow.commaMapEquivalenceUnitIso | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L : CategoryTheory.Functor C T} →
{R : CategoryTheory.Functor D T} →
{C' : Type u₄} →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C'] →
{D' : Type u₅} →
[inst_4 : CategoryTheory.Category.{v₅, u₅} D'] →
{T' : Type u₆} →
[inst_5 : CategoryTheory.Category.{v₆, u₆} T'] →
{L' : CategoryTheory.Functor C' T'} →
{R' : CategoryTheory.Functor D' T'} →
{F₁ : CategoryTheory.Functor C C'} →
{F₂ : CategoryTheory.Functor D D'} →
{F : CategoryTheory.Functor T T'} →
(α : F₁.comp L' ⟶ L.comp F) →
(β : R.comp F ⟶ F₂.comp R') →
[inst_6 : CategoryTheory.IsIso β] →
(X : CategoryTheory.Comma L' R') →
CategoryTheory.Functor.id
(CategoryTheory.StructuredArrow X (CategoryTheory.Comma.map α β)) ≅
(CategoryTheory.StructuredArrow.commaMapEquivalenceFunctor α β X).comp
(CategoryTheory.StructuredArrow.commaMapEquivalenceInverse α β X) | true |
_private.Mathlib.Tactic.GRewrite.Core.0.Lean.MVarId.grewrite.match_6 | Mathlib.Tactic.GRewrite.Core | (motive : Bool × Array Lean.MVarId → Sort u_1) →
(__discr : Bool × Array Lean.MVarId) →
((fst : Bool) → (sideGoals : Array Lean.MVarId) → motive (fst, sideGoals)) → motive __discr | false |
Matrix.replicateRow_add | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {m : Type u_2} {α : Type v} {ι : Type u_6} [inst : Add α] (v w : m → α),
Matrix.replicateRow ι (v + w) = Matrix.replicateRow ι v + Matrix.replicateRow ι w | true |
IsRelUpperSet.iUnion₂ | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {ι : Sort u_2} {κ : ι → Sort u_3} {P : α → Prop} [inst : LE α] {f : (i : ι) → κ i → Set α},
(∀ (i : ι) (j : κ i), IsRelUpperSet (f i j) P) → IsRelUpperSet (⋃ i, ⋃ j, f i j) P | true |
Std.Internal.UV.System.availableMemory | Std.Internal.UV.System | IO UInt64 | true |
SmoothBumpFunction.ball_inter_range_eq_ball_inter_target | Mathlib.Geometry.Manifold.BumpFunction | ∀ {E : Type uE} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type uH} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type uM} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {c : M}
(f : SmoothBumpFunction I c),
Metric.ball (↑(extChartAt I c) c) f.rOut ∩ Set.range ↑I =
Metric.ball (↑(extChartAt I c) c) f.rOut ∩ (extChartAt I c).target | true |
_private.Mathlib.Algebra.Order.Group.Finset.0.Multiset.toFinset_nsmul.match_1_1 | Mathlib.Algebra.Order.Group.Finset | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (h : 0 ≠ 0), motive 0 h) → (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | false |
SetSemiring.down_add | Mathlib.Data.Set.Semiring | ∀ {α : Type u_1} (s t : SetSemiring α), SetSemiring.down (s + t) = SetSemiring.down s ∪ SetSemiring.down t | true |
Std.ExtTreeMap.getElem?_erase | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k a : α},
(t.erase k)[a]? = if cmp k a = Ordering.eq then none else t[a]? | true |
isOpenMap_smul₀ | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {G₀ : Type u_4} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀] [inst_2 : MulAction G₀ α]
[ContinuousConstSMul G₀ α] {c : G₀}, c ≠ 0 → IsOpenMap fun x => c • x | true |
MulSemiringActionHom.recOn | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
[inst : Monoid M] →
{N : Type u_2} →
[inst_1 : Monoid N] →
{φ : M →* N} →
{R : Type u_10} →
[inst_2 : Semiring R] →
[inst_3 : MulSemiringAction M R] →
{S : Type u_12} →
[inst_4 : Semiring S] →
[inst_5 : MulSemiringAction N S] →
{motive : (R →ₑ+*[φ] S) → Sort u} →
(t : R →ₑ+*[φ] S) →
((toDistribMulActionHom : R →ₑ+[φ] S) →
(map_one' : toDistribMulActionHom.toFun 1 = 1) →
(map_mul' :
∀ (x y : R),
toDistribMulActionHom.toFun (x * y) =
toDistribMulActionHom.toFun x * toDistribMulActionHom.toFun y) →
motive
{ toDistribMulActionHom := toDistribMulActionHom, map_one' := map_one',
map_mul' := map_mul' }) →
motive t | false |
_private.Mathlib.Algebra.EuclideanDomain.Basic.0.EuclideanDomain.«_aux_Mathlib_Algebra_EuclideanDomain_Basic___macroRules__private_Mathlib_Algebra_EuclideanDomain_Basic_0_EuclideanDomain_term_≺__1» | Mathlib.Algebra.EuclideanDomain.Basic | Lean.Macro | false |
groupHomology.H0Iso | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] → (A : Rep.{u, u, u} k G) → groupHomology.H0 A ≅ (Rep.coinvariantsFunctor k G).obj A | true |
Std.ExtTreeMap.maxKey?_le_maxKey?_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {km kmi : α}, t.maxKey? = some km → (t.insert k v).maxKey?.get ⋯ = kmi → (cmp km kmi).isLE = true | true |
Positive.addLeftCancelSemigroup._proof_1 | Mathlib.Algebra.Order.Positive.Ring | ∀ {M : Type u_1} [inst : AddLeftCancelMonoid M] [inst_1 : Preorder M] [inst_2 : AddLeftStrictMono M],
IsLeftCancelAdd { x // 0 < x } | false |
CategoryTheory.Functor.copyObj._proof_4 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) (obj : C → D)
(e : (X : C) → F.obj X ≅ obj X) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (e X).inv
(CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.CategoryStruct.comp f g)) (e Z).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (e X).inv (CategoryTheory.CategoryStruct.comp (F.map f) (e Y).hom))
(CategoryTheory.CategoryStruct.comp (e Y).inv (CategoryTheory.CategoryStruct.comp (F.map g) (e Z).hom)) | false |
AddAut.instAddGroup._proof_9 | Mathlib.GroupTheory.GroupAction.SubMulAction.OfFixingSubgroup | ∀ (M : Type u_1) [inst : Add M] (x : AddAut M), x + 0 = x + 0 | false |
_private.Init.Data.List.Lemmas.0.List.dropLast_append_of_ne_nil.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} (motive : List α → l ≠ [] → Prop) (x : List α) (x_1 : l ≠ []),
(∀ (x : l ≠ []), motive [] x) → (∀ (a : α) (l' : List α) (h : l ≠ []), motive (a :: l') h) → motive x x_1 | false |
ProbabilityTheory.indepSet_iff_measure_inter_eq_mul | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {s t : Set Ω},
MeasurableSet s →
MeasurableSet t →
∀ (μ : autoParam (MeasureTheory.Measure Ω) ProbabilityTheory.indepSet_iff_measure_inter_eq_mul._auto_1)
[MeasureTheory.IsZeroOrProbabilityMeasure μ], ProbabilityTheory.IndepSet s t μ ↔ μ (s ∩ t) = μ s * μ t | true |
FreeSemigroup.mk._flat_ctor | Mathlib.Algebra.Free | {α : Type u} → α → List α → FreeSemigroup α | false |
Set.image_sigmaMk_preimage_sigmaMap_subset | Mathlib.Data.Set.Sigma | ∀ {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} {β : ι' → Type u_4} (f : ι → ι') (g : (i : ι) → α i → β (f i))
(i : ι) (s : Set (β (f i))), Sigma.mk i '' (g i ⁻¹' s) ⊆ Sigma.map f g ⁻¹' (Sigma.mk (f i) '' s) | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.coeff_weierstrassPExceptSeries._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
exists_zsmul_surjective | Mathlib.Algebra.Group.Defs | ∀ (G : Type u_2) [inst : SMul ℤ G] [IsAddCyclic G], ∃ g, Function.Surjective fun x => x • g | true |
Lean.Parser.Tactic.Conv._aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convRepeat__1 | Init.Conv | Lean.Macro | false |
_private.Lean.Meta.Basic.0.Lean.Meta.realizeValue.realizeAndReport | Lean.Meta.Basic | Lean.MetaM Dynamic → Lean.Core.Context → Lean.Environment → Lean.Options → BaseIO Dynamic | true |
Equiv.Perm.support_eq_empty_iff | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {σ : Equiv.Perm α}, σ.support = ∅ ↔ σ = 1 | true |
Rat.isFractionRing | Mathlib.RingTheory.Localization.FractionRing | IsFractionRing ℤ ℚ | true |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.interpolate._simp_2 | Mathlib.LinearAlgebra.Lagrange | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] {f g : ι → M},
∑ x ∈ s, f x + ∑ x ∈ s, g x = ∑ x ∈ s, (f x + g x) | false |
Subgroup.adjoinNegOne_eq_self_iff._simp_1 | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {R : Type u_2} [inst_2 : Ring R] {𝒢 : Subgroup (GL n R)},
(𝒢.adjoinNegOne = 𝒢) = (-1 ∈ 𝒢) | false |
BotHom.instSemilatticeInf._proof_2 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Bot α] [inst_1 : SemilatticeInf β] [inst_2 : OrderBot β] {x y : BotHom α β},
⇑y ≤ ⇑x ↔ ⇑y ≤ ⇑x | false |
Nat.Linear.ExprCnstr.lhs | Init.Data.Nat.Linear | Nat.Linear.ExprCnstr → Nat.Linear.Expr | true |
isMIntegralCurveAt_eventuallyEq_of_contMDiffAt_boundaryless | Mathlib.Geometry.Manifold.IntegralCurve.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : IsManifold I 1 M] {γ γ' : ℝ → M} {v : (x : M) → TangentSpace I x} {t₀ : ℝ} [BoundarylessManifold I M],
ContMDiffAt I (I.prod (modelWithCornersSelf ℝ E)) 1 (fun x => ⟨x, v x⟩) (γ t₀) →
IsMIntegralCurveAt γ v t₀ → IsMIntegralCurveAt γ' v t₀ → γ t₀ = γ' t₀ → γ =ᶠ[nhds t₀] γ' | true |
ContinuousLinearMap.integrableAtFilter_comp | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {l : Filter α} {E : Type u_7} {H : Type u_8}
{𝕜 : Type u_9} {𝕜' : Type u_10} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜' E] [inst_4 : NormedAddCommGroup H] [inst_5 : NormedSpace 𝕜 H]
{σ : 𝕜 →+* 𝕜'} [RingHomIsometric σ] {f : α → H} (L : H →SL[σ] E),
MeasureTheory.IntegrableAtFilter f l μ → MeasureTheory.IntegrableAtFilter (⇑L ∘ f) l μ | true |
OpenPartialHomeomorph.isOpen_symm_image_iff_of_subset_target | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {t : Set Y}, t ⊆ e.target → (IsOpen (↑e.symm '' t) ↔ IsOpen t) | true |
OnePoint.nhdsNE_infty_neBot | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [NoncompactSpace X], (nhdsWithin OnePoint.infty {OnePoint.infty}ᶜ).NeBot | true |
controlled_prod_of_mem_closure_range | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} {F : Type u_5} [inst : SeminormedCommGroup E] [inst_1 : SeminormedCommGroup F] {j : E →* F} {b : F},
b ∈ closure ↑j.range →
∀ {f : ℕ → ℝ},
(∀ (n : ℕ), 0 < f n) →
∃ a,
Filter.Tendsto (fun n => ∏ i ∈ Finset.range (n + 1), j (a i)) Filter.atTop (nhds b) ∧
‖(j (a 0))⁻¹ * b‖ < f 0 ∧ ∀ (n : ℕ), 0 < n → ‖j (a n)‖ < f n | true |
MeasureTheory.Lp.fourierTransformₗᵢ._proof_11 | Mathlib.Analysis.Fourier.LpSpace | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [inst_2 : BorelSpace E]
[inst_3 : InnerProductSpace ℝ E] [inst_4 : FiniteDimensional ℝ E], OpensMeasurableSpace E | false |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.compileToSimpleGroundExpr.compileSetChain._sparseCasesOn_7 | Lean.Compiler.IR.SimpleGroundExpr | {motive_2 : Lean.IR.FnBody → Sort u} →
(t : Lean.IR.FnBody) →
((x : Lean.IR.Arg) → motive_2 (Lean.IR.FnBody.ret x)) →
((x : Lean.IR.VarId) →
(i offset : ℕ) →
(y : Lean.IR.VarId) →
(ty : Lean.IR.IRType) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.sset x i offset y ty b)) →
((x : Lean.IR.VarId) →
(i : ℕ) → (y : Lean.IR.VarId) → (b : Lean.IR.FnBody) → motive_2 (Lean.IR.FnBody.uset x i y b)) →
(Nat.hasNotBit 1072 t.ctorIdx → motive_2 t) → motive_2 t | false |
groupHomology.mapCycles₂_comp | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u} [inst : CommRing k] {G H K : Type u} [inst_1 : Group G] [inst_2 : Group H] [inst_3 : Group K]
{A : Rep.{u, u, u} k G} {B : Rep.{u, u, u} k H} {C : Rep.{u, u, u} k K} (f : G →* H) (g : H →* K)
(φ : A ⟶ Rep.res f B) (ψ : B ⟶ Rep.res g C),
groupHomology.mapCycles₂ (g.comp f) (CategoryTheory.CategoryStruct.comp φ ((Rep.resFunctor f).map ψ)) =
CategoryTheory.CategoryStruct.comp (groupHomology.mapCycles₂ f φ) (groupHomology.mapCycles₂ g ψ) | true |
Lean.Syntax.eqWithInfo | Lean.Syntax | Lean.Syntax → Lean.Syntax → Bool | true |
PrimeMultiset.ofNatList.eq_1 | Mathlib.Data.PNat.Factors | ∀ (l : List ℕ) (h : ∀ p ∈ l, Nat.Prime p), PrimeMultiset.ofNatList l h = PrimeMultiset.ofNatMultiset (↑l) h | true |
CategoryTheory.Triangulated.AbelianSubcategory.hasCokernel | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_1} {A : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C] [inst_6 : CategoryTheory.Category.{v_2, u_2} A]
{ι : CategoryTheory.Functor A C},
(∀ ⦃X Y : A⦄ ⦃n : ℤ⦄ (f : ι.obj X ⟶ (CategoryTheory.shiftFunctor C n).obj (ι.obj Y)), n < 0 → f = 0) →
∀ {X₁ X₂ : A} {f₁ : X₁ ⟶ X₂} {X₃ : C} {f₂ : ι.obj X₂ ⟶ X₃}
{f₃ : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj (ι.obj X₁)},
CategoryTheory.Pretriangulated.Triangle.mk (ι.map f₁) f₂ f₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles →
∀ {K Q : A} {α : (CategoryTheory.shiftFunctor C 1).obj (ι.obj K) ⟶ X₃} {β : X₃ ⟶ ι.obj Q}
{γ : ι.obj Q ⟶ (CategoryTheory.shiftFunctor C 1).obj ((CategoryTheory.shiftFunctor C 1).obj (ι.obj K))},
CategoryTheory.Pretriangulated.Triangle.mk α β γ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles →
∀ [ι.Full] [inst_8 : CategoryTheory.Preadditive A] [ι.Faithful], CategoryTheory.Limits.HasCokernel f₁ | true |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0._proof_445 | Mathlib.CategoryTheory.ComposableArrows.Basic | 4 ≤ 5 | false |
CategoryTheory.Sieve.instCompleteLattice._proof_9 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x x_1 : CategoryTheory.Sieve X) (x_2 : C)
(x_3 : x_2 ⟶ X), x.arrows x_3 ∧ x_1.arrows x_3 → x_1.arrows x_3 | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.