name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.IsCardinalFiltered.mk._flat_ctor | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
(∀ {A : Type w} [inst_2 : CategoryTheory.SmallCategory A] (F : CategoryTheory.Functor A J),
HasCardinalLT (CategoryTheory.Arrow A) κ → Nonempty (CategoryTheory.Limits.Cocone F)) →
CategoryTheory.IsCardinalFiltered J κ | false |
CategoryTheory.ShortComplex.moduleCatCyclesIso_inv_iCycles_assoc | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)) {Z : ModuleCat R} (h : S.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp S.moduleCatCyclesIso.inv (CategoryTheory.CategoryStruct.comp S.iCycles h) =
CategoryTheory.CategoryStruct.comp S.moduleCatLeftHomologyData.i h | true |
RingCon.range_mk' | Mathlib.RingTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Ring M] {c : RingCon M}, c.mk'.range = ⊤ | true |
CategoryTheory.MonoidalCategory.curriedTensorPreFunctor._proof_6 | Mathlib.CategoryTheory.Monoidal.Multifunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(X : CategoryTheory.Functor C D),
{
app := fun X₁ =>
{
app := fun X₂ =>
CategoryTheory.MonoidalCategoryStruct.tensorHom ((CategoryTheory.CategoryStruct.id X).app X₁)
((CategoryTheory.CategoryStruct.id X).app X₂),
naturality := ⋯ },
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategory.curriedTensorPre X) | false |
Lean.ToLevel.recOn | Lean.ToLevel | {motive : Lean.ToLevel → Sort u_1} →
(t : Lean.ToLevel) →
((toLevel : Lean.Level) → (univ : ∀ (x : Sort u), True) → motive { toLevel := toLevel }) → motive t | false |
Con.lift_range | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass P] {c : Con M} {f : M →* P}
(H : c ≤ Con.ker f), MonoidHom.mrange (c.lift f H) = MonoidHom.mrange f | true |
_private.Mathlib.Topology.Algebra.LinearTopology.0.isLinearTopology_iff_hasBasis_open_twoSidedIdeal.match_1_1 | Mathlib.Topology.Algebra.LinearTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : TopologicalSpace R]
(motive : IsLinearTopology R R ∧ IsLinearTopology Rᵐᵒᵖ R → Prop) (x : IsLinearTopology R R ∧ IsLinearTopology Rᵐᵒᵖ R),
(∀ (left : IsLinearTopology R R) (right : IsLinearTopology Rᵐᵒᵖ R), motive ⋯) → motive x | false |
Ordset.find | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → α → Ordset α → Option α | true |
_private.Mathlib.NumberTheory.Ostrowski.0.Rat.AbsoluteValue.equiv_padic_of_bounded._simp_1_7 | Mathlib.NumberTheory.Ostrowski | ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), (x ^ y)⁻¹ = x ^ (-y) | false |
Lean.Expr.sort.injEq | Lean.Expr | ∀ (u u_1 : Lean.Level), (Lean.Expr.sort u = Lean.Expr.sort u_1) = (u = u_1) | true |
Algebra.Extension.instIsScalarTowerRingTensorProductBaseChange | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (P : Algebra.Extension R S)
{T : Type u_1} [inst_3 : CommRing T] [inst_4 : Algebra R T], IsScalarTower R P.Ring P.baseChange.Ring | true |
Bundle.Pretrivialization.mem_target | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
(e : Bundle.Pretrivialization F proj) {x : B × F}, x ∈ e.target ↔ x.1 ∈ e.baseSet | true |
ZLattice.summable_norm_zpow | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [FiniteDimensional ℝ E] (L : Submodule ℤ E)
[DiscreteTopology ↥L], ∀ n < -↑(Module.finrank ℤ ↥L), Summable fun z => ‖z‖ ^ n | true |
CategoryTheory.monoidalCategoryMop._proof_5 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(X Y : Cᴹᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.CategoryStruct.id Y).unmop X.unmop).mop =
CategoryTheory.CategoryStruct.id { unmop := CategoryTheory.MonoidalCategoryStruct.tensorObj Y.unmop X.unmop } | false |
DirectSum.IsInternal.subordinateOrthonormalBasisIndex | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_7} →
{𝕜 : Type u_8} →
[inst : RCLike 𝕜] →
{E : Type u_9} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[Fintype ι] →
[FiniteDimensional 𝕜 E] →
{n : ℕ} →
Module.finrank 𝕜 E = n →
[inst_5 : DecidableEq ι] →
{V : ι → Submodule 𝕜 E} →
DirectSum.IsInternal V →
Fin n → (OrthogonalFamily 𝕜 (fun i => ↥(V i)) fun i => (V i).subtypeₗᵢ) → ι | true |
Matroid.restrict_isRestriction._auto_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.Syntax | false |
EckmannHilton.MulOneClass.isUnital | Mathlib.GroupTheory.EckmannHilton | ∀ {X : Type u} [_G : MulOneClass X], EckmannHilton.IsUnital (fun x1 x2 => x1 * x2) 1 | true |
_private.Lean.Meta.Basic.0.Lean.Meta.orelseMergeErrorsImp._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.Exception → Sort u} →
(t : Lean.Exception) →
((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive (Lean.Exception.error ref msg)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.someExistsOneDivLT_subset | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α},
MeasureTheory.SignedMeasure.someExistsOneDivLT✝ s i ⊆ i | true |
Lean.Grind.ConfigInteractive.splitIndPred._inherited_default | Init.Grind.Config | Bool | false |
Lean.Server.Watchdog.FileWorker.mk.sizeOf_spec | Lean.Server.Watchdog | ∀ (doc : Lean.Server.DocumentMeta) (proc : IO.Process.Child Lean.Server.Watchdog.workerCfg)
(exitCode : Std.Mutex (Option UInt32)) (commTask? : Option (Lean.Server.ServerTask Lean.Server.Watchdog.WorkerEvent))
(state : Std.Mutex Lean.Server.Watchdog.WorkerState),
sizeOf { doc := doc, proc := proc, exitCode := exitCode, commTask? := commTask?, state := state } =
1 + sizeOf doc + sizeOf proc + sizeOf exitCode + sizeOf commTask? + sizeOf state | true |
MeasureTheory.Measure.sum_apply₀ | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {ι : Type u_5} {m0 : MeasurableSpace α} (f : ι → MeasureTheory.Measure α) {s : Set α},
MeasureTheory.NullMeasurableSet s (MeasureTheory.Measure.sum f) →
(MeasureTheory.Measure.sum f) s = ∑' (i : ι), (f i) s | true |
nndist_self | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] (a : α), nndist a a = 0 | true |
RingHom.PropertyIsLocal.localizationAwayPreserves | Mathlib.RingTheory.LocalProperties.Basic | ∀ {P : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop},
RingHom.PropertyIsLocal P → RingHom.LocalizationAwayPreserves P | true |
ModuleCat.moduleOfAlgebraModule | Mathlib.Algebra.Category.ModuleCat.Algebra | {k : Type u} → [inst : Field k] → {A : Type w} → [inst_1 : Ring A] → [Algebra k A] → (M : ModuleCat A) → Module k ↑M | true |
Lean.Doc.Part.rec | Lean.DocString.Types | {i : Type u} →
{b : Type v} →
{p : Type w} →
{motive_1 : Lean.Doc.Part i b p → Sort u_1} →
{motive_2 : Array (Lean.Doc.Part i b p) → Sort u_1} →
{motive_3 : List (Lean.Doc.Part i b p) → Sort u_1} →
((title : Array (Lean.Doc.Inline i)) →
(titleString : String) →
(metadata : Option p) →
(content : Array (Lean.Doc.Block i b)) →
(subParts : Array (Lean.Doc.Part i b p)) →
motive_2 subParts →
motive_1
{ title := title, titleString := titleString, metadata := metadata, content := content,
subParts := subParts }) →
((toList : List (Lean.Doc.Part i b p)) → motive_3 toList → motive_2 { toList := toList }) →
motive_3 [] →
((head : Lean.Doc.Part i b p) →
(tail : List (Lean.Doc.Part i b p)) → motive_1 head → motive_3 tail → motive_3 (head :: tail)) →
(t : Lean.Doc.Part i b p) → motive_1 t | false |
UniformOnFun.topologicalSpace | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | (α : Type u_1) → (β : Type u_2) → [UniformSpace β] → (𝔖 : Set (Set α)) → TopologicalSpace (UniformOnFun α β 𝔖) | true |
AffineMap.instAddTorsor | Mathlib.LinearAlgebra.AffineSpace.AffineMap | {k : Type u_1} →
{V1 : Type u_2} →
{P1 : Type u_3} →
{V2 : Type u_4} →
{P2 : Type u_5} →
[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] → AddTorsor (P1 →ᵃ[k] V2) (P1 →ᵃ[k] P2) | true |
instTransEq_1 | Init.Prelude | {α : Sort u_1} → {β : Sort u_2} → (r : α → β → Sort u) → Trans r Eq r | true |
Std.TreeMap.isSome_maxKey?_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t → t.maxKey?.isSome = true | true |
alternatingGroup.eq_bot_of_card_le_two | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], Fintype.card α ≤ 2 → alternatingGroup α = ⊥ | true |
_private.Mathlib.Tactic.FunProp.Core.0.Mathlib.Meta.FunProp.synthesizeArgs.match_4 | Mathlib.Tactic.FunProp.Core | (motive : Option Lean.Expr → Sort u_1) →
(__do_lift : Option Lean.Expr) →
((proof : Lean.Expr) → motive (some proof)) → ((x : Option Lean.Expr) → motive x) → motive __do_lift | false |
CategoryTheory.SemilatticeInf.braidedCategory | Mathlib.CategoryTheory.Monoidal.Cartesian.InfSemilattice | (C : Type u) → [inst : SemilatticeInf C] → [inst_1 : OrderTop C] → CategoryTheory.BraidedCategory C | true |
AddMonoidHom.sub_apply | Mathlib.Algebra.Group.Hom.Basic | ∀ {M : Type u_2} {G : Type u_5} [inst : AddZeroClass M] [inst_1 : AddCommGroup G] (f g : M →+ G) (x : M),
(f - g) x = f x - g x | true |
Filter.addAction._proof_2 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid α] [inst_1 : AddAction α β] (x x_1 : Filter α) (x_2 : Filter β),
Filter.map₂ (fun x1 x2 => x1 +ᵥ x2) (Filter.map₂ (fun x1 x2 => x1 + x2) x x_1) x_2 =
Filter.map₂ (fun x1 x2 => x1 +ᵥ x2) x (Filter.map₂ (fun x1 x2 => x1 +ᵥ x2) x_1 x_2) | false |
Nat.succPNat_strictMono | Mathlib.Data.PNat.Basic | StrictMono Nat.succPNat | true |
Quiver.Path.cons.noConfusion | Mathlib.Combinatorics.Quiver.Path | {V : Type u} →
{inst : Quiver V} →
{a : V} →
{P : Sort u_1} →
{b c : V} →
{a_1 : Quiver.Path a b} →
{a_2 : b ⟶ c} →
{b' c' : V} →
{a' : Quiver.Path a b'} →
{a'_1 : b' ⟶ c'} →
c = c' → a_1.cons a_2 ≍ a'.cons a'_1 → (b ≍ b' → c ≍ c' → a_1 ≍ a' → a_2 ≍ a'_1 → P) → P | false |
Std.ExtDTreeMap.getKey!_map | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited α] {f : (a : α) → β a → γ a} {k : α},
(Std.ExtDTreeMap.map f t).getKey! k = t.getKey! k | true |
CategoryTheory.Pseudofunctor.StrongTrans.Modification.vcomp | Mathlib.CategoryTheory.Bicategory.Modification.Pseudo | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.Pseudofunctor B C} →
{η θ ι : F ⟶ G} →
CategoryTheory.Pseudofunctor.StrongTrans.Modification η θ →
CategoryTheory.Pseudofunctor.StrongTrans.Modification θ ι →
CategoryTheory.Pseudofunctor.StrongTrans.Modification η ι | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_maxKeyD._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Std.DTreeMap.Internal.Impl.get!_inter_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h₁ : m₁.WF),
m₂.WF →
∀ {k : α} [inst_1 : Inhabited (β k)],
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter m₂ ⋯).get! k = default | true |
Nat.mem_factoredNumbers_iff_forall_le | Mathlib.NumberTheory.SmoothNumbers | ∀ {s : Finset ℕ} {m : ℕ}, m ∈ Nat.factoredNumbers s ↔ m ≠ 0 ∧ ∀ p ≤ m, Nat.Prime p → p ∣ m → p ∈ s | true |
Module.End.mem_genEigenspace | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ∞} {x : M}, x ∈ (f.genEigenspace μ) k ↔ ∃ l, ↑l ≤ k ∧ x ∈ ((f - μ • 1) ^ l).ker | true |
CategoryTheory.ComposableArrows.isoMk₄_hom | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {f g : CategoryTheory.ComposableArrows C 4}
(app₀ : f.obj' 0 _proof_353✝ ≅ g.obj' 0 _proof_353✝¹) (app₁ : f.obj' 1 _proof_354✝ ≅ g.obj' 1 _proof_354✝¹)
(app₂ : f.obj' 2 _proof_355✝ ≅ g.obj' 2 _proof_355✝¹) (app₃ : f.obj' 3 _proof_356✝ ≅ g.obj' 3 _proof_356✝¹)
(app₄ : f.obj' 4 _proof_357✝ ≅ g.obj' 4 _proof_357✝¹)
(w₀ :
CategoryTheory.CategoryStruct.comp (f.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_354✝²)
app₁.hom =
CategoryTheory.CategoryStruct.comp app₀.hom
(g.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proof_354✝³))
(w₁ :
CategoryTheory.CategoryStruct.comp (f.map' 1 2 _proof_238✝ _proof_355✝²) app₂.hom =
CategoryTheory.CategoryStruct.comp app₁.hom (g.map' 1 2 _proof_238✝¹ _proof_355✝³))
(w₂ :
CategoryTheory.CategoryStruct.comp (f.map' 2 3 _proof_291✝ _proof_356✝²) app₃.hom =
CategoryTheory.CategoryStruct.comp app₂.hom (g.map' 2 3 _proof_291✝¹ _proof_356✝³))
(w₃ :
CategoryTheory.CategoryStruct.comp (f.map' 3 4 _proof_356✝⁴ _proof_357✝²) app₄.hom =
CategoryTheory.CategoryStruct.comp app₃.hom (g.map' 3 4 _proof_356✝⁵ _proof_357✝³)),
(CategoryTheory.ComposableArrows.isoMk₄ app₀ app₁ app₂ app₃ app₄ w₀ w₁ w₂ w₃).hom =
CategoryTheory.ComposableArrows.homMk₄ app₀.hom app₁.hom app₂.hom app₃.hom app₄.hom w₀ w₁ w₂ w₃ | true |
Lean.KeyedDeclsAttribute.AttributeEntry._sizeOf_inst | Lean.KeyedDeclsAttribute | (γ : Type) → [SizeOf γ] → SizeOf (Lean.KeyedDeclsAttribute.AttributeEntry γ) | false |
CoheytingHom.map_top' | Mathlib.Order.Heyting.Hom | ∀ {α : Type u_6} {β : Type u_7} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (self : CoheytingHom α β),
self.toFun ⊤ = ⊤ | true |
Dyadic.mul_zero | Init.Data.Dyadic.Basic | ∀ (x : Dyadic), x * 0 = 0 | true |
SemimoduleCat.forget₂_obj | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ (R : Type u) [inst : Semiring R] (X : SemimoduleCat R),
(CategoryTheory.forget₂ (SemimoduleCat R) AddCommMonCat).obj X = AddCommMonCat.of ↑X | true |
Lean.Compiler.LCNF.FixedParams.mkAssignment | Lean.Compiler.LCNF.FixedParams | Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.pure →
Array Lean.Compiler.LCNF.FixedParams.AbsValue → Lean.FVarIdMap Lean.Compiler.LCNF.FixedParams.AbsValue | true |
ULift.instT3Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T3Space X], T3Space (ULift.{u_3, u_1} X) | true |
ArithmeticFunction.sum_eq_iff_sum_smul_moebius_eq | Mathlib.NumberTheory.ArithmeticFunction.Moebius | ∀ {R : Type u_1} [inst : AddCommGroup R] {f g : ℕ → R},
(∀ n > 0, ∑ i ∈ n.divisors, f i = g n) ↔
∀ n > 0, ∑ x ∈ n.divisorsAntidiagonal, ArithmeticFunction.moebius x.1 • g x.2 = f n | true |
skyscraperPresheafCoconeIsColimitOfNotSpecializes.match_1 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) {y : ↑X} (motive : (∃ S, IsOpen S ∧ y ∈ S ∧ p₀ ∉ S) → Prop)
(x : ∃ S, IsOpen S ∧ y ∈ S ∧ p₀ ∉ S), (∀ (U : Set ↑X) (ho : IsOpen U) (h₀ : y ∈ U) (hy : p₀ ∉ U), motive ⋯) → motive x | false |
_private.Mathlib.Algebra.Order.Nonneg.Lattice.0.Nonneg.noMaxOrder._proof_1 | Mathlib.Algebra.Order.Nonneg.Lattice | ∀ {α : Type u_1} [inst : PartialOrder α] [NoMaxOrder α] {a : α}, NoMaxOrder { x // a ≤ x } | false |
_private.Mathlib.Order.Filter.Pi.0.Filter.mem_pi._simp_1_3 | Mathlib.Order.Filter.Pi | ∀ {α : Type u_1} {β : Type u_2} {g : Filter β} {m : α → β} {s : Set α}, (s ∈ Filter.comap m g) = ∃ t ∈ g, m ⁻¹' t ⊆ s | false |
_private.Mathlib.Topology.UrysohnsLemma.0.Urysohns.CU.approx.match_1.splitter | Mathlib.Topology.UrysohnsLemma | {X : Type u_1} →
[inst : TopologicalSpace X] →
{P : Set X → Set X → Prop} →
(motive : ℕ → Urysohns.CU P → X → Sort u_2) →
(x : ℕ) →
(x_1 : Urysohns.CU P) →
(x_2 : X) →
((c : Urysohns.CU P) → (x : X) → motive 0 c x) →
((n : ℕ) → (c : Urysohns.CU P) → (x : X) → motive n.succ c x) → motive x x_1 x_2 | true |
Submonoid.LocalizationMap.ofMulEquivOfDom_apply | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {T : Submonoid P} {k : P ≃* M}
(H : Submonoid.map k.toMonoidHom T = S) (x : P), (f.ofMulEquivOfDom H) x = f (k x) | true |
CategoryTheory.Oplax.LaxTrans.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} [inst_2 : SizeOf B] [inst_3 : SizeOf C] (app : (a : B) → F.obj a ⟶ G.obj a)
(naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (app a) (G.map f) ⟶ CategoryTheory.CategoryStruct.comp (F.map f) (app b))
(naturality_naturality :
autoParam
(∀ {a b : B} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.CategoryStruct.comp (naturality f) (CategoryTheory.Bicategory.whiskerRight (F.map₂ η) (app b)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (app a) (G.map₂ η)) (naturality g))
CategoryTheory.Oplax.LaxTrans.naturality_naturality._autoParam)
(naturality_id :
autoParam
(∀ (a : B),
CategoryTheory.CategoryStruct.comp (naturality (CategoryTheory.CategoryStruct.id a))
(CategoryTheory.Bicategory.whiskerRight (F.mapId a) (app a)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapId a))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.rightUnitor (app a)).hom
(CategoryTheory.Bicategory.leftUnitor (app a)).inv))
CategoryTheory.Oplax.LaxTrans.naturality_id._autoParam)
(naturality_comp :
autoParam
(∀ {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (naturality (CategoryTheory.CategoryStruct.comp f g))
(CategoryTheory.Bicategory.whiskerRight (F.mapComp f g) (app c)) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (app a) (G.mapComp f g))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.associator (app a) (G.map f) (G.map g)).inv
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight (naturality f) (G.map g))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator (F.map f) (app b) (G.map g)).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft (F.map f) (naturality g))
(CategoryTheory.Bicategory.associator (F.map f) (F.map g) (app c)).inv)))))
CategoryTheory.Oplax.LaxTrans.naturality_comp._autoParam),
sizeOf
{ app := app, naturality := naturality, naturality_naturality := naturality_naturality,
naturality_id := naturality_id, naturality_comp := naturality_comp } =
1 | true |
Lean.Parser.Attr.extern._regBuiltin.Lean.Parser.Attr.externEntry.formatter_7 | Lean.Parser.Attr | IO Unit | false |
MeasureTheory.IsFundamentalDomain.setIntegral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} {E : Type u_5} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α]
[inst_3 : NormedAddCommGroup E] {s : Set α} {μ : MeasureTheory.Measure α} [MeasurableConstSMul G α]
[MeasureTheory.SMulInvariantMeasure G α μ] [Countable G] [inst_7 : NormedSpace ℝ E],
MeasureTheory.IsFundamentalDomain G s μ →
∀ {f : α → E} {t : Set α},
MeasureTheory.IntegrableOn f t μ → ∫ (x : α) in t, f x ∂μ = ∑' (g : G), ∫ (x : α) in g • t ∩ s, f (g⁻¹ • x) ∂μ | true |
BoundedContinuousFunction.instNonUnitalRing._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NonUnitalSeminormedRing R]
(a b c : BoundedContinuousFunction α R), a * (b + c) = a * b + a * c | false |
SeminormedCommGroup.ctorIdx | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → SeminormedCommGroup E → ℕ | false |
MeasurableSet | Mathlib.MeasureTheory.MeasurableSpace.Defs | {α : Type u_1} → [MeasurableSpace α] → Set α → Prop | true |
MultilinearMap.domCoprod_alternization_coe | Mathlib.LinearAlgebra.Alternating.DomCoprod | ∀ {ιa : Type u_1} {ιb : Type u_2} [inst : Fintype ιa] [inst_1 : Fintype ιb] {R' : Type u_3} {Mᵢ : Type u_4}
{N₁ : Type u_5} {N₂ : Type u_6} [inst_2 : CommSemiring R'] [inst_3 : AddCommGroup N₁] [inst_4 : Module R' N₁]
[inst_5 : AddCommGroup N₂] [inst_6 : Module R' N₂] [inst_7 : AddCommMonoid Mᵢ] [inst_8 : Module R' Mᵢ]
[inst_9 : DecidableEq ιa] [inst_10 : DecidableEq ιb] (a : MultilinearMap R' (fun x => Mᵢ) N₁)
(b : MultilinearMap R' (fun x => Mᵢ) N₂),
(↑(MultilinearMap.alternatization a)).domCoprod ↑(MultilinearMap.alternatization b) =
∑ σa,
∑ σb,
Equiv.Perm.sign σa •
Equiv.Perm.sign σb • (MultilinearMap.domDomCongr σa a).domCoprod (MultilinearMap.domDomCongr σb b) | true |
Differentiable.fun_pow | Mathlib.Analysis.Calculus.FDeriv.Pow | ∀ {𝕜 : Type u_1} {𝔸 : Type u_2} {E : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing 𝔸]
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedAlgebra 𝕜 𝔸] [inst_4 : NormedSpace 𝕜 E] {f : E → 𝔸},
Differentiable 𝕜 f → ∀ (n : ℕ), Differentiable 𝕜 fun x => f x ^ n | true |
Equiv.Perm.subtypePerm._proof_4 | Mathlib.Algebra.Group.End | ∀ {α : Type u_1} {p : α → Prop} (f : Equiv.Perm α), (∀ (x : α), p (f x) ↔ p x) → ∀ (x : { x // p x }), p (f ↑x) | false |
FreeAlgebra.equivMonoidAlgebraFreeMonoid._proof_2 | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R],
((MonoidAlgebra.lift R (FreeAlgebra R X) (FreeMonoid X)) (FreeMonoid.lift (FreeAlgebra.ι R))).comp
((FreeAlgebra.lift R) fun x => (MonoidAlgebra.of R (FreeMonoid X)) (FreeMonoid.of x)) =
AlgHom.id R (FreeAlgebra R X) | false |
CategoryTheory.ShortComplex.RightHomologyData.mapRightHomologyIso_eq | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {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.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C} (hr : S.RightHomologyData)
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] [inst_5 : S.HasRightHomology]
[inst_6 : F.PreservesRightHomologyOf S],
S.mapRightHomologyIso F = (hr.map F).rightHomologyIso ≪≫ F.mapIso hr.rightHomologyIso.symm | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Clause.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.folder.match_1.eq_2 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ (motive : Option Bool → Sort u_1) (x : Option Bool) (h_1 : (val' : Bool) → motive (some val'))
(h_2 : (x : Option Bool) → motive x),
(∀ (val' : Bool), x = some val' → False) →
(match x with
| some val' => h_1 val'
| x => h_2 x) =
h_2 x | true |
ContinuousLinearEquiv.submoduleMap_apply | Mathlib.Topology.Algebra.Module.Equiv | ∀ {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 : TopologicalSpace M] [inst_4 : AddCommMonoid M₂] [inst_5 : TopologicalSpace M₂]
{module_M : Module R M} {module_M₂ : Module R₂ M₂} {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁}
{re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (e : M ≃SL[σ₁₂] M₂) (p : Submodule R M) (x : ↥p), ↑((e.submoduleMap p) x) = e ↑x | true |
CategoryTheory.CostructuredArrow.isEquivalence_toOver | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D T) (X : T) [F.IsEquivalence],
(CategoryTheory.CostructuredArrow.toOver F X).IsEquivalence | true |
_private.Mathlib.GroupTheory.SpecificGroups.Quaternion.0.QuaternionGroup.inv | Mathlib.GroupTheory.SpecificGroups.Quaternion | {n : ℕ} → QuaternionGroup n → QuaternionGroup n | true |
Qq.instantiateMVarsQ | Qq.MetaM | {u : Lean.Level} → {α : Q(Sort u)} → Q(«$α») → Lean.MetaM Q(«$α») | true |
_private.Lean.Compiler.IR.EmitLLVM.0.Lean.IR.EmitLLVM.emitFnDecls.match_1 | Lean.Compiler.IR.EmitLLVM | (motive : Option String → Sort u_1) →
(x : Option String) → ((cName : String) → motive (some cName)) → (Unit → motive none) → motive x | false |
Matroid.Loopless.mk._flat_ctor | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α}, M.loops = ∅ → M.Loopless | false |
Filter.inv_le_self | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : InvolutiveInv α] {f : Filter α}, f⁻¹ ≤ f ↔ f⁻¹ = f | true |
Std.HashMap.Raw.getKey?_modify_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k : α} {f : β → β}, m.WF → (m.modify k f).getKey? k = if k ∈ m then some k else none | true |
LinearMap.extendScalarsOfIsLocalizationEquiv._proof_6 | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} [inst : CommSemiring R] (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Module A N] [IsScalarTower R A N], SMulCommClass R A N | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_twoPow._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {i w : ℕ}, i < w → i = w - 1 → ¬0 < w → False | false |
_private.Mathlib.Algebra.Lie.Weights.Cartan.0.LieAlgebra.mem_corootSpace'._simp_1_7 | Mathlib.Algebra.Lie.Weights.Cartan | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
Nat.xor_lt_two_pow | Init.Data.Nat.Bitwise.Lemmas | ∀ {x y n : ℕ}, x < 2 ^ n → y < 2 ^ n → x ^^^ y < 2 ^ n | true |
Manifold.IsImmersionAtOfComplement.instNormedAddCommGroupSmallComplement._aux_39 | Mathlib.Geometry.Manifold.Immersion | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_3} →
{E'' : Type u_1} →
{F : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup E''] →
[inst_4 : NormedSpace 𝕜 E''] →
[inst_5 : NormedAddCommGroup F] →
[inst_6 : NormedSpace 𝕜 F] →
{H : Type u_5} →
[inst_7 : TopologicalSpace H] →
{G : Type u_6} →
[inst_8 : TopologicalSpace G] →
{I : ModelWithCorners 𝕜 E H} →
{J : ModelWithCorners 𝕜 E'' G} →
{M : Type u_7} →
[inst_9 : TopologicalSpace M] →
[inst_10 : ChartedSpace H M] →
{N : Type u_8} →
[inst_11 : TopologicalSpace N] →
[inst_12 : ChartedSpace G N] →
{n : WithTop ℕ∞} →
{f : M → N} →
{x : M} →
(hf : Manifold.IsImmersionAtOfComplement F I J n f x) →
Small.{u_1, u_4} F →
Filter (hf.smallComplement × hf.smallComplement) | false |
Finset.one_mem_inv_mul_iff | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Group α] {s t : Finset α}, 1 ∈ t⁻¹ * s ↔ ¬Disjoint s t | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel_congr_left.match_1_3 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u_1} {S : Stream'.WSeq (Computation α)} {a : α} (motive : (∃ c ∈ S, a ∈ c) → Prop) (x : ∃ c ∈ S, a ∈ c),
(∀ (s : Computation α) (sS : s ∈ S) (as : a ∈ s), motive ⋯) → motive x | false |
Simps.ProjectionRule | Mathlib.Tactic.Simps.Basic | Type | true |
CategoryTheory.Functor.pi._proof_4 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)] {D : I → Type u_5}
[inst_1 : (i : I) → CategoryTheory.Category.{u_4, u_5} (D i)] (F : (i : I) → CategoryTheory.Functor (C i) (D i))
{X Y Z : (i : I) → C i} (f : X ⟶ Y) (g : Y ⟶ Z),
(fun i => (F i).map (CategoryTheory.CategoryStruct.comp f g i)) =
CategoryTheory.CategoryStruct.comp (fun i => (F i).map (f i)) fun i => (F i).map (g i) | false |
AlgebraicGeometry.Scheme.geometricFiber._proof_4 | Mathlib.AlgebraicGeometry.Sites.Etale | ∀ (Ω : Type u_1) [inst : Field Ω] [IsSepClosed Ω] {S : AlgebraicGeometry.Scheme},
∀ R ∈ AlgebraicGeometry.Scheme.etaleTopology S,
∀ (f : AlgebraicGeometry.Spec (CommRingCat.of Ω) ⟶ S),
∃ Y f_1,
∃ (_ : R.arrows f_1),
∃ y, (CategoryTheory.coyoneda.obj (Opposite.op (AlgebraicGeometry.Spec (CommRingCat.of Ω)))).map f_1 y = f | false |
ack_inj_left | Mathlib.Computability.Ackermann | ∀ {m₁ m₂ n : ℕ}, ack m₁ n = ack m₂ n ↔ m₁ = m₂ | true |
solvable_of_ker_le_range | Mathlib.GroupTheory.Solvable | ∀ {G : Type u_1} [inst : Group G] {G' : Type u_3} {G'' : Type u_4} [inst_1 : Group G'] [inst_2 : Group G'']
(f : G' →* G) (g : G →* G''), g.ker ≤ f.range → ∀ [hG' : IsSolvable G'] [hG'' : IsSolvable G''], IsSolvable G | true |
StarMemClass.instStar._proof_1 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Star R] [inst_1 : SetLike S R] [hS : StarMemClass S R] (s : S) (r : ↥s),
star ↑r ∈ s | false |
_private.Mathlib.Algebra.Algebra.Subalgebra.Pointwise.0.Subalgebra.mul_toSubmodule_le._simp_1_1 | Mathlib.Algebra.Algebra.Subalgebra.Pointwise | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
{x : A}, (x ∈ Subalgebra.toSubmodule S) = (x ∈ S) | false |
Set.forall_neg_mem._simp_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : InvolutiveNeg α] {s : Set α} {p : α → Prop}, (∀ (x : α), -x ∈ s → p x) = ∀ x ∈ s, p (-x) | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_151 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (rw : ℕ)
(rlhs : Std.Tactic.BVDecide.BVExpr w) (rrhs : Std.Tactic.BVDecide.BVExpr rw),
¬hash (llhs.arithShiftRight lrhs) ≠ hash (rlhs.arithShiftRight rrhs) →
∀ (h1 : lw = rw), ¬h1 ▸ lrhs = rrhs → ¬llhs.arithShiftRight lrhs = rlhs.arithShiftRight rrhs | false |
_private.Std.Time.DateTime.PlainDateTime.0.Std.Time.instLawfulEqOrdPlainDateTime._simp_1 | Std.Time.DateTime.PlainDateTime | ∀ {α : Sort u_1} {cmp₁ cmp₂ : α → α → Ordering} {a b : α},
(compareLex cmp₁ cmp₂ a b = Ordering.eq) = (cmp₁ a b = Ordering.eq ∧ cmp₂ a b = Ordering.eq) | false |
Valuation.exists_div_eq_of_surjective | Mathlib.Topology.Algebra.Valued.WithVal | ∀ {K : Type u_7} [inst : Field K] {Γ₀ : Type u_8} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation K Γ₀},
Function.Surjective ⇑v → ∀ (γ : Γ₀ˣ), ∃ r s, 0 < v r ∧ 0 < v s ∧ v r / v s = ↑γ | true |
Int32.and_neg_one | Init.Data.SInt.Bitwise | ∀ {a : Int32}, a &&& -1 = a | true |
Field.embEquivOfAdjoinSplits._proof_4 | Mathlib.FieldTheory.SeparableDegree | ∀ (F : Type u_3) (E : Type u_1) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type u_2)
[inst_3 : Field K] [inst_4 : Algebra F K] {S : Set E},
IntermediateField.adjoin F S = ⊤ →
(∀ s ∈ S, IsIntegral F s ∧ (Polynomial.map (algebraMap F K) (minpoly F s)).Splits) →
Algebra.IsAlgebraic F E → Nonempty (Field.Emb F E ≃ (E →ₐ[F] K)) | false |
ONote.split_dvd | Mathlib.SetTheory.Ordinal.Notation | ∀ {o o' : ONote} {m : ℕ} [o.NF], o.split = (o', m) → Ordinal.omega0 ∣ o'.repr | true |
CommRingCat.piFanIsLimit._proof_1 | Mathlib.Algebra.Category.Ring.Constructions | ∀ {ι : Type u_1} (R : ι → CommRingCat) (s : CategoryTheory.Limits.Cone (CategoryTheory.Discrete.functor R))
(i : CategoryTheory.Discrete ι),
CategoryTheory.CategoryStruct.comp (CommRingCat.ofHom (Pi.ringHom fun i => CommRingCat.Hom.hom (s.π.app { as := i })))
((CommRingCat.piFan R).π.app i) =
s.π.app i | false |
Std.Rxo.Iterator.step_eq_step | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LT α] [inst_2 : DecidableLT α] {it : Std.Iter α},
it.step = ⟨Std.Rxo.Iterator.step it, ⋯⟩ | true |
isProperMap_dist | Mathlib.Topology.MetricSpace.ProperSpace.Lemmas | ∀ {α : Type u_1} [inst : PseudoMetricSpace α] [ProperSpace α] (x : α), IsProperMap (dist x) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.