name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Linter.MissingDocs.hasTacticAlt | Lean.Linter.MissingDocs | Lean.Syntax → Bool |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary.eq_def | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap)
(_x :
(idx : Std.Time.Month.Ordinal) ×'
(acc : ℤ) ×' (_ : ↑ordinal > acc) ×' acc = (Std.Time.Month.Ordinal.cumulativeDays leap idx).val),
Std.Time.ValidDate.ofOrdinal.go._unary✝ ordinal _x =
PSigma.casesOn _x fun idx acc =>
PSigma.casesOn acc fun acc h =>
PSigma.casesOn h fun h p =>
let monthDays := Std.Time.Month.Ordinal.days leap idx;
if h₁ : ↑ordinal ≤ acc + ↑monthDays then
let bounded := (Std.Time.Internal.Bounded.LE.mk ↑ordinal ⋯).sub acc;
let bounded := Std.Time.Internal.Bounded.cast ⋯ ⋯ bounded;
let days₁ := ⟨↑bounded, ⋯⟩;
⟨(idx, days₁), ⋯⟩
else
have h₂ := ⋯;
have h₃ := ⋯;
let idx₂ :=
(Std.Time.Internal.Bounded.LE.truncateTop idx ⋯).addTop 1
Std.Time.ValidDate.ofOrdinal.go._unary._proof_25✝;
Std.Time.ValidDate.ofOrdinal.go._unary✝¹ ordinal ⟨idx₂, ⟨acc + ↑monthDays, ⟨h₂, ⋯⟩⟩⟩ |
Rat.cast_fract | Mathlib.Data.Rat.Floor | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : FloorRing α] (x : ℚ),
↑(Int.fract x) = Int.fract ↑x |
List.Perm.union_right | Batteries.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α} [inst : BEq α] [LawfulBEq α] (t₁ : List α), l₁.Perm l₂ → (l₁ ∪ t₁).Perm (l₂ ∪ t₁) |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateLeft._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.ShiftTarget w),
∀ idx < w, ¬idx < target.distance % w → idx - target.distance % w < w |
RCLike.sqrt_eq_ite | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {a : 𝕜},
RCLike.sqrt a =
if h : RCLike.im RCLike.I = 1 then (RCLike.complexRingEquiv h).symm ((RCLike.complexRingEquiv h) a).sqrt
else ↑√(RCLike.re a) |
CategoryTheory.Arrow.cechNerve | Mathlib.AlgebraicTopology.CechNerve | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(f : CategoryTheory.Arrow C) →
[∀ (n : ℕ), CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom] →
CategoryTheory.SimplicialObject C |
CategoryTheory.Functor.IsWellOrderContinuous.restriction_setIci | Mathlib.CategoryTheory.Limits.Shapes.Preorder.WellOrderContinuous | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J]
{F : CategoryTheory.Functor J C} [F.IsWellOrderContinuous] (j : J), (⋯.functor.comp F).IsWellOrderContinuous |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.toSheafedSpace | Mathlib.Geometry.RingedSpace.OpenImmersion | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : AlgebraicGeometry.PresheafedSpace C} →
(Y : AlgebraicGeometry.SheafedSpace C) →
(f : X ⟶ Y.toPresheafedSpace) →
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] → AlgebraicGeometry.SheafedSpace C |
Lean.MonadResolveName.mk._flat_ctor | Lean.ResolveName | {m : Type → Type} → m Lean.Name → m (List Lean.OpenDecl) → Lean.MonadResolveName m |
AddCommGrpCat.coyonedaType._proof_3 | Mathlib.Algebra.Category.Grp.Yoneda | ∀ {X Y : Type u_1ᵒᵖ} (f : X ⟶ Y) ⦃X_1 Y_1 : AddCommGrpCat⦄ (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
({ obj := fun G => AddCommGrpCat.of (Opposite.unop X → ↑G),
map := fun {X_2 Y} f =>
AddCommGrpCat.ofHom
(Pi.addMonoidHom fun i => (AddCommGrpCat.Hom.hom f).comp (Pi.evalAddMonoidHom (fun a => ↑X_2) i)),
map_id := ⋯, map_comp := ⋯ }.map
f_1)
(AddCommGrpCat.ofHom (Pi.addMonoidHom fun i => Pi.evalAddMonoidHom (fun a => ↑Y_1) (f.unop i))) =
CategoryTheory.CategoryStruct.comp
(AddCommGrpCat.ofHom (Pi.addMonoidHom fun i => Pi.evalAddMonoidHom (fun a => ↑X_1) (f.unop i)))
({ obj := fun G => AddCommGrpCat.of (Opposite.unop Y → ↑G),
map := fun {X Y_2} f =>
AddCommGrpCat.ofHom
(Pi.addMonoidHom fun i => (AddCommGrpCat.Hom.hom f).comp (Pi.evalAddMonoidHom (fun a => ↑X) i)),
map_id := ⋯, map_comp := ⋯ }.map
f_1) |
Isometry.comp_continuousOn_iff | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {f : α → β} {γ : Type u_3}
[inst_2 : TopologicalSpace γ], Isometry f → ∀ {g : γ → α} {s : Set γ}, ContinuousOn (f ∘ g) s ↔ ContinuousOn g s |
CategoryTheory.CostructuredArrow.prodInverse._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_5, u_1} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_2, u_6} D] {C' : Type u_3} [inst_2 : CategoryTheory.Category.{u_7, u_3} C']
{D' : Type u_8} [inst_3 : CategoryTheory.Category.{u_4, u_8} D'] (S : CategoryTheory.Functor C D)
(S' : CategoryTheory.Functor C' D') (T : D) (T' : D')
(X : CategoryTheory.CostructuredArrow S T × CategoryTheory.CostructuredArrow S' T'),
CategoryTheory.CostructuredArrow.homMk
((CategoryTheory.CategoryStruct.id X).1.left, (CategoryTheory.CategoryStruct.id X).2.left) ⋯ =
CategoryTheory.CategoryStruct.id (CategoryTheory.CostructuredArrow.mk (X.1.hom, X.2.hom)) |
Lean.Parser.Attr.export._regBuiltin.Lean.Parser.Attr.export.declRange_3 | Lean.Parser.Attr | IO Unit |
ConvexOn.integrable_apply_rnDeriv_of_integrable_compProd | Mathlib.MeasureTheory.Measure.Decomposition.IntegralRNDeriv | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {μ ν : MeasureTheory.Measure 𝓧} {𝓨 : Type u_2} {m𝓨 : MeasurableSpace 𝓨}
{κ η : ProbabilityTheory.Kernel 𝓧 𝓨} {f : ℝ → ℝ} [MeasureTheory.IsFiniteMeasure μ] [MeasureTheory.IsFiniteMeasure ν]
[ProbabilityTheory.IsMarkovKernel κ] [ProbabilityTheory.IsMarkovKernel η],
MeasureTheory.StronglyMeasurable f →
ConvexOn ℝ (Set.Ici 0) f →
ContinuousWithinAt f (Set.Ici 0) 0 →
MeasureTheory.Integrable (fun p => f ((μ.compProd κ).rnDeriv (ν.compProd η) p).toReal) (ν.compProd η) →
(μ.compProd κ).AbsolutelyContinuous (μ.compProd η) →
MeasureTheory.Integrable (fun a => f (μ.rnDeriv ν a).toReal) ν |
Metric.isPreconnected_ball | Mathlib.Analysis.Normed.Module.Connected | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [NormedSpace ℝ E] {x : E} {r : ℝ}, IsPreconnected (Metric.ball x r) |
_private.Mathlib.Analysis.Seminorm.0.Seminorm.neg_mem_closedBall_zero._simp_1_1 | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
(p : Seminorm 𝕜 E) {y : E} {r : ℝ}, (y ∈ p.closedBall 0 r) = (p y ≤ r) |
Module.instFinitePolynomialAEval' | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (φ : M →ₗ[R] M)
[Module.Finite R M], Module.Finite (Polynomial R) (Module.AEval' φ) |
Real.sin_nonpos_of_nonpos_of_neg_pi_le | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ {x : ℝ}, x ≤ 0 → -Real.pi ≤ x → Real.sin x ≤ 0 |
Array.sum_div_length_le_max_of_max?_eq_some_int | Init.Data.Array.Int | ∀ {x : ℤ} {xs : Array ℤ}, xs.max? = some x → xs.sum / ↑xs.size ≤ x |
AddGroup.fintypeOfKerOfCodom._proof_2 | Mathlib.GroupTheory.QuotientGroup.Finite | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (g : G →+ H),
∀ x ∈ g.ker, ∃ y, (AddSubgroup.topEquiv.toAddMonoidHom.comp (AddSubgroup.inclusion ⋯)) y = x |
Lean.Parser.registerAlias | Lean.Parser.Extension | Lean.Name →
Lean.Name →
Lean.Parser.ParserAliasValue →
optParam (Option Lean.SyntaxNodeKind) none → optParam Lean.Parser.ParserAliasInfo { } → IO Unit |
Vector.isEqv_self | Init.Data.Vector.DecidableEq | ∀ {α : Type u_1} {n : ℕ} [inst : DecidableEq α] (xs : Vector α n), (xs.isEqv xs fun x1 x2 => decide (x1 = x2)) = true |
Std.ExtDHashMap.Const.getD_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {fallback v : β},
Std.ExtDHashMap.Const.getD (m.insertIfNew k v) a fallback =
if (k == a) = true ∧ k ∉ m then v else Std.ExtDHashMap.Const.getD m a fallback |
Aesop.UnsafeQueueEntry | Aesop.Tree.UnsafeQueue | Type |
Lean.Doc.Data.Attribute._sizeOf_inst | Lean.Elab.DocString.Builtin | SizeOf Lean.Doc.Data.Attribute |
_private.Mathlib.NumberTheory.LucasLehmer.0.mersenne_mod_three._proof_1_2 | Mathlib.NumberTheory.LucasLehmer | ∀ (j : ℕ), 2 * (j + 1) = 2 * j + 1 + 1 |
_private.Mathlib.RingTheory.FractionalIdeal.Norm.0.FractionalIdeal.absNorm_span_singleton._simp_1_5 | Mathlib.RingTheory.FractionalIdeal.Norm | ∀ {α : Type u} [inst : Semiring α] {x y : α}, (x ∈ Ideal.span {y}) = ∃ a, a * y = x |
Lean.instToExprLiteral | Lean.ToExpr | Lean.ToExpr Lean.Literal |
PiLp.edist_eq_card | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {ι : Type u_2} {β : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → EDist (β i)] (f g : PiLp 0 β),
edist f g = ↑⋯.toFinset.card |
Projectivization.mulHeight | Mathlib.NumberTheory.Height.Projectivization | {K : Type u_1} →
[inst : Field K] → [Height.AdmissibleAbsValues K] → {ι : Type u_2} → [Finite ι] → Projectivization K (ι → K) → ℝ |
add_tsub_le_tsub_add | Mathlib.Algebra.Order.Sub.Defs | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddCommSemigroup α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}
[AddLeftMono α], a + b - c ≤ a - c + b |
CategoryTheory.Center.isoMk | Mathlib.CategoryTheory.Monoidal.Center | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X Y : CategoryTheory.Center C} → (f : X ⟶ Y) → [CategoryTheory.IsIso f.f] → X ≅ Y |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.mem_rootsOfUnity._simp_1_4 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Diffeomorph.boundarylessManifold | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{N : Type u_7} [inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace H' N] {n : WithTop ℕ∞},
n ≠ 0 → ∀ (Φ : Diffeomorph I I' M N n) [BoundarylessManifold I M], BoundarylessManifold I' N |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.collectVersoTokens.tok | Lean.Server.FileWorker.SemanticHighlighting | Lean.Syntax → Lean.Lsp.SemanticTokenType → StateM (Array Lean.Server.FileWorker.LeanSemanticToken) Unit |
Nat.getElem_toArray_roo | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ} (_h : i < (m<...n).toArray.size), (m<...n).toArray[i] = m + 1 + i |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.map'_inv_eq_inv_map'._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n m : ℕ}, n + 1 ≤ m → ¬n ≤ m → False |
Setoid.comap | Mathlib.Data.Setoid.Basic | {α : Type u_1} → {β : Type u_2} → (α → β) → Setoid β → Setoid α |
UniformConcaveOn.concaveOn | Mathlib.Analysis.Convex.Strong | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {φ : ℝ → ℝ} {s : Set E} {f : E → ℝ},
UniformConcaveOn s φ f → 0 ≤ φ → ConcaveOn ℝ s f |
Lean.Meta.Sym.getMatch | Lean.Meta.Sym.Simp.DiscrTree | {α : Type} → Lean.Meta.DiscrTree α → Lean.Expr → Array α |
UInt64.not_eq_neg_sub | Init.Data.UInt.Bitwise | ∀ (a : UInt64), ~~~a = -a - 1 |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.y_smooth._simp_1_7 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b |
PrincipalSeg.isMin_apply_iff | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder β] {a : α} [inst_1 : PartialOrder α]
(f : PrincipalSeg (fun x1 x2 => x1 < x2) fun x1 x2 => x1 < x2), IsMin (f.toRelEmbedding a) ↔ IsMin a |
CategoryTheory.NatTrans.mapHomologicalComplex_id | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_3} {W₂ : Type u_4} [inst : CategoryTheory.Category.{v_2, u_3} W₁]
[inst_1 : CategoryTheory.Category.{v_3, u_4} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (c : ComplexShape ι) (F : CategoryTheory.Functor W₁ W₂)
[inst_4 : F.PreservesZeroMorphisms],
CategoryTheory.NatTrans.mapHomologicalComplex (CategoryTheory.CategoryStruct.id F) c =
CategoryTheory.CategoryStruct.id (F.mapHomologicalComplex c) |
PiTensorProduct.congr_symm_tprod | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_11} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i ≃ₗ[R] t i) (p : (i : ι) → t i),
(PiTensorProduct.congr f).symm ((PiTensorProduct.tprod R) p) = ⨂ₜ[R] (i : ι), (f i).symm (p i) |
le_of_forall_lt_imp_ne | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ c < a, c ≠ b) → a ≤ b |
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 t ∩ g • s, f x ∂μ |
mul_eq_zero_of_ne_zero_imp_eq_zero | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] {a b : M₀}, (a ≠ 0 → b = 0) → a * b = 0 |
Nat.Partition.oddDistincts | Mathlib.Combinatorics.Enumerative.Partition.Basic | (n : ℕ) → Finset n.Partition |
Real.exp_one_gt_d9 | Mathlib.Analysis.Complex.ExponentialBounds | 2.7182818283 < Real.exp 1 |
Lean.Meta.UnificationHints.discrTree._default | Lean.Meta.UnificationHint | Lean.Meta.DiscrTree Lean.Name |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula.0.WeierstrassCurve.Affine.cyclic_sum_Y_mul_X_sub_X._simp_1_7 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
instNonUnitalCommCStarAlgebraSubtypeMemNonUnitalStarSubalgebraComplexElementalOfIsStarNormal._proof_8 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (x : A) (a b : ↥(NonUnitalStarAlgebra.elemental ℂ x)), a + b = b + a |
CategoryTheory.Abelian.Ext.comp_add | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y Z : C} {n : ℕ} (α : CategoryTheory.Abelian.Ext X Y n) {m : ℕ}
(β₁ β₂ : CategoryTheory.Abelian.Ext Y Z m) {p : ℕ} (h : n + m = p), α.comp (β₁ + β₂) h = α.comp β₁ h + α.comp β₂ h |
_private.Init.Data.UInt.Lemmas.0.USize.zero_lt_one._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.unicodeLinter.match_3 | Mathlib.Tactic.Linter.TextBased | (motive : Mathlib.Linter.TextBased.StyleError✝ → Sort u_1) →
(e : Mathlib.Linter.TextBased.StyleError✝¹) →
((c : Char) → motive (Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝ c)) →
((s : String) → (sel : Option Char) → motive (Mathlib.Linter.TextBased.StyleError.unicodeVariant✝ s sel)) →
((x : Mathlib.Linter.TextBased.StyleError✝²) → motive x) → motive e |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.StructFieldKind.isParent.match_1 | Lean.Elab.Structure | (motive : Lean.Elab.Command.Structure.StructFieldKind → Sort u_1) →
(kind : Lean.Elab.Command.Structure.StructFieldKind) →
((structName : Lean.Name) → motive (Lean.Elab.Command.Structure.StructFieldKind.subobject structName)) →
((structName : Lean.Name) → motive (Lean.Elab.Command.Structure.StructFieldKind.otherParent structName)) →
((x : Lean.Elab.Command.Structure.StructFieldKind) → motive x) → motive kind |
Subrepresentation.coe_inf | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : CommRing A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} (ρ₁ ρ₂ : Subrepresentation ρ), ↑(ρ₁ ⊓ ρ₂) = ↑ρ₁ ∩ ↑ρ₂ |
Lean.Meta.Grind.CheckResult.closed.sizeOf_spec | Lean.Meta.Tactic.Grind.CheckResult | sizeOf Lean.Meta.Grind.CheckResult.closed = 1 |
CategoryTheory.Limits.coequalizer.condition_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasCoequalizer f g] {Z : C} (h : CategoryTheory.Limits.coequalizer f g ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) h) =
CategoryTheory.CategoryStruct.comp g
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) h) |
Std.DHashMap.Internal.Raw₀.getₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[LawfulBEq α] →
[inst_2 : Hashable α] → (m : Std.DHashMap.Internal.Raw₀ α β) → (a : α) → m.containsₘ a = true → β a |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar.0.MeasureTheory.Measure.tendsto_addHaar_inter_smul_zero_of_density_zero_aux1._simp_1_2 | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {a b : ENNReal}, (a / b = ⊤) = (a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤) |
ContinuousMap.addUnitsLift._proof_8 | Mathlib.Topology.ContinuousMap.Units | ∀ {X : Type u_2} {M : Type u_1} [inst : TopologicalSpace X] [inst_1 : AddMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : ContinuousAdd M] (f : AddUnits C(X, M)) (x : X), (↑(-f) + ↑f) x = 0 x |
CategoryTheory.Limits.Cocone.extensions | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone F) →
(CategoryTheory.coyoneda.obj (Opposite.op c.pt)).comp CategoryTheory.uliftFunctor.{u₁, v₃} ⟶ F.cocones |
Finset.max_abv_sum_one_le_of_isNonarchimedean | Mathlib.NumberTheory.Height.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : CommSemiring S] [inst_2 : LinearOrder S] [IsOrderedRing S]
{v : AbsoluteValue R S},
IsNonarchimedean ⇑v → ∀ {ι : Type u_3} (s : Finset ι) (x : ι → R), max (v (∑ i ∈ s, x i)) 1 ≤ ∏ i ∈ s, max (v (x i)) 1 |
Lean.LMVarId.getLevel | Lean.Meta.Basic | Lean.LMVarId → Lean.MetaM ℕ |
Lean.ToJson.recOn | Lean.Data.Json.FromToJson.Basic | {α : Type u} →
{motive : Lean.ToJson α → Sort u_1} →
(t : Lean.ToJson α) → ((toJson : α → Lean.Json) → motive { toJson := toJson }) → motive t |
Std.Iterators.Types.Flatten.IsPlausibleStep.recOn | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m (Std.IterM m β)] [inst_1 : Std.Iterator α₂ m β]
{motive :
(it : Std.IterM m β) →
(step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.Flatten.IsPlausibleStep it step → Prop}
{it : Std.IterM m β} {step : Std.IterStep (Std.IterM m β) β}
(t : Std.Iterators.Types.Flatten.IsPlausibleStep it step),
(∀ {it₁ it₁' : Std.IterM m (Std.IterM m β)} {it₂' : Std.IterM m β}
(a : it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂')),
motive { internalState := { it₁ := it₁, it₂ := none } }
(Std.IterStep.skip { internalState := { it₁ := it₁', it₂ := some it₂' } }) ⋯) →
(∀ {it₁ it₁' : Std.IterM m (Std.IterM m β)} (a : it₁.IsPlausibleStep (Std.IterStep.skip it₁')),
motive { internalState := { it₁ := it₁, it₂ := none } }
(Std.IterStep.skip { internalState := { it₁ := it₁', it₂ := none } }) ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} (a : it₁.IsPlausibleStep Std.IterStep.done),
motive { internalState := { it₁ := it₁, it₂ := none } } Std.IterStep.done ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} {it₂ it₂' : Std.IterM m β} {b : β}
(a : it₂.IsPlausibleStep (Std.IterStep.yield it₂' b)),
motive { internalState := { it₁ := it₁, it₂ := some it₂ } }
(Std.IterStep.yield { internalState := { it₁ := it₁, it₂ := some it₂' } } b) ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} {it₂ it₂' : Std.IterM m β}
(a : it₂.IsPlausibleStep (Std.IterStep.skip it₂')),
motive { internalState := { it₁ := it₁, it₂ := some it₂ } }
(Std.IterStep.skip { internalState := { it₁ := it₁, it₂ := some it₂' } }) ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} {it₂ : Std.IterM m β} (a : it₂.IsPlausibleStep Std.IterStep.done),
motive { internalState := { it₁ := it₁, it₂ := some it₂ } }
(Std.IterStep.skip { internalState := { it₁ := it₁, it₂ := none } }) ⋯) →
motive it step t |
Congr!.Config.etaExpand._default | Mathlib.Tactic.CongrExclamation | Bool |
GradedTensorProduct.«term_ᵍ⊗ₜ[_]_» | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | Lean.TrailingParserDescr |
Std.HashMap.Raw.all | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → Std.HashMap.Raw α β → (α → β → Bool) → Bool |
Lean.Meta.LazyDiscrTree.toFlat | Lean.Meta.LazyDiscrTree | {α : Type} →
Lean.Meta.LazyDiscrTree.ImportData →
Lean.Meta.LazyDiscrTree.PreDiscrTree α → BaseIO (Lean.Meta.LazyDiscrTree.InitResults α) |
_private.Init.Data.Array.InsertIdx.0.Array.insertIdx_comm._proof_4 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {i j : ℕ} {xs : Array α}, i ≤ j → j ≤ xs.size → ¬i ≤ xs.size + 1 → False |
FreeAddGroup.lift_mk | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {β : Type v} [inst : AddGroup β] {f : α → β},
(FreeAddGroup.lift f) (FreeAddGroup.mk L) = (List.map (fun x => bif x.2 then f x.1 else -f x.1) L).sum |
Submonoid.centerCongr_apply_coe | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (e : M ≃* N)
(r : ↥(Subsemigroup.center M)), ↑((Submonoid.centerCongr e) r) = e ↑r |
Lean.PrintImportResult.rec | Lean.Elab.ParseImportsFast | {motive : Lean.PrintImportResult → Sort u} →
((result? : Option Lean.ModuleHeader) → (errors : Array String) → motive { result? := result?, errors := errors }) →
(t : Lean.PrintImportResult) → motive t |
mul_pow_le_nat_floor_pow | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {c : ℝ}, 1 < c → ∀ (i : ℕ), (1 - c⁻¹) * c ^ i ≤ ↑⌊c ^ i⌋₊ |
Matrix.scalarAlgHom_apply | Mathlib.Data.Matrix.Basic | ∀ (n : Type u_3) (R : Type u_7) {α : Type u_11} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R]
[inst_3 : Semiring α] [inst_4 : Algebra R α] (a : α), (Matrix.scalarAlgHom n R) a = (Matrix.scalar n) a |
Real.arctan_tan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, -(Real.pi / 2) < x → x < Real.pi / 2 → Real.arctan (Real.tan x) = x |
derivWithin_fun_sum | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {s : Set 𝕜} {ι : Type u_1} {u : Finset ι} {A : ι → 𝕜 → F},
(∀ i ∈ u, DifferentiableWithinAt 𝕜 (A i) s x) →
derivWithin (fun y => ∑ i ∈ u, A i y) s x = ∑ i ∈ u, derivWithin (A i) s x |
Set.bijOn_of_subsingleton | Mathlib.Data.Set.Function | ∀ {α : Type u_1} [Subsingleton α] (f : α → α) (s : Set α), Set.BijOn f s s |
Finset.divisionCommMonoid._proof_3 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : DivisionCommMonoid α] (s : Finset α), ↑s⁻¹ = (↑s)⁻¹ |
Polynomial.nextCoeff_map | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S},
Function.Injective ⇑f → ∀ (p : Polynomial R), (Polynomial.map f p).nextCoeff = f p.nextCoeff |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.sSupNormIm_scale_right._simp_1_3 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y |
Lean.Compiler.LCNF.ToLCNF.Context.casesOn | Lean.Compiler.LCNF.ToLCNF | {motive : Lean.Compiler.LCNF.ToLCNF.Context → Sort u} →
(t : Lean.Compiler.LCNF.ToLCNF.Context) →
((ignoreNoncomputable : Bool) → motive { ignoreNoncomputable := ignoreNoncomputable }) → motive t |
ISize.add_eq_left._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : ISize}, (a + b = a) = (b = 0) |
Subgroup.equivOp.eq_1 | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_2} [inst : Group G] (H : Subgroup G), H.equivOp = MulOpposite.opEquiv.subtypeEquiv ⋯ |
innerSL._proof_1 | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], RingHomIsometric (RingHom.id 𝕜) |
AddMonoid.Coprod.swap_eq_zero | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {x : AddMonoid.Coprod M N},
(AddMonoid.Coprod.swap M N) x = 0 ↔ x = 0 |
Batteries.UnionFind.rankD_set | Batteries.Data.UnionFind.Basic | ∀ {arr : Array Batteries.UFNode} {x : ℕ} {v : Batteries.UFNode} {i : ℕ} {h : x < arr.size},
Batteries.UnionFind.rankD (arr.set x v h) i = if x = i then v.rank else Batteries.UnionFind.rankD arr i |
Lean.Meta.Sym.instHashableAlphaKey._private_1 | Lean.Meta.Sym.AlphaShareCommon | Lean.Meta.Sym.AlphaKey → UInt64 |
CategoryTheory.toOverIsoToOverUnit | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
CategoryTheory.toOver (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ CategoryTheory.toOverUnit C |
CategoryTheory.Limits.ImageFactorisation | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (X ⟶ Y) → Type (max u v) |
CategoryTheory.Functor.CoconeTypes.postcomp._proof_2 | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {F : CategoryTheory.Functor J (Type u_3)}
(c : F.CoconeTypes) {T : Type u_4} (φ : c.pt → T) {j j' : J} (f : j ⟶ j'), (φ ∘ c.ι j') ∘ F.map f = φ ∘ c.ι j |
CategoryTheory.Grp.instMonoidalCategory._proof_11 | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : CategoryTheory.Grp C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
(f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂) f₃)
(CategoryTheory.MonoidalCategoryStruct.associator Y₁ Y₂ Y₃).hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X₁ X₂ X₃).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ (CategoryTheory.MonoidalCategoryStruct.tensorHom f₂ f₃)) |
Lean.Meta.Simp.simpMatchDiscrs? | Lean.Meta.Tactic.Simp.Rewrite | Lean.Meta.MatcherInfo → Lean.Expr → Lean.Meta.SimpM (Option Lean.Meta.Simp.Result) |
CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_19 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ}, ∀ k ≤ n, k + 1 + 2 < n + 3 + 1 |
_private.Mathlib.Tactic.Linter.DeprecatedModule.0.Mathlib.Linter.DeprecatedModule.deprecated.moduleLinter.match_1 | Mathlib.Tactic.Linter.DeprecatedModule | (motive : Lean.Syntax × Lean.Name → Sort u_1) →
(x : Lean.Syntax × Lean.Name) → ((nmStx : Lean.Syntax) → (snd : Lean.Name) → motive (nmStx, snd)) → motive x |
Set.IsWF.mono | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} [inst : LT α] {s t : Set α}, t.IsWF → s ⊆ t → s.IsWF |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.