name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Finset.UV.isInitSeg_of_compressed | Mathlib.Combinatorics.SetFamily.KruskalKatona | ∀ {α : Type u_1} [inst : LinearOrder α] {ℬ : Finset (Finset α)} {r : ℕ},
Set.Sized r ↑ℬ →
(∀ (U V : Finset α), Finset.UV.UsefulCompression✝ U V → UV.IsCompressed U V ℬ) → Finset.Colex.IsInitSeg ℬ r |
Lean.Grind.Config.noConfusion | Init.Grind.Config | {P : Sort u} → {t t' : Lean.Grind.Config} → t = t' → Lean.Grind.Config.noConfusionType P t t' |
Lean.Exception.toMessageData | Lean.Exception | Lean.Exception → Lean.MessageData |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.toTree._sparseCasesOn_3 | Lean.Elab.Extra | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {k : ℕ} {c : Lean.Meta.Grind.Arith.Linear.EqCnstr} {k_1 : ℕ} {c_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr},
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff k c = Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff k_1 c_1 →
k = k_1 ∧ c = c_1 |
CategoryTheory.Presieve.CoverByImageStructure.noConfusionType | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{G : CategoryTheory.Functor C D} →
{V U : D} →
{f : V ⟶ U} →
CategoryTheory.Presieve.CoverByImageStructure G f →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{D' : Type u_2} →
[inst'_1 : CategoryTheory.Category.{v_2, u_2} D'] →
{G' : CategoryTheory.Functor C' D'} →
{V' U' : D'} → {f' : V' ⟶ U'} → CategoryTheory.Presieve.CoverByImageStructure G' f' → Sort u |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.mem_succ_succ_iff._simp_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b |
Module.End.instSemiring._proof_5 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M →ₗ[R] M),
g ∘ₗ 0 = 0 |
_private.Mathlib.LinearAlgebra.LinearIndependent.Defs.0.Fintype.not_linearIndependent_iffₒₛ._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : LinearOrder R] [CanonicallyOrderedAdd R] [AddRightReflectLE R] [IsCancelAdd M]
[inst_7 : DecidableEq ι] [inst_8 : Fintype ι],
LinearIndependent R v = ∀ (t : Finset ι) (f : ι → R), ∑ i ∈ t, f i • v i = ∑ i ∈ tᶜ, f i • v i → ∀ (i : ι), f i = 0 |
Finsupp.equivMapDomain_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (l : α →₀ M) (b : β),
(Finsupp.equivMapDomain f l) b = l (f.symm b) |
SemilatInfCat.of | Mathlib.Order.Category.Semilat | (X : Type u) → [isSemilatticeInf : SemilatticeInf X] → [isOrderTop : OrderTop X] → SemilatInfCat |
Bimod.tensorBimod | Mathlib.CategoryTheory.Monoidal.Bimod | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.Limits.HasCoequalizers C] →
[∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorLeft X)] →
[∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, v₁, v₁, u₁, u₁}
(CategoryTheory.MonoidalCategory.tensorRight X)] →
{X Y Z : CategoryTheory.Mon C} → Bimod X Y → Bimod Y Z → Bimod X Z |
Function.mem_ptsOfPeriod | Mathlib.Dynamics.PeriodicPts.Defs | ∀ {α : Type u_1} {f : α → α} {x : α} {n : ℕ}, x ∈ Function.ptsOfPeriod f n ↔ Function.IsPeriodicPt f n x |
_private.Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty.0.SimplexCategory.Truncated.morphismProperty_eq_top._proof_1_6 | Mathlib.AlgebraicTopology.SimplexCategory.MorphismProperty | ∀ {d : ℕ} (b : ℕ), b + 1 ≤ d → b < d |
UniformConvexOn.mono | Mathlib.Analysis.Convex.Strong | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {φ ψ : ℝ → ℝ} {s : Set E} {f : E → ℝ},
ψ ≤ φ → UniformConvexOn s φ f → UniformConvexOn s ψ f |
_private.Mathlib.RingTheory.WittVector.StructurePolynomial.0.eq_wittStructureInt._simp_1_1 | Mathlib.RingTheory.WittVector.StructurePolynomial | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {σ : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
[inst_2 : CommSemiring S₂] (f : R →+* S₁) (g : σ → S₂) (φ : S₁ →+* S₂) (p : MvPolynomial σ R),
(MvPolynomial.eval₂Hom (φ.comp f) g) p = (MvPolynomial.eval₂Hom φ g) ((MvPolynomial.map f) p) |
TotallyBounded.isSeparable | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} [uniformSpace : UniformSpace α] [(uniformity α).IsCountablyGenerated] {s : Set α},
TotallyBounded s → TopologicalSpace.IsSeparable s |
CategoryTheory.ShortComplex.opcyclesMap'_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData) (a : R),
CategoryTheory.ShortComplex.opcyclesMap' (a • φ) h₁ h₂ = a • CategoryTheory.ShortComplex.opcyclesMap' φ h₁ h₂ |
ProfiniteGrp.toLimit._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u_1}), CompactSpace ↥(ProfiniteGrp.limitConePtAux P.diagram) |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.toInt.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | sizeOf Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.toInt✝ = 1 |
Multiset.exists_cons_of_mem | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s : Multiset α} {a : α}, a ∈ s → ∃ t, s = a ::ₘ t |
mulMulHom_apply | Mathlib.Algebra.Group.Prod | ∀ {α : Type u_6} [inst : CommSemigroup α] (a : α × α), mulMulHom a = a.1 * a.2 |
Set.union_iUnion | Mathlib.Data.Set.Lattice | ∀ {β : Type u_2} {ι : Sort u_5} [Nonempty ι] (s : Set β) (t : ι → Set β), s ∪ ⋃ i, t i = ⋃ i, s ∪ t i |
CategoryTheory.Functor.sections_ext_iff | Mathlib.CategoryTheory.Types.Basic | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w)} {x y : ↑F.sections},
x = y ↔ ∀ (j : J), ↑x j = ↑y j |
_private.Mathlib.Topology.NhdsWithin.0.dense_pi._simp_1_1 | Mathlib.Topology.NhdsWithin | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, Dense s = (closure s = Set.univ) |
Filter.CardinalGenerateSets.rec | Mathlib.Order.Filter.CardinalInter | ∀ {α : Type u} {c : Cardinal.{u}} {g : Set (Set α)} {motive : (a : Set α) → Filter.CardinalGenerateSets g a → Prop},
(∀ {s : Set α} (a : s ∈ g), motive s ⋯) →
motive Set.univ ⋯ →
(∀ {s t : Set α} (a : Filter.CardinalGenerateSets g s) (a_1 : s ⊆ t), motive s a → motive t ⋯) →
(∀ {S : Set (Set α)} (a : Cardinal.mk ↑S < c) (a_1 : ∀ s ∈ S, Filter.CardinalGenerateSets g s),
(∀ (s : Set α) (a : s ∈ S), motive s ⋯) → motive (⋂₀ S) ⋯) →
∀ {a : Set α} (t : Filter.CardinalGenerateSets g a), motive a t |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Lookup.0.Lean.Meta.RefinedDiscrTree.evalNode.match_4 | Mathlib.Lean.Meta.RefinedDiscrTree.Lookup | (motive : Lean.Meta.RefinedDiscrTree.Key → Sort u_1) →
(key : Lean.Meta.RefinedDiscrTree.Key) →
((label : ℕ) → motive (Lean.Meta.RefinedDiscrTree.Key.labelledStar label)) →
(Unit → motive Lean.Meta.RefinedDiscrTree.Key.star) →
((x : Lean.Meta.RefinedDiscrTree.Key) → motive x) → motive key |
IicProdIoc_self | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] [inst_2 : DecidableLE ι] {X : ι → Type u_2}
[inst_3 : LocallyFiniteOrderBot ι] (a : ι), IicProdIoc a a = Prod.fst |
TopologicalSpace.Opens.coe_sup | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] (s t : TopologicalSpace.Opens α), ↑(s ⊔ t) = ↑s ∪ ↑t |
Std.Internal.IO.Process.PId.recOn | Std.Internal.Async.Process | {motive : Std.Internal.IO.Process.PId → Sort u} →
(t : Std.Internal.IO.Process.PId) → ((toUInt64 : UInt64) → motive { toUInt64 := toUInt64 }) → motive t |
_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Finset.Icc_ofNat_ofNat.match_10 | Mathlib.Tactic.Simproc.FinsetInterval | (em en : Q(ℕ)) →
(motive : (s : Q(Finset ℕ)) × Q(Finset.Icc «$em» «$en» = «$s») → Sort u_1) →
(__discr : (s : Q(Finset ℕ)) × Q(Finset.Icc «$em» «$en» = «$s»)) →
((es : Q(Finset ℕ)) → (p : Q(Finset.Icc «$em» «$en» = «$es»)) → motive ⟨es, p⟩) → motive __discr |
Set.exists_image_eq_and_injOn | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (f : α → β), ∃ u, f '' u = f '' s ∧ Set.InjOn f u |
_private.Mathlib.Data.Bool.Count.0.List.IsChain.count_not_le_count_add_one._proof_1_1 | Mathlib.Data.Bool.Count | ∀ (b x : Bool) (l : List Bool),
List.count b (x :: l) + 2 ≤ (List.filter (fun x => decide (x = !b)) (x :: l)).length →
List.count b (x :: l) + 1 < (List.filter (fun x => decide (x = !b)) (x :: l)).length |
Dioph.«_aux_Mathlib_NumberTheory_Dioph___macroRules_Dioph_term_D-__1» | Mathlib.NumberTheory.Dioph | Lean.Macro |
CategoryTheory.PreZeroHypercover.Relation.fst | Mathlib.CategoryTheory.Sites.Hypercover.Saturate | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S : C} → {E : CategoryTheory.PreZeroHypercover S} → {i j : E.I₀} → (self : E.Relation i j) → self.obj ⟶ E.X i |
CompactlyGeneratedSpace | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | (X : Type u) → [TopologicalSpace X] → Prop |
RingEquiv.ofNonUnitalRingHom._proof_1 | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_1} {S : Type u_2} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(hom : R →ₙ+* S) (inv : S →ₙ+* R),
inv.comp hom = NonUnitalRingHom.id R → ∀ (x : R), (inv.comp hom) x = (NonUnitalRingHom.id R) x |
CommSemiring.toCoalgebra._proof_7 | Mathlib.RingTheory.Coalgebra.Basic | ∀ (R : Type u_1) [inst : CommSemiring R],
↑(TensorProduct.assoc R R R R) ∘ₗ LinearMap.rTensor R ((TensorProduct.mk R R R) 1) ∘ₗ (TensorProduct.mk R R R) 1 =
↑(TensorProduct.assoc R R R R) ∘ₗ LinearMap.rTensor R ((TensorProduct.mk R R R) 1) ∘ₗ (TensorProduct.mk R R R) 1 |
UInt8.compare_eq_toNat_compare_toNat | Batteries.Data.UInt | ∀ (x y : UInt8), compare x y = compare x.toNat y.toNat |
unitInterval.symm.eq_1 | Mathlib.Topology.UnitInterval | ∀ (t : ↑unitInterval), unitInterval.symm t = ⟨1 - ↑t, ⋯⟩ |
fderiv_cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E},
DifferentiableAt ℝ f x → fderiv ℝ (fun x => Real.cos (f x)) x = -Real.sin (f x) • fderiv ℝ f x |
MonadWriterAdapter.mk._flat_ctor | Mathlib.Control.Monad.Writer | {ω : outParam (Type u)} → {m : Type u → Type v} → ({α : Type u} → (ω → ω) → m α → m α) → MonadWriterAdapter ω m |
dirichletSummandHom._proof_1 | Mathlib.NumberTheory.EulerProduct.DirichletLSeries | ∀ {s : ℂ} {n : ℕ} (χ : DirichletCharacter ℂ n), s ≠ 0 → χ ↑0 * ↑0 ^ (-s) = 0 |
_private.Mathlib.Analysis.CStarAlgebra.Basic.0.«term_⋆» | Mathlib.Analysis.CStarAlgebra.Basic | Lean.TrailingParserDescr |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.simpBetaApp.go.match_1 | Lean.Meta.Sym.Simp.Have | (motive : Lean.Meta.Sym.Simp.Result → Lean.Meta.Sym.Simp.Result → Sort u_1) →
(rf __do_lift : Lean.Meta.Sym.Simp.Result) →
((done done_1 : Bool) → motive (Lean.Meta.Sym.Simp.Result.rfl done) (Lean.Meta.Sym.Simp.Result.rfl done_1)) →
((f' hf : Lean.Expr) →
(done done_1 : Bool) →
motive (Lean.Meta.Sym.Simp.Result.step f' hf done) (Lean.Meta.Sym.Simp.Result.rfl done_1)) →
((done : Bool) →
(a' ha : Lean.Expr) →
(done_1 : Bool) →
motive (Lean.Meta.Sym.Simp.Result.rfl done) (Lean.Meta.Sym.Simp.Result.step a' ha done_1)) →
((f' hf : Lean.Expr) →
(done : Bool) →
(a' ha : Lean.Expr) →
(done_1 : Bool) →
motive (Lean.Meta.Sym.Simp.Result.step f' hf done) (Lean.Meta.Sym.Simp.Result.step a' ha done_1)) →
motive rf __do_lift |
CategoryTheory.BraidedCategory.Hexagon.functor₂₃₁'_map_app_app | Mathlib.CategoryTheory.Monoidal.Braided.Multifunctor | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(h : X ⟶ Y) (X_1 Y_1 : C),
(((CategoryTheory.BraidedCategory.Hexagon.functor₂₃₁' C).map h).app X_1).app Y_1 =
CategoryTheory.MonoidalCategoryStruct.whiskerLeft X_1 (CategoryTheory.MonoidalCategoryStruct.whiskerLeft Y_1 h) |
Down.erase_mem_compression | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {α : Type u_1} [inst : DecidableEq α] {𝒜 : Finset (Finset α)} {s : Finset α} {a : α},
s ∈ 𝒜 → s.erase a ∈ Down.compression a 𝒜 |
StructureGroupoid.subset_maximalAtlas | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(G : StructureGroupoid H) [HasGroupoid M G], atlas H M ⊆ StructureGroupoid.maximalAtlas M G |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.isEmpty_eq_false_iff_exists_containsKey._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [ReflBEq α] {l : List ((a : α) × β a)},
(l.isEmpty = false) = ∃ a, (Std.Internal.List.getEntry? a l).isSome = true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.mkIte.match_1 | Lean.Elab.Do.Legacy | (motive : Lean.Elab.Term.Do.CodeBlock × Lean.Elab.Term.Do.CodeBlock → Sort u_1) →
(__discr : Lean.Elab.Term.Do.CodeBlock × Lean.Elab.Term.Do.CodeBlock) →
((thenBranch elseBranch : Lean.Elab.Term.Do.CodeBlock) → motive (thenBranch, elseBranch)) → motive __discr |
Std.TreeMap.unitOfArray._auto_1 | Std.Data.TreeMap.Basic | Lean.Syntax |
SubMulAction.instCompleteLattice._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_2} {M : Type u_1} [inst : SMul R M], Function.Injective SetLike.coe |
CategoryTheory.Functor.flip₁₃._proof_12 | Mathlib.CategoryTheory.Functor.CurryingThree | ∀ {C₁ : Type u_2} {C₂ : Type u_6} {C₃ : Type u_8} {E : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_5, u_6} C₂] [inst_2 : CategoryTheory.Category.{u_7, u_8} C₃]
[inst_3 : CategoryTheory.Category.{u_3, u_4} E]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ E))) {X Y : C₃} (h : X ⟶ Y)
(X_1 : C₂) ⦃X_2 Y_1 : C₁⦄ (f : X_2 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
(({
obj := fun H =>
{ obj := fun K => ((F.obj K).obj H).obj X, map := fun {X_3 Y} f => ((F.map f).app H).app X,
map_id := ⋯, map_comp := ⋯ },
map := fun {X_3 Y} g => { app := fun X_4 => ((F.obj X_4).map g).app X, naturality := ⋯ }, map_id := ⋯,
map_comp := ⋯ }.obj
X_1).map
f)
(((F.obj Y_1).obj X_1).map h) =
CategoryTheory.CategoryStruct.comp (((F.obj X_2).obj X_1).map h)
(({
obj := fun H =>
{ obj := fun K => ((F.obj K).obj H).obj Y, map := fun {X Y_2} f => ((F.map f).app H).app Y,
map_id := ⋯, map_comp := ⋯ },
map := fun {X Y_2} g => { app := fun X_3 => ((F.obj X_3).map g).app Y, naturality := ⋯ }, map_id := ⋯,
map_comp := ⋯ }.obj
X_1).map
f) |
Lean.Parser.Priority.numPrio._regBuiltin.Lean.Parser.Priority.numPrio.declRange_3 | Lean.Parser.Attr | IO Unit |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.isProbabilityMeasure_tilted._simp_1_2 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) |
Subfield.topEquiv | Mathlib.Algebra.Field.Subfield.Basic | {K : Type u} → [inst : DivisionRing K] → ↥⊤ ≃+* K |
Group.ofLeftAxioms._proof_6 | Mathlib.Algebra.Group.MinimalAxioms | ∀ {G : Type u_1} [inst : Mul G] [inst_1 : Inv G] [inst_2 : One G] (n : ℕ) (a : G),
zpowRec npowRec (↑n.succ) a = zpowRec npowRec (↑n) a * a |
UniformSpace.isCompact_iff_isSeqCompact | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : TopologicalSpace X] [TopologicalSpace.PseudoMetrizableSpace X] {s : Set X},
IsCompact s ↔ IsSeqCompact s |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual.eq_def | Lean.Compiler.NameMangling | ∀ (s : String)
(x :
(_ : s.Pos) ×' (_ : Lean.Name) ×' ℕ ⊕'
(_ : s.Pos) ×' Lean.Name ⊕' (_ : s.Pos) ×' (_ : Lean.Name) ×' (_ : String) ×' ℕ),
Lean.Name.demangleAux.decodeNum._mutual✝ s x =
PSum.casesOn x
(fun _x =>
PSigma.casesOn _x fun p res =>
PSigma.casesOn res fun res n =>
if h : p = s.endPos then res.num n
else
have ch := p.get h;
have p := p.next h;
if ch.isDigit = true then
Lean.Name.demangleAux.decodeNum._mutual✝¹ s (PSum.inl ⟨p, ⟨res, n * 10 + (ch.val - 48).toNat⟩⟩)
else
have res := res.num n;
if h : p = s.endPos then res
else Lean.Name.demangleAux.decodeNum._mutual✝² s (PSum.inr (PSum.inl ⟨p.next h, res⟩)))
fun _x =>
PSum.casesOn _x
(fun _x =>
PSigma.casesOn _x fun p res =>
if h : p = s.endPos then res
else
let ch := p.get h;
let p_1 := p.next h;
if ch.isDigit = true then
if h_1 : ch = '0' ∧ ∃ (h : p_1 ≠ s.endPos), p_1.get h = '0' then
Lean.Name.demangleAux.decodeNum._mutual✝³ s (PSum.inr (PSum.inr ⟨p_1.next ⋯, ⟨res, ⟨"", 0⟩⟩⟩))
else Lean.Name.demangleAux.decodeNum._mutual✝⁴ s (PSum.inl ⟨p_1, ⟨res, (ch.val - 48).toNat⟩⟩)
else
if ch = '_' then Lean.Name.demangleAux.decodeNum._mutual✝⁵ s (PSum.inr (PSum.inr ⟨p_1, ⟨res, ⟨"", 1⟩⟩⟩))
else
Lean.Name.demangleAux.decodeNum._mutual✝⁶ s
(PSum.inr (PSum.inr ⟨p_1, ⟨res, ⟨String.singleton ch, 0⟩⟩⟩)))
fun _x =>
PSigma.casesOn _x fun p₀ res =>
PSigma.casesOn res fun res acc =>
PSigma.casesOn acc fun acc ucount =>
if hp₀ : p₀ = s.endPos then res.str (acc.pushn '_' (ucount / 2))
else
let ch := p₀.get hp₀;
let p := p₀.next hp₀;
if ch = '_' then
Lean.Name.demangleAux.decodeNum._mutual✝⁷ s (PSum.inr (PSum.inr ⟨p, ⟨res, ⟨acc, ucount + 1⟩⟩⟩))
else
if ucount % 2 = 0 then
Lean.Name.demangleAux.decodeNum._mutual✝⁸ s
(PSum.inr (PSum.inr ⟨p, ⟨res, ⟨(acc.pushn '_' (ucount / 2)).push ch, 0⟩⟩⟩))
else
if ch.isDigit = true then
have res := res.str (acc.pushn '_' (ucount / 2));
if h : ch = '0' ∧ ∃ (h : p ≠ s.endPos), p.get h = '0' then
Lean.Name.demangleAux.decodeNum._mutual✝⁹ s (PSum.inr (PSum.inr ⟨p.next ⋯, ⟨res, ⟨"", 0⟩⟩⟩))
else Lean.Name.demangleAux.decodeNum._mutual✝¹⁰ s (PSum.inl ⟨p, ⟨res, (ch.val - 48).toNat⟩⟩)
else
match ch, h₁ : Lean.parseLowerHex?✝ 2 s p 0 with
| 'x', some (q, v) =>
have acc := acc.pushn '_' (ucount / 2);
have this := ⋯;
Lean.Name.demangleAux.decodeNum._mutual✝¹¹ s
(PSum.inr (PSum.inr ⟨q, ⟨res, ⟨acc.push (Char.ofNat v), 0⟩⟩⟩))
| x, x_1 =>
match ch, h₂ : Lean.parseLowerHex?✝¹ 4 s p 0 with
| 'u', some (q, v) =>
have acc := acc.pushn '_' (ucount / 2);
have this := ⋯;
Lean.Name.demangleAux.decodeNum._mutual✝¹² s
(PSum.inr (PSum.inr ⟨q, ⟨res, ⟨acc.push (Char.ofNat v), 0⟩⟩⟩))
| x, x_2 =>
match ch, h₃ : Lean.parseLowerHex?✝² 8 s p 0 with
| 'U', some (q, v) =>
have acc := acc.pushn '_' (ucount / 2);
have this := ⋯;
Lean.Name.demangleAux.decodeNum._mutual✝¹³ s
(PSum.inr (PSum.inr ⟨q, ⟨res, ⟨acc.push (Char.ofNat v), 0⟩⟩⟩))
| x, x_3 =>
Lean.Name.demangleAux.decodeNum._mutual✝¹⁴ s
(PSum.inr (PSum.inr ⟨p, ⟨res.str acc, ⟨("".pushn '_' (ucount / 2)).push ch, 0⟩⟩⟩)) |
Runtime.markPersistent | Init.System.IO | {α : Type} → α → BaseIO α |
Array.foldr_pmap | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {xs : Array α} {P : α → Prop} {f : (a : α) → P a → β} (H : ∀ a ∈ xs, P a)
(g : β → γ → γ) (x : γ), Array.foldr g x (Array.pmap f xs H) = Array.foldr (fun a acc => g (f ↑a ⋯) acc) x xs.attach |
Complex.imAddGroupHom | Mathlib.Data.Complex.Basic | ℂ →+ ℝ |
HolderWith.smul | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoMetricSpace X] [inst_1 : SeminormedAddCommGroup Y] {C r : NNReal}
{f : X → Y} {α : Type u_4} [inst_2 : SeminormedAddCommGroup α] [inst_3 : SMulZeroClass α Y] [IsBoundedSMul α Y]
(a : α), HolderWith C r f → HolderWith (C * ‖a‖₊) r (a • f) |
CategoryTheory.SimplicialObject.whiskering_obj_obj_δ | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(F : CategoryTheory.Functor C D) (X : CategoryTheory.SimplicialObject C) {n : ℕ} (i : Fin (n + 2)),
(((CategoryTheory.SimplicialObject.whiskering C D).obj F).obj X).δ i = F.map (X.δ i) |
lowerHemicontinuousAt_iff_frequently | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → Set β} {x : α},
LowerHemicontinuousAt f x ↔ ∀ (t : Set β), IsClosed t → (∃ᶠ (x' : α) in nhds x, f x' ⊆ t) → f x ⊆ t |
FiniteArchimedeanClass.submodule._proof_1 | Mathlib.Algebra.Order.Module.Archimedean | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : Module K M] (k : K) {a : M}, ArchimedeanClass.mk a = ⊤ → ArchimedeanClass.mk (k • a) = ⊤ |
_private.Mathlib.Order.Monotone.MonovaryOrder.0.monovaryOn_iff_exists_antitoneOn._simp_1_2 | Mathlib.Order.Monotone.MonovaryOrder | ∀ {ι : Type u_1} {α : Type u_3} {β : Type u_4} [inst : LinearOrder α] [inst_1 : LinearOrder β] {f : ι → α} {g : ι → β}
{s : Set ι}, AntivaryOn f g s = ∃ x, MonotoneOn f s ∧ AntitoneOn g s |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m = ∅) = (m.isEmpty = true) |
MvPolynomial.eval_C | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {f : σ → R} (a : R), (MvPolynomial.eval f) (MvPolynomial.C a) = a |
RingInvo.mk'._proof_2 | Mathlib.RingTheory.RingInvo | ∀ {R : Type u_1} [inst : Semiring R] (f : R →+* Rᵐᵒᵖ) (x y : R), (↑↑f).toFun (x * y) = (↑↑f).toFun x * (↑↑f).toFun y |
Rep.unitIsoAddEquiv.eq_1 | Mathlib.RepresentationTheory.Rep | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Monoid G] {V : Rep k G},
Rep.unitIsoAddEquiv =
id (V.ρ.asModuleEquiv.symm.toAddEquiv.trans (RestrictScalars.addEquiv k (MonoidAlgebra k G) V.ρ.asModule).symm) |
Subspace.dualRestrict_comp_dualLift | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (W : Subspace K V),
Submodule.dualRestrict W ∘ₗ W.dualLift = 1 |
orderIsoShrink._proof_1 | Mathlib.Order.Shrink | ∀ (α : Type u_2) [inst : Small.{u_1, u_2} α] [inst_1 : Preorder α] {a b : α},
(equivShrink α) a ≤ (equivShrink α) b ↔ a ≤ b |
_private.Mathlib.Topology.MetricSpace.UniformConvergence.0.UniformFun.lipschitzOnWith_iff._simp_1_1 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {s : Set α}
{f : α → β}, LipschitzOnWith K f s = LipschitzWith K (s.restrict f) |
ContinuousAlgEquiv.continuous | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (e : A ≃A[R] B), Continuous ⇑e |
AkraBazziRecurrence.sumTransform_def | Mathlib.Computability.AkraBazzi.SumTransform | ∀ {p : ℝ} {g : ℝ → ℝ} {n₀ n : ℕ},
AkraBazziRecurrence.sumTransform p g n₀ n = ↑n ^ p * ∑ u ∈ Finset.Ico n₀ n, g ↑u / ↑u ^ (p + 1) |
Lean.Meta.Simp.mkEqTransOptProofResult | Lean.Meta.Tactic.Simp.Types | Option Lean.Expr → Bool → Lean.Meta.Simp.Result → Lean.MetaM Lean.Meta.Simp.Result |
CategoryTheory.Idempotents.Karoubi.Hom.comm._autoParam | Mathlib.CategoryTheory.Idempotents.Karoubi | Lean.Syntax |
Lean.CollectFVars.State.mk.sizeOf_spec | Lean.Util.CollectFVars | ∀ (visitedExpr : Lean.ExprSet) (fvarSet : Lean.FVarIdSet) (fvarIds : Array Lean.FVarId),
sizeOf { visitedExpr := visitedExpr, fvarSet := fvarSet, fvarIds := fvarIds } =
1 + sizeOf visitedExpr + sizeOf fvarSet + sizeOf fvarIds |
CompHausLike.LocallyConstant.sigmaIncl | Mathlib.Condensed.Discrete.LocallyConstant | {P : TopCat → Prop} →
[inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
{Q : CompHausLike P} →
{Z : Type (max u w)} →
(r : LocallyConstant (↑Q.toTop) Z) → (a : Function.Fiber ⇑r) → CompHausLike.LocallyConstant.fiber r a ⟶ Q |
Std.DHashMap.Raw.Const.getKey?_alter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF →
(Std.DHashMap.Raw.Const.alter m k f).getKey? k' =
if (k == k') = true then if (f (Std.DHashMap.Raw.Const.get? m k)).isSome = true then some k else none
else m.getKey? k' |
_private.Mathlib.Analysis.InnerProductSpace.Basic.0.dist_div_norm_sq_smul._simp_1_7 | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
CategoryTheory.isIso_iff_yoneda_map_bijective | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.IsIso f ↔ ∀ (T : C), Function.Bijective fun x => CategoryTheory.CategoryStruct.comp x f |
Sigma.curry_mul | Mathlib.Algebra.Group.Pi.Lemmas | ∀ {α : Type u_4} {β : α → Type u_5} {γ : (a : α) → β a → Type u_6} [inst : (a : α) → (b : β a) → Mul (γ a b)]
(x y : (i : (a : α) × β a) → γ i.fst i.snd), Sigma.curry (x * y) = Sigma.curry x * Sigma.curry y |
InverseSystem.PEquivOn.compat | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_6} {F : ι → Type u_7} {X : ι → Type u_8} [inst : LinearOrder ι] {f : ⦃i j : ι⦄ → i ≤ j → F j → F i}
[inst_1 : SuccOrder ι] {equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} {s : Set ι}
(self : InverseSystem.PEquivOn f equivSucc s) {i : ι} (hsi : Order.succ i ∈ s) (hi : ¬IsMax i)
(x : F ↑⟨Order.succ i, hsi⟩), (self.equiv ⟨Order.succ i, hsi⟩) x ⟨i, ⋯⟩ = ((equivSucc hi) x).2 |
Filter.tendsto_atTop_finset_of_monotone | Mathlib.Order.Filter.AtTopBot.Finset | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder β] {f : β → Finset α},
Monotone f → (∀ (x : α), ∃ n, x ∈ f n) → Filter.Tendsto f Filter.atTop Filter.atTop |
LocalSubring._sizeOf_inst | Mathlib.RingTheory.LocalRing.LocalSubring | (R : Type u_1) → {inst : CommRing R} → [SizeOf R] → SizeOf (LocalSubring R) |
AlgebraicGeometry.IsAffineOpen.fromSpecStalk | Mathlib.AlgebraicGeometry.Stalk | {X : AlgebraicGeometry.Scheme} →
{U : X.Opens} →
AlgebraicGeometry.IsAffineOpen U → {x : ↥X} → x ∈ U → (AlgebraicGeometry.Spec (X.presheaf.stalk x) ⟶ X) |
Lean.Elab.Term.ElabElim.Context.casesOn | Lean.Elab.App | {motive : Lean.Elab.Term.ElabElim.Context → Sort u} →
(t : Lean.Elab.Term.ElabElim.Context) →
((elimInfo : Lean.Elab.Term.ElabElimInfo) →
(expectedType : Lean.Expr) → motive { elimInfo := elimInfo, expectedType := expectedType }) →
motive t |
MeasureTheory.Measure.ext_of_Ioc' | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_5} [inst : TopologicalSpace α] {m : MeasurableSpace α} [SecondCountableTopology α]
[inst_2 : LinearOrder α] [OrderTopology α] [BorelSpace α] [NoMinOrder α] (μ ν : MeasureTheory.Measure α),
(∀ ⦃a b : α⦄, a < b → μ (Set.Ioc a b) ≠ ⊤) → (∀ ⦃a b : α⦄, a < b → μ (Set.Ioc a b) = ν (Set.Ioc a b)) → μ = ν |
ULift.module._proof_3 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : ULift.{u_1, u_2} R), a • 0 = 0 |
Lean.Elab.Command.State.infoState._default | Lean.Elab.Command | Lean.Elab.InfoState |
Mathlib.Tactic.BicategoryLike.Atom.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {P : Sort u} →
{t t' : Mathlib.Tactic.BicategoryLike.Atom} → t = t' → Mathlib.Tactic.BicategoryLike.Atom.noConfusionType P t t' |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.cancel_natIso_inv_left._simp_1_2 | Mathlib.CategoryTheory.NatIso | ∀ {α : Sort u_1} {r : α → α → Prop} [Std.Refl r] (a : α), r a a = True |
DirectLimit.instDivisionSemiring._proof_18 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → DivisionSemiring (G i)] [inst_6 : ∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)]
(n : ℕ), ↑(n + 1) = ↑n + 1 |
_private.Mathlib.Geometry.Manifold.Riemannian.PathELength.0.Manifold.lintegral_norm_mfderiv_Icc_eq_pathELength_projIcc._simp_1_1 | Mathlib.Geometry.Manifold.Riemannian.PathELength | ∀ {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] {x y : ℝ}
[h : Fact (x < y)] {f : ↑(Set.Icc x y) → M} {w : ↑(Set.Icc x y)},
(mfderiv% f w) 1 = (mfderivWithin (modelWithCornersSelf ℝ ℝ) I (f ∘ Set.projIcc x y ⋯) (Set.Icc x y) ↑w) 1 |
Filter.HasBasis.uniformity_closeds | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] {ι : Sort u_3} {p : ι → Prop} {s : ι → Set (α × α)},
(uniformity α).HasBasis p s →
(uniformity (TopologicalSpace.Closeds α)).HasBasis p fun i =>
Prod.map SetLike.coe SetLike.coe ⁻¹' hausdorffEntourage (s i) |
NumberField.mixedEmbedding.fundamentalCone.expMap_single | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | {K : Type u_1} → [inst : Field K] → NumberField.InfinitePlace K → OpenPartialHomeomorph ℝ ℝ |
SupHom.coe_top | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Max α] [inst_1 : SemilatticeSup β] [inst_2 : Top β], ⇑⊤ = ⊤ |
Valued.hasBasis_uniformity | Mathlib.Topology.Algebra.Valued.ValuationTopology | ∀ (R : Type u) [inst : Ring R] (Γ₀ : Type v) [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [_i : Valued R Γ₀],
(uniformity R).HasBasis (fun x => True) fun γ => {p | Valued.v.restrict (p.2 - p.1) < ↑γ} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.