name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.MorphismProperty.multiplicativeClosure'.below.id | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
{motive : ⦃X Y : C⦄ → (x : X ⟶ Y) → W.multiplicativeClosure' x → Prop} (x : C),
CategoryTheory.MorphismProperty.multiplicativeClosure'.below ⋯ |
LocallyConstant.instCommMonoid | Mathlib.Topology.LocallyConstant.Algebra | {X : Type u_1} → {Y : Type u_2} → [inst : TopologicalSpace X] → [CommMonoid Y] → CommMonoid (LocallyConstant X Y) |
conjneg_inj | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f g : G → R},
conjneg f = conjneg g ↔ f = g |
GenContFract.IntFractPair.stream_zero | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.stream v 0 = some (GenContFract.IntFractPair.of v) |
CategoryTheory.Functor.essImage.liftFunctor._proof_1 | Mathlib.CategoryTheory.EssentialImage | ∀ {J : Type u_6} {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
(G : CategoryTheory.Functor J D) (F : CategoryTheory.Functor C D) [inst_3 : F.Full] [F.Faithful]
(hG : ∀ (j : J), F.essImage (G.obj j)) (x : J),
F.map
(F.preimage
(CategoryTheory.CategoryStruct.comp (F.toEssImage.objObjPreimageIso { obj := G.obj x, property := ⋯ }).hom.hom
(CategoryTheory.CategoryStruct.comp (G.map (CategoryTheory.CategoryStruct.id x))
(F.toEssImage.objObjPreimageIso { obj := G.obj x, property := ⋯ }).inv.hom))) =
F.map (CategoryTheory.CategoryStruct.id (F.toEssImage.objPreimage { obj := G.obj x, property := ⋯ })) |
AddMonoidAlgebra.uniqueAlgEquiv | Mathlib.Algebra.MonoidAlgebra.Basic | (R : Type u_1) →
{A : Type u_4} →
(M : Type u_7) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] → [inst_3 : AddMonoid M] → [Unique M] → AddMonoidAlgebra A M ≃ₐ[R] A |
TestFunction.instAddCommGroup._proof_8 | Mathlib.Analysis.Distribution.TestFunction | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousConstSMul ℕ F |
Homeomorph.preimageImageRestrict._proof_2 | Mathlib.Topology.IsClosedRestrict | ∀ {ι : Type u_1} (α : ι → Type u_2) (S : Set ι) (s : Set ((j : ι) → α j)) (p : ↑(Sᶜ.restrict '' s) × ((i : ↑S) → α ↑i)),
(fun x => (⟨Sᶜ.restrict ↑x, ⋯⟩, fun i => ↑x ↑i)) ((fun p => ⟨Topology.reorderRestrictProd S s p, ⋯⟩) p) = p |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_counitIso_hom_app_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
(X :
CategoryTheory.Comma (CategoryTheory.Functor.const SimplexCategory)
(CategoryTheory.Functor.id (CategoryTheory.Functor SimplexCategory C))),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.counitIso.hom.app X).left =
CategoryTheory.CategoryStruct.id X.left |
UV.shadow_compression_subset_compression_shadow | Mathlib.Combinatorics.SetFamily.Compression.UV | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} (u v : Finset α),
(∀ x ∈ u, ∃ y ∈ v, UV.IsCompressed (u.erase x) (v.erase y) 𝒜) →
(UV.compression u v 𝒜).shadow ⊆ UV.compression u v 𝒜.shadow |
Lean.initFn._@.Lean.Util.SafeExponentiation.3025597618._hygCtx._hyg.4 | Lean.Util.SafeExponentiation | IO (Lean.Option ℕ) |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithBot.instPosMulStrictMono._simp_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : LT α] (a : α), (⊥ < ↑a) = True |
CategoryTheory.leftDistributor_ext_left | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts C] {J : Type} [inst_5 : Finite J] {X Y : C} {f : J → C}
{g h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (⨁ f) ⟶ Y},
(∀ (j : J),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.Limits.biproduct.ι f j)) g =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.Limits.biproduct.ι f j)) h) →
g = h |
Lean.Elab.Tactic.evalSimpArithBang._regBuiltin.Lean.Elab.Tactic.evalSimpArithBang_1 | Lean.Elab.Tactic.SimpArith | IO Unit |
Submodule.submoduleOf_sup_of_le | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N₁ N₂ N : Submodule R M}, N₁ ≤ N → N₂ ≤ N → (N₁ ⊔ N₂).submoduleOf N = N₁.submoduleOf N ⊔ N₂.submoduleOf N |
_private.Lean.Environment.0.Lean.ImportedModule.rec | Lean.Environment | {motive : Lean.ImportedModule✝ → Sort u} →
((toEffectiveImport : Lean.EffectiveImport) →
(parts : Array (Lean.ModuleData × Lean.CompactedRegion)) →
(irData? : Option (Lean.ModuleData × Lean.CompactedRegion)) →
(needsData needsIRTrans : Bool) →
motive
{ toEffectiveImport := toEffectiveImport, parts := parts, irData? := irData?, needsData := needsData,
needsIRTrans := needsIRTrans }) →
(t : Lean.ImportedModule✝¹) → motive t |
LinearEquiv.toEquiv | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
{S : Type u_6} →
{M : Type u_7} →
{M₂ : Type u_9} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
{modM : Module R M} →
{modM₂ : Module S M₂} →
{σ : R →+* S} →
{σ' : S →+* R} →
[inst_4 : RingHomInvPair σ σ'] → [inst_5 : RingHomInvPair σ' σ] → (M ≃ₛₗ[σ] M₂) → M ≃ M₂ |
CategoryTheory.Grothendieck.fiber_eqToHom | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{X Y : CategoryTheory.Grothendieck F} (h : X = Y), (CategoryTheory.eqToHom h).fiber = CategoryTheory.eqToHom ⋯ |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.comap_dist_right_atTop._simp_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) |
Stream'.get_even | Mathlib.Data.Stream.Init | ∀ {α : Type u} (n : ℕ) (s : Stream' α), s.even.get n = s.get (2 * n) |
List.bagInter.match_1.congr_eq_3 | Mathlib.Data.List.Lattice | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (x x_1 : List α) (h_1 : (x : List α) → motive [] x)
(h_2 : (x : List α) → motive x []) (h_3 : (a : α) → (l₁ l₂ : List α) → motive (a :: l₁) l₂) (a : α) (l₁ l₂ : List α),
x = a :: l₁ →
x_1 = l₂ →
(l₂ = [] → False) →
(match x, x_1 with
| [], x => h_1 x
| x, [] => h_2 x
| a :: l₁, l₂ => h_3 a l₁ l₂) ≍
h_3 a l₁ l₂ |
rothNumberNat_le_ruzsaSzemerediNumberNat' | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ (n : ℕ), (↑n / 3 - 2) * ↑(rothNumberNat ((n - 3) / 6)) ≤ ↑(ruzsaSzemerediNumberNat n) |
_private.Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral.0.integral_gaussian_complex._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral | Complex.ofReal = ⇑(algebraMap ℝ ℂ) |
mem_subalgebraOfSubring._simp_1 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_1} [inst : Ring R] {x : R} {S : Subring R}, (x ∈ subalgebraOfSubring S) = (x ∈ S) |
_private.Lean.Elab.DocString.0.Lean.Doc.elabBlock.withSpace | Lean.Elab.DocString | String → String |
Setoid.instPartialOrder | Mathlib.Data.Setoid.Basic | {α : Type u_1} → PartialOrder (Setoid α) |
AlgHom.toLieHom_apply | Mathlib.Algebra.Lie.OfAssociative | ∀ {A : Type v} [inst : Ring A] {R : Type u} [inst_1 : CommRing R] [inst_2 : Algebra R A] {B : Type w} [inst_3 : Ring B]
[inst_4 : Algebra R B] (f : A →ₐ[R] B) (x : A), f.toLieHom x = f x |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.extractBind.match_4 | Lean.Elab.Do.Legacy | (motive : Option Lean.Expr → Sort u_1) →
(expectedType? : Option Lean.Expr) →
((expectedType : Lean.Expr) → motive (some expectedType)) →
((x : Option Lean.Expr) → motive x) → motive expectedType? |
MeasureTheory.IsStoppingTime | Mathlib.Probability.Process.Stopping | {Ω : Type u_1} →
{ι : Type u_3} → {m : MeasurableSpace Ω} → [inst : Preorder ι] → MeasureTheory.Filtration ι m → (Ω → WithTop ι) → Prop |
Derivation.map_smul_of_tower | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M] {S : Type u_5}
[inst_6 : SMul S A] [inst_7 : SMul S M] [LinearMap.CompatibleSMul A M S R] (D : Derivation R A M) (r : S) (a : A),
D (r • a) = r • D a |
List.Perm.trans | Init.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ l₃ : List α}, l₁.Perm l₂ → l₂.Perm l₃ → l₁.Perm l₃ |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.exp_inj._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {G : Type u_1} [inst : AddCommGroup G] {p a b : G}, (a ≡ b [PMOD p]) = ∃ m, b - a = m • p |
LaurentPolynomial.isLocalization | Mathlib.Algebra.Polynomial.Laurent | ∀ {R : Type u_1} [inst : CommSemiring R], IsLocalization.Away Polynomial.X (LaurentPolynomial R) |
_private.Mathlib.Combinatorics.SimpleGraph.Basic.0.SimpleGraph.adj_incidenceSet_inter._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) |
Quaternion.instGroupWithZero._proof_7 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R], Nontrivial (Quaternion R) |
SimpleGraph.diam_anti_of_ediam_ne_top | Mathlib.Combinatorics.SimpleGraph.Diam | ∀ {α : Type u_1} {G G' : SimpleGraph α}, G ≤ G' → G.ediam ≠ ⊤ → G'.diam ≤ G.diam |
_private.Lean.Parser.Term.Basic.0.Lean.Parser.Term.initFn._@.Lean.Parser.Term.Basic.2382944618._hygCtx._hyg.2 | Lean.Parser.Term.Basic | IO Unit |
Isometry.mapsTo_emetric_closedBall | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β},
Isometry f → ∀ (x : α) (r : ENNReal), Set.MapsTo f (Metric.closedEBall x r) (Metric.closedEBall (f x) r) |
Std.HashMap.Raw.emptyWithCapacity | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → optParam ℕ 8 → Std.HashMap.Raw α β |
SheafOfModules.Presentation.IsFinite.casesOn | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat] →
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat] →
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
{M : SheafOfModules R} →
{p : M.Presentation} →
{motive : p.IsFinite → Sort u_1} →
(t : p.IsFinite) →
((isFiniteType_generators : p.generators.IsFiniteType) →
(finite_relations : Finite p.relations.I) → motive ⋯) →
motive t |
Lean.Elab.Term.Do.ToTerm.Kind.nestedSBC | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind |
_private.Mathlib.Tactic.GRewrite.Core.0.Lean.MVarId.grewrite._sparseCasesOn_1 | Mathlib.Tactic.GRewrite.Core | {motive : ℕ → Sort u} → (t : ℕ) → ((n : ℕ) → motive n.succ) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.reverse._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, p.reverse.support.tail.Nodup = p.support.tail.Nodup |
Lean.Server.Watchdog.ServerRequestData.freshServerRequestID | Lean.Server.Watchdog | Lean.Server.Watchdog.ServerRequestData → ℕ |
Ring.inverse_non_unit | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] (x : M₀), ¬IsUnit x → Ring.inverse x = 0 |
HasDerivAt.nonpos_of_antitone | Mathlib.Analysis.Calculus.Deriv.Slope | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[OrderTopology 𝕜] {g : 𝕜 → 𝕜} {g' : 𝕜}, HasDerivAt g g' x → Antitone g → g' ≤ 0 |
Module.Basis.addSubgroupOfClosure._proof_1 | Mathlib.LinearAlgebra.Basis.Submodule | ∀ {M : Type u_1} {R : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (A : AddSubgroup M)
{ι : Type u_2} (b : Module.Basis ι R M),
A = AddSubgroup.closure (Set.range ⇑b) → Submodule.span ℤ (Set.range ⇑b) = AddSubgroup.toIntSubmodule A |
CategoryTheory.Limits.PushoutCocone.ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y Z : C} →
{f : X ⟶ Y} →
{g : X ⟶ Z} →
{s t : CategoryTheory.Limits.PushoutCocone f g} →
(i : s.pt ≅ t.pt) →
autoParam (CategoryTheory.CategoryStruct.comp s.inl i.hom = t.inl)
CategoryTheory.Limits.PushoutCocone.ext._auto_1 →
autoParam (CategoryTheory.CategoryStruct.comp s.inr i.hom = t.inr)
CategoryTheory.Limits.PushoutCocone.ext._auto_3 →
(s ≅ t) |
ProbabilityTheory.Kernel.condKernelReal.eq_1 | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {γ : Type u_3} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ}
[inst : MeasurableSpace.CountablyGenerated γ] (κ : ProbabilityTheory.Kernel α (γ × ℝ))
[inst_1 : ProbabilityTheory.IsFiniteKernel κ],
κ.condKernelReal = ProbabilityTheory.IsCondKernelCDF.toKernel κ.condKernelCDF ⋯ |
Nonempty.some | Mathlib.Logic.Nonempty | {α : Sort u_3} → Nonempty α → α |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.map_add_atTop_eq._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [AddRightMono α] {a b c : α}, (a ≤ c - b) = (a + b ≤ c) |
Lagrange.eval_basis_of_ne | Mathlib.LinearAlgebra.Lagrange | ∀ {F : Type u_1} [inst : Field F] {ι : Type u_2} [inst_1 : DecidableEq ι] {s : Finset ι} {v : ι → F} {i j : ι},
i ≠ j → j ∈ s → Polynomial.eval (v j) (Lagrange.basis s v i) = 0 |
Lean.registerOption | Lean.Data.Options | Lean.Name → Lean.OptionDecl → IO Unit |
TensorProduct.norm_map | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {H : Type u_5} [inst : RCLike 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F]
[inst_4 : InnerProductSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G]
[inst_7 : NormedAddCommGroup H] [inst_8 : InnerProductSpace 𝕜 H] (f : E →ₗᵢ[𝕜] G) (g : F →ₗᵢ[𝕜] H)
(x : TensorProduct 𝕜 E F), ‖(TensorProduct.map f.toLinearMap g.toLinearMap) x‖ = ‖x‖ |
Finsupp.sum_ite_eq | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : AddCommMonoid N] [inst_2 : DecidableEq α]
(f : α →₀ M) (a : α) (b : α → M → N),
(f.sum fun x v => if a = x then b x v else 0) = if a ∈ f.support then b a (f a) else 0 |
Lean.PersistentHashMap.mk.injEq | Lean.Data.PersistentHashMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (root root_1 : Lean.PersistentHashMap.Node α β),
({ root := root } = { root := root_1 }) = (root = root_1) |
Lean.ExternEntry.inline.noConfusion | Lean.Compiler.ExternAttr | {P : Sort u} →
{backend : Lean.Name} →
{pattern : String} →
{backend' : Lean.Name} →
{pattern' : String} →
Lean.ExternEntry.inline backend pattern = Lean.ExternEntry.inline backend' pattern' →
(backend = backend' → pattern = pattern' → P) → P |
FirstOrder.Language.Term.inhabitedOfConstant | Mathlib.ModelTheory.Syntax | {L : FirstOrder.Language} → {α : Type u'} → [Inhabited L.Constants] → Inhabited (L.Term α) |
Mathlib.Tactic.Order.AtomicFact.le.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr),
sizeOf (Mathlib.Tactic.Order.AtomicFact.le lhs rhs proof) = 1 + sizeOf lhs + sizeOf rhs + sizeOf proof |
EReal.instInv | Mathlib.Data.EReal.Inv | Inv EReal |
RegularSpace.inf | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_3} {t₁ t₂ : TopologicalSpace X}, RegularSpace X → RegularSpace X → RegularSpace X |
Fin.reduceBin | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | Lean.Name → ℕ → ({n : ℕ} → Fin n → Fin n → Fin n) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep |
_private.Mathlib.Combinatorics.SimpleGraph.Trails.0.SimpleGraph.Walk.IsTrail.even_countP_edges_iff._simp_1_6 | Mathlib.Combinatorics.SimpleGraph.Trails | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
FirstOrder.Language.IsOrdered.recOn | Mathlib.ModelTheory.Order | {L : FirstOrder.Language} →
{motive : L.IsOrdered → Sort u_1} →
(t : L.IsOrdered) → ((leSymb : L.Relations 2) → motive { leSymb := leSymb }) → motive t |
DomAddAct.mk_vadd_indicatorConstLp._proof_1 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {M : Type u_2} {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : VAdd M α]
[MeasureTheory.VAddInvariantMeasure M α μ] (c : M) {s : Set α},
MeasurableSet s → μ s ≠ ⊤ → μ ((fun x => c +ᵥ x) ⁻¹' s) ≠ ⊤ |
HasEnoughRootsOfUnity.finite_rootsOfUnity | Mathlib.RingTheory.RootsOfUnity.EnoughRootsOfUnity | ∀ (M : Type u_1) [inst : CommMonoid M] (n : ℕ) [NeZero n] [HasEnoughRootsOfUnity M n], Finite ↥(rootsOfUnity n M) |
_private.Mathlib.Order.Filter.Map.0.Filter.mem_comap_prodMk._simp_1_5 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
Submodule.spanRank_finite_iff_fg._simp_1 | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {p : Submodule R M},
(p.spanRank < Cardinal.aleph0) = p.FG |
MvPolynomial.decomposition | Mathlib.RingTheory.MvPolynomial.Homogeneous | {σ : Type u_1} →
{R : Type u_3} → [inst : CommSemiring R] → DirectSum.Decomposition (MvPolynomial.homogeneousSubmodule σ R) |
Lean.pp.safeShadowing | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool |
CategoryTheory.Over.coprod._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
{A : C} {X Y : CategoryTheory.Over A} (k : X ⟶ Y) (f g : CategoryTheory.Over A) (k_1 : f ⟶ g),
CategoryTheory.CategoryStruct.comp (X.coprodObj.map k_1)
(CategoryTheory.Over.homMk
(CategoryTheory.Limits.coprod.map k.left
(CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id C).obj g.left)))
⋯) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.homMk
(CategoryTheory.Limits.coprod.map k.left
(CategoryTheory.CategoryStruct.id ((CategoryTheory.Functor.id C).obj f.left)))
⋯)
(Y.coprodObj.map k_1) |
CategoryTheory.Distributive.«_aux_Mathlib_CategoryTheory_Distributive_Monoidal___macroRules_CategoryTheory_Distributive_term∂R_1» | Mathlib.CategoryTheory.Distributive.Monoidal | Lean.Macro |
_private.Mathlib.MeasureTheory.Measure.LevyConvergence.0.MeasureTheory.isTightMeasureSet_of_tendsto_charFun._proof_1_6 | Mathlib.MeasureTheory.Measure.LevyConvergence | (3 + 1).AtLeastTwo |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.EMatchTheorem | ∀ (symPrios : Lean.Meta.Grind.SymbolPriorities) (minPrio : ℕ),
sizeOf { symPrios := symPrios, minPrio := minPrio } = 1 + sizeOf symPrios + sizeOf minPrio |
PartENat.orderBot | Mathlib.Data.Nat.PartENat | OrderBot PartENat |
Lean.Kernel.Exception.unknownConstant.elim | Lean.Environment | {motive : Lean.Kernel.Exception → Sort u} →
(t : Lean.Kernel.Exception) →
t.ctorIdx = 0 →
((env : Lean.Kernel.Environment) → (name : Lean.Name) → motive (Lean.Kernel.Exception.unknownConstant env name)) →
motive t |
CategoryTheory.imageOpUnop | Mathlib.CategoryTheory.Abelian.Opposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X Y : C} → (f : X ⟶ Y) → Opposite.unop (CategoryTheory.Limits.image f.op) ≅ CategoryTheory.Limits.image f |
UInt64.le_antisymm_iff | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, a = b ↔ a ≤ b ∧ b ≤ a |
GaloisCoinsertion.liftCompleteLattice | Mathlib.Order.GaloisConnection.Basic | {α : Type u} →
{β : Type v} →
{l : α → β} →
{u : β → α} → [inst : PartialOrder α] → [inst_1 : CompleteLattice β] → GaloisCoinsertion l u → CompleteLattice α |
_private.Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic.0.exists_continuous_add_one_of_isCompact_nnreal._simp_1_2 | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False |
SimpleGraph.UnitDistEmbedding.mk | Mathlib.Combinatorics.SimpleGraph.UnitDistance.Basic | {V : Type u_1} →
{G : SimpleGraph V} →
{E : Type u_3} →
[inst : MetricSpace E] → (p : V ↪ E) → (∀ {u v : V}, G.Adj u v → dist (p u) (p v) = 1) → G.UnitDistEmbedding E |
isProperMap_iff_isCompact_preimage | Mathlib.Topology.Maps.Proper.CompactlyGenerated | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [T2Space Y]
[CompactlyCoherentSpace Y] {f : X → Y},
IsProperMap f ↔ Continuous f ∧ ∀ ⦃K : Set Y⦄, IsCompact K → IsCompact (f ⁻¹' K) |
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_2 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_1} {R' : Type u_2} {M : Type u_3} {M' : Type u_4} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_5} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommClass R S' M]
(x : M →ₛₗ[σ₁₂] M'), 1 • x = x |
_private.Mathlib.Analysis.Normed.Group.Bounded.0.Bornology.IsBounded.exists_pos_norm_le'.match_1_1 | Mathlib.Analysis.Normed.Group.Bounded | ∀ {E : Type u_1} [inst : SeminormedGroup E] {s : Set E} (motive : (∃ C, ∀ x ∈ s, ‖x‖ ≤ C) → Prop)
(x : ∃ C, ∀ x ∈ s, ‖x‖ ≤ C), (∀ (R₀ : ℝ) (hR₀ : ∀ x ∈ s, ‖x‖ ≤ R₀), motive ⋯) → motive x |
LinearMap.BilinForm.SeparatingRight.toMatrix | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} {M₂ : Type u_4} [inst : CommRing R₂] [inst_1 : AddCommGroup M₂] [inst_2 : Module R₂ M₂] {ι : Type u_6}
[inst_3 : DecidableEq ι] [inst_4 : Fintype ι] {B : LinearMap.BilinForm R₂ M₂},
LinearMap.SeparatingRight B → ∀ (b : Module.Basis ι R₂ M₂), ((LinearMap.BilinForm.toMatrix b) B).SeparatingRight |
NumberField.mixedEmbedding.convexBodySum_isBounded | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] (B : ℝ),
Bornology.IsBounded (NumberField.mixedEmbedding.convexBodySum K B) |
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ.noConfusion | Mathlib.Tactic.NormNum.BigOperators | {n : Q(ℕ)} →
{P : Sort u} →
{n' : Q(ℕ)} →
{pf : «$n» =Q «$n'».succ} →
{n'' : Q(ℕ)} →
{pf' : «$n» =Q «$n''».succ} →
Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n' pf = Mathlib.Meta.Nat.UnifyZeroOrSuccResult.succ n'' pf' →
(n' = n'' → P) → P |
Filter.EventuallyEq.isTheta | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {E : Type u_3} [inst : Norm E] {l : Filter α} {f g : α → E}, f =ᶠ[l] g → f =Θ[l] g |
Std.DTreeMap.Const.minKey!_modify_eq_minKey! | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited α] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey! = t.minKey! |
Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (Q : Ideal S)
[inst_3 : Q.IsPrime] [Algebra.FiniteType R S] [Algebra.IsUnramifiedAt R Q], ∃ f ∉ Q, HasStandardEtaleSurjectionOn R f |
Std.Internal.Small.casesOn | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
{motive : Std.Internal.Small α → Sort u_1} →
(t : Std.Internal.Small α) → ((h : Nonempty (Std.Internal.ComputableSmall α)) → motive ⋯) → motive t |
_private.Mathlib.MeasureTheory.Measure.Restrict.0.MeasureTheory.Measure.restrictₗ._simp_2 | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_1} (a b c : Set α), a ∩ (b \ c) = (a ∩ b) \ c |
AlgebraicGeometry.PresheafedSpace.instInhabited | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → [Inhabited C] → Inhabited (AlgebraicGeometry.PresheafedSpace C) |
IsAlgClosure.of_exists_root | Mathlib.FieldTheory.Isaacs | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[alg : Algebra.IsAlgebraic F E],
(∀ (p : Polynomial F), p.Monic → Irreducible p → ∃ x, (Polynomial.aeval x) p = 0) → IsAlgClosure F E |
CategoryTheory.Limits.MulticospanIndex.mk | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(left : J.L → C) →
(right : J.R → C) →
((b : J.R) → left (J.fst b) ⟶ right b) →
((b : J.R) → left (J.snd b) ⟶ right b) → CategoryTheory.Limits.MulticospanIndex J C |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_negAddY_of_eq._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
bddAbove_smul_iff_of_neg._simp_1 | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β]
{s : Set β} {a : α}, a < 0 → BddAbove (a • s) = BddBelow s |
Matrix.frobeniusNormedRing._proof_10 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_2} {α : Type u_1} [inst : Fintype m] [inst_1 : RCLike α] [inst_2 : DecidableEq m] (n : ℕ),
↑(n + 1) = ↑n + 1 |
ByteArray.utf8Decode?.eq_1 | Init.Data.String.Basic | ∀ (b : ByteArray), b.utf8Decode? = ByteArray.utf8Decode?.go b 0 #[] ⋯ |
_private.Batteries.Tactic.Init.0.Batteries.Tactic._aux_Batteries_Tactic_Init___macroRules_Batteries_Tactic_byContra_1.match_1 | Batteries.Tactic.Init | (motive : Option (Lean.TSyntax `term) → Sort u_1) →
(ty? : Option (Lean.TSyntax `term)) →
((ty? : Lean.TSyntax `term) → motive (some ty?)) → ((x : Option (Lean.TSyntax `term)) → motive x) → motive ty? |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.