name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
IsContDiffImplicitAt.implicitFunctionData._proof_7 | Mathlib.Analysis.Calculus.ImplicitContDiff | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F],
(↑(ContinuousLinearMap.fst 𝕜 E F)).range = ⊤ |
Lean.Server.Test.Runner.Client.WidgetInstance.mk.injEq | Lean.Server.Test.Runner | ∀ (id : Lean.Name) (javascriptHash : UInt64) (props : Lean.Json) (id_1 : Lean.Name) (javascriptHash_1 : UInt64)
(props_1 : Lean.Json),
({ id := id, javascriptHash := javascriptHash, props := props } =
{ id := id_1, javascriptHash := javascriptHash_1, props := props_1 }) =
(id = id_1 ∧ javascriptHash = javascriptHash_1 ∧ props = props_1) |
_private.Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs.0.«_aux_Mathlib_Algebra_Order_GroupWithZero_Unbundled_Defs___macroRules__private_Mathlib_Algebra_Order_GroupWithZero_Unbundled_Defs_0_termα>0_1» | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | Lean.Macro |
_private.Mathlib.Data.Nat.Squarefree.0.Nat.minSqFacAux.match_1._arg_pusher | Mathlib.Data.Nat.Squarefree | ∀ (motive : ℕ → ℕ → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x) (rel : ℕ → ℕ → α → Prop) (x x_1 : ℕ)
(h_1 : (n k : ℕ) → ((y : α) → rel n k y → β y) → motive n k),
((match (motive := (x x_2 : ℕ) → ((y : α) → rel x x_2 y → β y) → motive x x_2) x, x_1 with
| n, k => fun x => h_1 n k x)
fun y h => f y) =
match x, x_1 with
| n, k => h_1 n k fun y h => f y |
CochainComplex.augmentTruncate_hom_f_succ | Mathlib.Algebra.Homology.Augment | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
(C : CochainComplex V ℕ) (i : ℕ), C.augmentTruncate.hom.f (i + 1) = CategoryTheory.CategoryStruct.id (C.X (i + 1)) |
ArzelaAscoli.compactSpace_of_isClosedEmbedding | Mathlib.Topology.UniformSpace.Ascoli | ∀ {ι : Type u_1} {X : Type u_2} {α : Type u_3} [inst : TopologicalSpace X] [inst_1 : UniformSpace α] {F : ι → X → α}
[inst_2 : TopologicalSpace ι] {𝔖 : Set (Set X)},
(∀ K ∈ 𝔖, IsCompact K) →
Topology.IsClosedEmbedding (⇑(UniformOnFun.ofFun 𝔖) ∘ F) →
(∀ K ∈ 𝔖, EquicontinuousOn F K) → (∀ K ∈ 𝔖, ∀ x ∈ K, ∃ Q, IsCompact Q ∧ ∀ (i : ι), F i x ∈ Q) → CompactSpace ι |
Lean.Level.quote | Lean.Level | Lean.Level → optParam ℕ 0 → optParam Bool true → Lean.Syntax.Level |
_private.Mathlib.SetTheory.Cardinal.Cofinality.0.Ordinal.aleph0_le_cof._simp_1_2 | Mathlib.SetTheory.Cardinal.Cofinality | (1 < Cardinal.aleph0) = True |
Lean.Parser.Term.structInstField | Lean.Parser.Term.Basic | Lean.Parser.Parser |
ModuleCat.restrictScalarsId | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | (R : Type u₁) → [inst : Ring R] → ModuleCat.restrictScalars (RingHom.id R) ≅ CategoryTheory.Functor.id (ModuleCat R) |
QuadraticModuleCat.toModuleCat_tensor | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Invertible 2] (X Y : QuadraticModuleCat R),
(CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).toModuleCat =
CategoryTheory.MonoidalCategoryStruct.tensorObj X.toModuleCat Y.toModuleCat |
WithTop.mul_lt_mul | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : CommSemiring α] [inst_2 : PartialOrder α] [OrderBot α]
[inst_4 : CanonicallyOrderedAdd α] [PosMulStrictMono α] {a₁ a₂ b₁ b₂ : WithTop α},
a₁ < a₂ → b₁ < b₂ → a₁ * b₁ < a₂ * b₂ |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical.of | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reify | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.LemmaM (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVLogical) |
_private.Mathlib.Algebra.Order.Field.Basic.0.sub_self_div_two._proof_1_1 | Mathlib.Algebra.Order.Field.Basic | (1 + 1).AtLeastTwo |
SimpleGraph.Subgraph.comap_equiv_top | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {W : Type v} {G : SimpleGraph V} {H : SimpleGraph W} (f : G →g H), SimpleGraph.Subgraph.comap f ⊤ = ⊤ |
exteriorPower.presentation.Rels | Mathlib.LinearAlgebra.ExteriorPower.Basic | Type u → Type u_4 → Type u_5 → Type (max (max u u_4) u_5) |
CategoryTheory.Pretriangulated.Triangle.rotate_mor₂ | Mathlib.CategoryTheory.Triangulated.Rotate | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C), T.rotate.mor₂ = T.mor₃ |
ProofWidgets.RpcEncodablePacket.«_@».ProofWidgets.Presentation.Expr.4196812879._hygCtx._hyg.1.recOn | ProofWidgets.Presentation.Expr | {motive : ProofWidgets.RpcEncodablePacket✝ → Sort u} →
(t : ProofWidgets.RpcEncodablePacket✝) → ((expr : Lean.Json) → motive { expr := expr }) → motive t |
ULift.algebra | Mathlib.Algebra.Algebra.Basic | {R : Type u_1} →
{A : Type u_2} → [inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra R (ULift.{u_4, u_2} A) |
CategoryTheory.Triangulated.Octahedron.mk.noConfusion | Mathlib.CategoryTheory.Triangulated.Triangulated | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Preadditive C} →
{inst_2 : CategoryTheory.Limits.HasZeroObject C} →
{inst_3 : CategoryTheory.HasShift C ℤ} →
{inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive} →
{inst_5 : CategoryTheory.Pretriangulated C} →
{X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C} →
{u₁₂ : X₁ ⟶ X₂} →
{u₂₃ : X₂ ⟶ X₃} →
{u₁₃ : X₁ ⟶ X₃} →
{comm : CategoryTheory.CategoryStruct.comp u₁₂ u₂₃ = u₁₃} →
{v₁₂ : X₂ ⟶ Z₁₂} →
{w₁₂ : Z₁₂ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
{h₁₂ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₂ v₁₂ w₁₂ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{v₂₃ : X₃ ⟶ Z₂₃} →
{w₂₃ : Z₂₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₂} →
{h₂₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₂₃ v₂₃ w₂₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{v₁₃ : X₃ ⟶ Z₁₃} →
{w₁₃ : Z₁₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj X₁} →
{h₁₃ :
CategoryTheory.Pretriangulated.Triangle.mk u₁₃ v₁₃ w₁₃ ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{P : Sort u} →
{m₁ : Z₁₂ ⟶ Z₁₃} →
{m₃ : Z₁₃ ⟶ Z₂₃} →
{comm₁ :
CategoryTheory.CategoryStruct.comp v₁₂ m₁ =
CategoryTheory.CategoryStruct.comp u₂₃ v₁₃} →
{comm₂ : CategoryTheory.CategoryStruct.comp m₁ w₁₃ = w₁₂} →
{comm₃ : CategoryTheory.CategoryStruct.comp v₁₃ m₃ = v₂₃} →
{comm₄ :
CategoryTheory.CategoryStruct.comp w₁₃
((CategoryTheory.shiftFunctor C 1).map u₁₂) =
CategoryTheory.CategoryStruct.comp m₃ w₂₃} →
{mem :
CategoryTheory.Pretriangulated.Triangle.mk m₁ m₃
(CategoryTheory.CategoryStruct.comp w₂₃
((CategoryTheory.shiftFunctor C 1).map v₁₂)) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{m₁' : Z₁₂ ⟶ Z₁₃} →
{m₃' : Z₁₃ ⟶ Z₂₃} →
{comm₁' :
CategoryTheory.CategoryStruct.comp v₁₂ m₁' =
CategoryTheory.CategoryStruct.comp u₂₃ v₁₃} →
{comm₂' :
CategoryTheory.CategoryStruct.comp m₁' w₁₃ = w₁₂} →
{comm₃' :
CategoryTheory.CategoryStruct.comp v₁₃ m₃' =
v₂₃} →
{comm₄' :
CategoryTheory.CategoryStruct.comp w₁₃
((CategoryTheory.shiftFunctor C 1).map
u₁₂) =
CategoryTheory.CategoryStruct.comp m₃' w₂₃} →
{mem' :
CategoryTheory.Pretriangulated.Triangle.mk m₁'
m₃'
(CategoryTheory.CategoryStruct.comp w₂₃
((CategoryTheory.shiftFunctor C 1).map
v₁₂)) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles} →
{ m₁ := m₁, m₃ := m₃, comm₁ := comm₁,
comm₂ := comm₂, comm₃ := comm₃,
comm₄ := comm₄, mem := mem } =
{ m₁ := m₁', m₃ := m₃', comm₁ := comm₁',
comm₂ := comm₂', comm₃ := comm₃',
comm₄ := comm₄', mem := mem' } →
(m₁ ≍ m₁' → m₃ ≍ m₃' → P) → P |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_deriv_norm | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]}
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2) (n : ℕ),
‖(Polynomial.aeval (newton_seq_gen✝ hnorm n)) (Polynomial.derivative F)‖ =
‖(Polynomial.aeval a) (Polynomial.derivative F)‖ |
Std.DTreeMap.Const.getD_insertMany_list_of_contains_eq_false | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[inst : BEq α] [Std.LawfulBEqCmp cmp] {l : List (α × β)} {k : α} {fallback : β},
(List.map Prod.fst l).contains k = false →
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.insertMany t l) k fallback = Std.DTreeMap.Const.getD t k fallback |
CategoryTheory.Presieve.Arrows.Compatible.familyOfElements.congr_simp | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {B : C}
{I : Type u_1} {X : I → C} {π π_1 : (i : I) → X i ⟶ B} (e_π : π = π_1) {x x_1 : (i : I) → P.obj (Opposite.op (X i))}
(e_x : x = x_1) (hx : CategoryTheory.Presieve.Arrows.Compatible P π x) ⦃Y : C⦄ (f f_1 : Y ⟶ B) (e_f : f = f_1)
(a : CategoryTheory.Presieve.ofArrows X π f), hx.familyOfElements f a = ⋯.familyOfElements f_1 ⋯ |
MeasureTheory.OuterMeasure.mkMetric' | Mathlib.MeasureTheory.Measure.Hausdorff | {X : Type u_2} → [EMetricSpace X] → (Set X → ENNReal) → MeasureTheory.OuterMeasure X |
BitVec.instTransOrd | Init.Data.Ord.BitVec | ∀ {n : ℕ}, Std.TransOrd (BitVec n) |
Fin.preimage_rev_Ioo | Mathlib.Order.Interval.Set.Fin | ∀ {n : ℕ} (i j : Fin n), Fin.rev ⁻¹' Set.Ioo i j = Set.Ioo j.rev i.rev |
Lean.Compiler.LCNF.Simp.State.mk.sizeOf_spec | Lean.Compiler.LCNF.Simp.SimpM | ∀ (subst : Lean.Compiler.LCNF.FVarSubst Lean.Compiler.LCNF.Purity.pure) (used : Lean.Compiler.LCNF.UsedLocalDecls)
(binderRenaming : Lean.Compiler.LCNF.Renaming) (funDeclInfoMap : Lean.Compiler.LCNF.Simp.FunDeclInfoMap)
(simplified : Bool) (visited inline inlineLocal : ℕ),
sizeOf
{ subst := subst, used := used, binderRenaming := binderRenaming, funDeclInfoMap := funDeclInfoMap,
simplified := simplified, visited := visited, inline := inline, inlineLocal := inlineLocal } =
1 + sizeOf subst + sizeOf used + sizeOf binderRenaming + sizeOf funDeclInfoMap + sizeOf simplified +
sizeOf visited +
sizeOf inline +
sizeOf inlineLocal |
Lean.Language.Lean.HeaderProcessedState.casesOn | Lean.Language.Lean.Types | {motive : Lean.Language.Lean.HeaderProcessedState → Sort u} →
(t : Lean.Language.Lean.HeaderProcessedState) →
((cmdState : Lean.Elab.Command.State) →
(firstCmdSnap : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) →
motive { cmdState := cmdState, firstCmdSnap := firstCmdSnap }) →
motive t |
Nat.map_add_toArray_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n k : ℕ}, Array.map (fun x => x + k) (m<...=n).toArray = ((m + k)<...=n + k).toArray |
Lean.Grind.decide_eq_false | Init.Grind.Lemmas | ∀ {p : Prop} {x : Decidable p}, p = False → decide p = false |
CategoryTheory.Bicategory.Pith.pseudofunctorToPithCompInclusionStrongIsoHom._proof_6 | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {B' : Type u_2} [inst_1 : CategoryTheory.Bicategory B']
[inst_2 : CategoryTheory.Bicategory.IsLocallyGroupoid B'] (F : CategoryTheory.Pseudofunctor B' B) {a b c : B'}
(f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.rightUnitor
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
(CategoryTheory.CategoryStruct.comp f g)) ≪≫
(CategoryTheory.Bicategory.leftUnitor
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
(CategoryTheory.CategoryStruct.comp f g))).symm).hom
(CategoryTheory.Bicategory.whiskerLeft
(CategoryTheory.CategoryStruct.id
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).obj
a))
(F.mapComp f g).hom) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).mapComp
f g).hom
(CategoryTheory.CategoryStruct.id
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).obj
c)))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
f)
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
g)
(CategoryTheory.CategoryStruct.id
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).obj
c))).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
f)
(CategoryTheory.Bicategory.rightUnitor
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
g) ≪≫
(CategoryTheory.Bicategory.leftUnitor
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
g)).symm).hom)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
f)
(CategoryTheory.CategoryStruct.id
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).obj
b))
(F.map g)).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight
(CategoryTheory.Bicategory.rightUnitor
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
f) ≪≫
(CategoryTheory.Bicategory.leftUnitor
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).map
f)).symm).hom
(F.map g))
(CategoryTheory.Bicategory.associator
(CategoryTheory.CategoryStruct.id
(((CategoryTheory.Bicategory.Pith.pseudofunctorToPith F).comp
(CategoryTheory.Bicategory.Pith.inclusion B)).obj
a))
(F.map f) (F.map g)).hom)))) |
CategoryTheory.Functor.isRightAdjoint_comp | Mathlib.CategoryTheory.Adjunction.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {F : CategoryTheory.Functor C D}
{G : CategoryTheory.Functor D E} [F.IsRightAdjoint] [G.IsRightAdjoint], (F.comp G).IsRightAdjoint |
alternatingGroup.normal | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α], (alternatingGroup α).Normal |
SemimoduleCat.MonoidalCategory.associator | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | {R : Type u} →
[inst : CommSemiring R] →
(M : SemimoduleCat R) →
(N : SemimoduleCat R) →
(K : SemimoduleCat R) →
SemimoduleCat.MonoidalCategory.tensorObj (SemimoduleCat.MonoidalCategory.tensorObj M N) K ≅
SemimoduleCat.MonoidalCategory.tensorObj M (SemimoduleCat.MonoidalCategory.tensorObj N K) |
AddUnits.val_zero | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α], ↑0 = 0 |
StalkSkyscraperPresheafAdjunctionAuxs.fromStalk._proof_2 | Mathlib.Topology.Sheaves.Skyscraper | ∀ {X : TopCat} (p₀ : ↑X) [inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] {C : Type u_1}
[inst_1 : CategoryTheory.Category.{u_2, u_1} C] [inst_2 : CategoryTheory.Limits.HasTerminal C] {c : C}
(U : (TopologicalSpace.OpenNhds p₀)ᵒᵖ), (if p₀ ∈ ↑(Opposite.unop U) then c else ⊤_ C) = c |
Stream'.Seq.Corec.f.match_1 | Mathlib.Data.Seq.Defs | {β : Type u_1} →
(motive : Option β → Sort u_2) → (x : Option β) → (Unit → motive none) → ((b : β) → motive (some b)) → motive x |
RCLike.re_eq_complex_re | Mathlib.Analysis.Complex.Basic | ⇑RCLike.re = Complex.re |
_private.Mathlib.Lean.Expr.Basic.0.Lean.ConstantInfo.isDef.match_1 | Mathlib.Lean.Expr.Basic | (motive : Lean.ConstantInfo → Sort u_1) →
(x : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
((x : Lean.ConstantInfo) → motive x) → motive x |
Aesop.GoalData.lastExpandedInIteration | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → Aesop.Iteration |
isCycle_finRotate_of_le | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ}, 2 ≤ n → (finRotate n).IsCycle |
Lean.Grind.CommRing.Expr.toPolyC.go._unsafe_rec | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly |
OpenPartialHomeomorph.contDiff_unitBallBall | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ {n : ℕ∞} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {c : E} {r : ℝ} (hr : 0 < r),
ContDiff ℝ ↑n ↑(OpenPartialHomeomorph.unitBallBall c r hr) |
Algebra.RingHom.adjoinAlgebraMap.congr_simp | Mathlib.RingTheory.Adjoin.Singleton | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommSemiring A] [inst_1 : CommSemiring B]
[inst_2 : CommSemiring C] [inst_3 : Algebra A B] [inst_4 : Algebra B C] [inst_5 : Algebra A C]
[inst_6 : IsScalarTower A B C] (b : B), Algebra.RingHom.adjoinAlgebraMap b = Algebra.RingHom.adjoinAlgebraMap b |
EReal.coe_zsmul | Mathlib.Data.EReal.Operations | ∀ (n : ℤ) (x : ℝ), ↑(n • x) = n • ↑x |
Std.Roc.toList_toArray | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Roc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [inst_4 : Std.Rxc.IsAlwaysFinite α], r.toArray.toList = r.toList |
_private.Mathlib.Logic.Relation.0.Relation.map_onFun_map_eq_map._proof_1_2 | Mathlib.Logic.Relation | ∀ {α : Sort u_2} {β : Sort u_1} {r : α → α → Prop} (f : α → β),
Relation.Map (fun x y => Relation.Map r f f (f x) (f y)) f f = Relation.Map r f f |
PairReduction.edist_le_of_mem_pairSet | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : PseudoEMetricSpace T] {a c : ENNReal} {n : ℕ} {J : Finset T} [inst_1 : DecidableEq T],
1 < a → ↑J.card ≤ a ^ n → ∀ {s t : T}, (s, t) ∈ PairReduction.pairSet J a c → edist s t ≤ ↑n * c |
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.testTacticSeq._sparseCasesOn_9 | Mathlib.Tactic.TacticAnalysis | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
AlgebraicGeometry.PresheafedSpace.Hom.mk._flat_ctor | Mathlib.Geometry.RingedSpace.PresheafedSpace | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : AlgebraicGeometry.PresheafedSpace C} →
(base : ↑X ⟶ ↑Y) → (Y.presheaf ⟶ (TopCat.Presheaf.pushforward C base).obj X.presheaf) → X.Hom Y |
Lean.Grind.ToInt.wrap_toInt | Init.Grind.ToInt | ∀ {α : Type u_1} (I : Lean.Grind.IntInterval) [inst : Lean.Grind.ToInt α I] (x : α), I.wrap ↑x = ↑x |
Language.isRegular_iff_finite_range_leftQuotient | Mathlib.Computability.MyhillNerode | ∀ {α : Type u} {L : Language α}, L.IsRegular ↔ (Set.range L.leftQuotient).Finite |
_private.Lean.Widget.InteractiveGoal.0.Lean.Widget.withGoalCtx.match_1 | Lean.Widget.InteractiveGoal | (motive : Option Lean.MetavarDecl → Sort u_1) →
(x : Option Lean.MetavarDecl) →
((mvarDecl : Lean.MetavarDecl) → motive (some mvarDecl)) → ((x : Option Lean.MetavarDecl) → motive x) → motive x |
Lean.Meta.DiagSummary._sizeOf_inst | Lean.Meta.Diagnostics | SizeOf Lean.Meta.DiagSummary |
UInt16.neg_neg | Init.Data.UInt.Lemmas | ∀ {a : UInt16}, - -a = a |
Lean.Meta.Match.MatcherInfo.noConfusion | Lean.Meta.Match.MatcherInfo | {P : Sort u} → {t t' : Lean.Meta.MatcherInfo} → t = t' → Lean.Meta.Match.MatcherInfo.noConfusionType P t t' |
CategoryTheory.MonoidalCoherence.right'_iso | Mathlib.Tactic.CategoryTheory.MonoidalComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y : C)
[inst_2 : CategoryTheory.MonoidalCoherence X Y],
CategoryTheory.MonoidalCoherence.iso =
CategoryTheory.MonoidalCoherence.iso ≪≫ (CategoryTheory.MonoidalCategoryStruct.rightUnitor Y).symm |
Lean.Parser.Command.macroArg.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer |
Array.Matcher.Iterator.noConfusion | Batteries.Data.Array.Match | {P : Sort u} →
{σ : Type u_1} →
{n : Type u_1 → Type u_2} →
{α : Type u_1} →
{inst : BEq α} →
{m : Array.Matcher α} →
{inst_1 : Std.Iterator σ n α} →
{t : Array.Matcher.Iterator σ n α m} →
{σ' : Type u_1} →
{n' : Type u_1 → Type u_2} →
{α' : Type u_1} →
{inst' : BEq α'} →
{m' : Array.Matcher α'} →
{inst'_1 : Std.Iterator σ' n' α'} →
{t' : Array.Matcher.Iterator σ' n' α' m'} →
σ = σ' →
n = n' →
α = α' →
inst ≍ inst' →
m ≍ m' → inst_1 ≍ inst'_1 → t ≍ t' → Array.Matcher.Iterator.noConfusionType P t t' |
SSet.Truncated.liftOfStrictSegal.spineEquiv_f₂_arrow_one | Mathlib.AlgebraicTopology.SimplicialSet.NerveAdjunction | ∀ {X Y : SSet.Truncated 2}
(f₀ :
X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := _proof_11✝ }) →
Y.obj (Opposite.op { obj := SimplexCategory.mk 0, property := _proof_11✝¹ }))
(f₁ :
X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := _proof_12✝ }) →
Y.obj (Opposite.op { obj := SimplexCategory.mk 1, property := _proof_12✝¹ }))
(hδ₁ :
∀ (x : X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := _proof_12✝² })),
f₀ (X.map (SimplexCategory.Truncated.δ₂ 1 _proof_11✝² _proof_13✝).op x) =
Y.map (SimplexCategory.Truncated.δ₂ 1 _proof_11✝³ _proof_13✝¹).op (f₁ x))
(hδ₀ :
∀ (x : X.obj (Opposite.op { obj := SimplexCategory.mk 1, property := _proof_12✝³ })),
f₀ (X.map (SimplexCategory.Truncated.δ₂ 0 _proof_11✝⁴ _proof_13✝²).op x) =
Y.map (SimplexCategory.Truncated.δ₂ 0 _proof_11✝⁵ _proof_13✝³).op (f₁ x))
(hY : Y.StrictSegal) (x : X.obj (Opposite.op { obj := SimplexCategory.mk 2, property := _proof_14✝ })),
((hY.spineEquiv 2 SSet.Truncated.liftOfStrictSegal.f₂._proof_5)
(SSet.Truncated.liftOfStrictSegal.f₂ f₀ f₁ hδ₁ hδ₀ hY x)).arrow
1 =
f₁ (X.map (SimplexCategory.Truncated.δ₂ 0 _proof_12✝⁴ _proof_15✝).op x) |
_private.Aesop.Forward.LevelIndex.0.Aesop.instHashableLevelIndex.hash.match_1 | Aesop.Forward.LevelIndex | (motive : Aesop.LevelIndex → Sort u_1) → (x : Aesop.LevelIndex) → ((a : ℕ) → motive { toNat := a }) → motive x |
Set.Icc_subset_Icc_union_Icc | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Icc a c ⊆ Set.Icc a b ∪ Set.Icc b c |
CoheytingHom.id._proof_2 | Mathlib.Order.Heyting.Hom | ∀ (α : Type u_1) [inst : CoheytingAlgebra α] (x x_1 : α),
(LatticeHom.id α).toFun (x \ x_1) = (LatticeHom.id α).toFun (x \ x_1) |
Lean.Elab.Term.Do.ToTerm.Context.rec | Lean.Elab.Do.Legacy | {motive : Lean.Elab.Term.Do.ToTerm.Context → Sort u} →
((m returnType : Lean.Syntax) →
(uvars : Array Lean.Elab.Term.Do.Var) →
(kind : Lean.Elab.Term.Do.ToTerm.Kind) →
motive { m := m, returnType := returnType, uvars := uvars, kind := kind }) →
(t : Lean.Elab.Term.Do.ToTerm.Context) → motive t |
_private.Lean.Meta.Tactic.Grind.Internalize.0.Lean.Meta.Grind.internalizePattern.go._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Internalize | {motive : Lean.Meta.Grind.Origin → Sort u} →
(t : Lean.Meta.Grind.Origin) →
((declName : Lean.Name) → motive (Lean.Meta.Grind.Origin.decl declName)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
variationOnFromTo | Mathlib.Topology.EMetricSpace.BoundedVariation | {α : Type u_1} → [LinearOrder α] → {E : Type u_2} → [PseudoEMetricSpace E] → (α → E) → Set α → α → α → ℝ |
Lean.Parser.Category.prec | Init.Notation | Lean.Parser.Category |
Aesop.runFirstNormRule | Aesop.Search.Expansion.Norm | Lean.MVarId →
Aesop.UnorderedArraySet Lean.MVarId →
Array (Aesop.IndexMatchResult Aesop.NormRule) → Aesop.NormM (Option (Aesop.DisplayRuleName × Aesop.NormRuleResult)) |
FundamentalGroupoid.nonempty_iff._simp_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (X : Type u_3), Nonempty (FundamentalGroupoid X) = Nonempty X |
Nat.perfect_iff_sum_properDivisors | Mathlib.NumberTheory.Divisors | ∀ {n : ℕ}, 0 < n → (n.Perfect ↔ ∑ i ∈ n.properDivisors, i = n) |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo.parent? | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.DerivedValInfo✝ → Option Lean.FVarId |
ContDiffAt.hasStrictDerivAt | Mathlib.Analysis.Calculus.ContDiff.RCLike | ∀ {n : WithTop ℕ∞} {𝕂 : Type u_1} [inst : RCLike 𝕂] {F' : Type u_3} [inst_1 : NormedAddCommGroup F']
[inst_2 : NormedSpace 𝕂 F'] {f : 𝕂 → F'} {x : 𝕂}, ContDiffAt 𝕂 n f x → n ≠ 0 → HasStrictDerivAt f (deriv f x) x |
Lean.Grind.Linarith.zero_ne_one_of_charC | Init.Grind.Ordered.Linarith | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.Linarith.Context α)
(p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.zero_ne_one_of_charC_cert c p = true →
Lean.Grind.Linarith.Var.denote ctx 0 = One.one → Lean.Grind.Linarith.Poly.denote' ctx p ≠ 0 |
Nonneg.zero._proof_1 | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α], 0 ≤ 0 |
IsUltrametricDist.mem_ball_iff | Mathlib.Topology.MetricSpace.Ultra.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, x ∈ Metric.ball y ε ↔ y ∈ Metric.ball x ε |
PadicInt.nonarchimedean | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (q r : ℤ_[p]), ‖q + r‖ ≤ max ‖q‖ ‖r‖ |
_private.Mathlib.Algebra.Module.Presentation.Basic.0.Module.Relations.Solution.surjective_fromQuotient_iff_surjective_π._simp_1_1 | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M), solution.π = solution.fromQuotient ∘ₗ relations.toQuotient |
EisensteinSeries.isLittleO_const_left_of_properSpace_of_discreteTopology | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ {α : Type u_1} (a : α) [inst : NormedAddCommGroup α] [DiscreteTopology α] [ProperSpace α],
(fun x => a) =o[Filter.cofinite] fun x => ‖x‖ |
_private.Mathlib.NumberTheory.FLT.Basic.0.fermatLastTheoremWith_of_fermatLastTheoremWith_coprime._simp_1_1 | Mathlib.NumberTheory.FLT.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b ≠ 0) = (a ≠ 0 ∧ b ≠ 0) |
Int.toArray_roo_eq_singleton | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, n = m + 2 → (m<...n).toArray = #[m + 1] |
Quaternion.instIsStarNormal | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), IsStarNormal a |
Lean.Widget.TaggedText.forM._unsafe_rec | Lean.Widget.TaggedText | {m : Type → Type u_1} →
{α : Type u_2} → [Monad m] → (α → Lean.Widget.TaggedText α → m Unit) → Lean.Widget.TaggedText α → m Unit |
Equiv.Set.rangeInl.match_3 | Mathlib.Logic.Equiv.Set | ∀ (α : Type u_1) (β : Type u_2) (motive : ↑(Set.range Sum.inl) → Prop) (x : ↑(Set.range Sum.inl)),
(∀ (val : α), motive ⟨Sum.inl val, ⋯⟩) → motive x |
Aesop.Subgoal.diff | Aesop.RuleTac.Basic | Aesop.Subgoal → Aesop.GoalDiff |
Metric.Snowflaking.isBounded_image_ofSnowflaking_iff._simp_1 | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : Bornology X] {s : Set (Metric.Snowflaking X α hα₀ hα₁)},
Bornology.IsBounded (⇑Metric.Snowflaking.ofSnowflaking '' s) = Bornology.IsBounded s |
HopfAlgCat.instMonoidalCategoryStruct | Mathlib.Algebra.Category.HopfAlgCat.Monoidal | (R : Type u) → [inst : CommRing R] → CategoryTheory.MonoidalCategoryStruct (HopfAlgCat R) |
Continuous.of_neg | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} {α : Type u} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous (-f) → Continuous f |
BialgEquiv.ofBialgHom._proof_3 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_1} [inst : CommSemiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) |
Ordinal.type_sum_lex | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
Ordinal.type (Sum.Lex r s) = Ordinal.type r + Ordinal.type s |
Algebra.Generators.toExtension_σ | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.Generators R S ι) (a : S), P.toExtension.σ a = P.σ a |
_private.Mathlib.AlgebraicGeometry.ZariskisMainTheorem.0.AlgebraicGeometry.Scheme.Hom.exists_mem_and_isIso_morphismRestrict_toNormalization._simp_1_2 | Mathlib.AlgebraicGeometry.ZariskisMainTheorem | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [inst : AlgebraicGeometry.IsOpenImmersion f]
[inst_1 : AlgebraicGeometry.IsOpenImmersion g],
(AlgebraicGeometry.Scheme.Hom.opensFunctor g).obj (AlgebraicGeometry.Scheme.Hom.opensRange f) =
AlgebraicGeometry.Scheme.Hom.opensRange (CategoryTheory.CategoryStruct.comp f g) |
Set.eq_top_of_card_le_of_finite | Mathlib.Data.Finite.Card | ∀ {α : Type u_1} [Finite α] {s : Set α}, Nat.card α ≤ Nat.card ↑s → s = ⊤ |
PadicInt.continuousAddCharEquiv.match_1 | Mathlib.NumberTheory.Padics.AddChar | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
(R : Type u_1) →
[inst_1 : NormedRing R] →
(motive : { κ // Continuous ⇑κ } → Sort u_2) →
(x : { κ // Continuous ⇑κ }) → ((κ : AddChar ℤ_[p] R) → (hκ : Continuous ⇑κ) → motive ⟨κ, hκ⟩) → motive x |
Lean.Widget.RpcEncodablePacket.range?._@.Lean.Widget.UserWidget.3433604829._hygCtx._hyg.1 | Lean.Widget.UserWidget | Lean.Widget.RpcEncodablePacket✝ → Option Lean.Json |
Continuous.rpow | Mathlib.Analysis.SpecialFunctions.Pow.Continuity | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f g : α → ℝ},
Continuous f → Continuous g → (∀ (x : α), f x ≠ 0 ∨ 0 < g x) → Continuous fun x => f x ^ g x |
CategoryTheory.SmallObject.SuccStruct.Iteration.casesOn | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
{Φ : CategoryTheory.SmallObject.SuccStruct C} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : CategoryTheory.Limits.HasIterationOfShape J C] →
[inst_5 : WellFoundedLT J] →
{j : J} →
{motive : Φ.Iteration j → Sort u_1} →
(t : Φ.Iteration j) →
((F : CategoryTheory.Functor (↑(Set.Iic j)) C) →
(obj_bot : F.obj ⟨⊥, ⋯⟩ = Φ.X₀) →
(arrowSucc_eq :
∀ (i : J) (hi : i < j),
CategoryTheory.SmallObject.SuccStruct.arrowSucc F i hi =
Φ.toSuccArrow (F.obj ⟨i, ⋯⟩)) →
(arrowMap_limit :
∀ (i : J) (hi : Order.IsSuccLimit i) (hij : i ≤ j) (k : J) (hk : k < i),
CategoryTheory.SmallObject.SuccStruct.arrowMap F k i ⋯ hij =
CategoryTheory.SmallObject.SuccStruct.arrowι
(CategoryTheory.SmallObject.restrictionLT F hij) hi k hk) →
motive
{ F := F, obj_bot := obj_bot, arrowSucc_eq := arrowSucc_eq,
arrowMap_limit := arrowMap_limit }) →
motive t |
Cardinal.toNat_strictMonoOn | Mathlib.SetTheory.Cardinal.ToNat | StrictMonoOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0) |
PFunctor.M.IsBisimulation.mk | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {R : F.M → F.M → Prop},
(∀ {a a' : F.A} {f : F.B a → F.M} {f' : F.B a' → F.M}, R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a', f'⟩) → a = a') →
(∀ {a : F.A} {f f' : F.B a → F.M},
R (PFunctor.M.mk ⟨a, f⟩) (PFunctor.M.mk ⟨a, f'⟩) → ∀ (i : F.B a), R (f i) (f' i)) →
PFunctor.M.IsBisimulation R |
CategoryTheory.Limits.IsInitial.subsingleton_to | Mathlib.CategoryTheory.Limits.Shapes.StrictInitial | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasStrictInitialObjects C] {I : C}
(hI : CategoryTheory.Limits.IsInitial I) {A : C}, Subsingleton (A ⟶ I) |
List.perm_cons_append_cons | Init.Data.List.Perm | ∀ {α : Type u_1} {l l₁ l₂ : List α} (a : α), l.Perm (l₁ ++ l₂) → (a :: l).Perm (l₁ ++ a :: l₂) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.