name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Time.Weekday.noConfusionType | Std.Time.Date.Unit.Weekday | Sort v✝ → Std.Time.Weekday → Std.Time.Weekday → Sort v✝ | true |
CategoryTheory.Limits.WidePushoutShape.equivalenceOfEquiv._proof_10 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1} (J' : Type u_2) (h : J ≃ J') (X : CategoryTheory.Limits.WidePushoutShape J),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePushoutShape.Hom.init (h j)).map
((CategoryTheory.NatIso.ofComponents
(fun j =>
Option.casesOn (motive := fun t =>
j = t →
((CategoryTheory.Functor.id (CategoryTheory.Limits.WidePushoutShape J)).obj j ≅
((CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePushoutShape.Hom.init (h j)).comp
(CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h.invFun j))
fun j => CategoryTheory.Limits.WidePushoutShape.Hom.init (h.invFun j))).obj
j))
j (fun h_1 => ⋯ ▸ CategoryTheory.eqToIso ⋯) (fun val h_1 => ⋯ ▸ CategoryTheory.eqToIso ⋯) ⋯)
⋯).hom.app
X))
((CategoryTheory.NatIso.ofComponents
(fun j =>
Option.casesOn (motive := fun t =>
j = t →
(((CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h.invFun j)) fun j =>
CategoryTheory.Limits.WidePushoutShape.Hom.init (h.invFun j)).comp
(CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePushoutShape.Hom.init (h j))).obj
j ≅
(CategoryTheory.Functor.id (CategoryTheory.Limits.WidePushoutShape J')).obj j))
j (fun h_1 => ⋯ ▸ CategoryTheory.eqToIso ⋯) (fun val h_1 => ⋯ ▸ CategoryTheory.eqToIso ⋯) ⋯)
⋯).hom.app
((CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePushoutShape.Hom.init (h j)).obj
X)) =
CategoryTheory.CategoryStruct.id
((CategoryTheory.Limits.WidePushoutShape.wideSpan none (fun j => some (h j)) fun j =>
CategoryTheory.Limits.WidePushoutShape.Hom.init (h j)).obj
X) | false |
Finset.HasAntidiagonal.antidiagonal | Mathlib.Algebra.Order.Antidiag.Prod | {A : Type u_1} → {inst : AddMonoid A} → [self : Finset.HasAntidiagonal A] → A → Finset (A × A) | true |
Finset.mul_eq_empty._simp_2 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α}, (s * t = ∅) = (s = ∅ ∨ t = ∅) | false |
Std.ExtDTreeMap.get?_diff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α}, (t₁ \ t₂).get? k = if k ∈ t₂ then none else t₁.get? k | true |
Array.foldr_subtype' | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {start : ℕ} {p : α → Prop} {xs : Array { x // p x }} {f : { x // p x } → β → β}
{g : α → β → β} {x : β},
(∀ (x : α) (h : p x) (b : β), f ⟨x, h⟩ b = g x b) →
start = xs.size → Array.foldr f x xs start = Array.foldr g x xs.unattach | true |
CategoryTheory.Pretriangulated.rotCompInvRot | Mathlib.CategoryTheory.Triangulated.Rotate | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.HasShift C ℤ] →
[∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C) ≅
(CategoryTheory.Pretriangulated.rotate C).comp (CategoryTheory.Pretriangulated.invRotate C) | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell.match_5.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (l : Std.DTreeMap.Internal.Impl α β) → l.Balanced → Sort u_3)
(hl : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(h_1 : (hl : Std.DTreeMap.Internal.Impl.leaf.Balanced) → motive Std.DTreeMap.Internal.Impl.leaf hl)
(h_2 :
(sz : ℕ) →
(ky : α) →
(y : β ky) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(hl : (Std.DTreeMap.Internal.Impl.inner sz ky y l r).Balanced) →
motive (Std.DTreeMap.Internal.Impl.inner sz ky y l r) hl),
(match Std.DTreeMap.Internal.Impl.leaf, hl with
| Std.DTreeMap.Internal.Impl.leaf, hl => h_1 hl
| Std.DTreeMap.Internal.Impl.inner sz ky y l r, hl => h_2 sz ky y l r hl) =
h_1 hl | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.TauPackage.color_lt._simp_1_13 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | false |
CategoryTheory.Subobject.pullback_self | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {A B : C}
(f : A ⟶ B) [inst_2 : CategoryTheory.Mono f],
(CategoryTheory.Subobject.pullback f).obj (CategoryTheory.Subobject.mk f) = ⊤ | true |
HereditarilyLindelofSpace.isLindelof | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u} [inst : TopologicalSpace X] [HereditarilyLindelofSpace X] (s : Set X), IsLindelof s | true |
Real.cos_sub_cos | Mathlib.Analysis.Complex.Trigonometric | ∀ (x y : ℝ), Real.cos x - Real.cos y = -2 * Real.sin ((x + y) / 2) * Real.sin ((x - y) / 2) | true |
CStarMatrix.map_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {M : CStarMatrix m n A} {f : A → B} {i : m} {j : n},
M.map f i j = f (M i j) | true |
_private.Lean.Widget.UserWidget.0.Lean.Widget.initFn._@.Lean.Widget.UserWidget.1015473889._hygCtx._hyg.2 | Lean.Widget.UserWidget | IO Lean.Widget.PanelWidgetsExt✝ | false |
Lean.Meta.Simp.SimprocOLeanEntry | Lean.Meta.Tactic.Simp.Types | Type | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comapOn_isBase_iff_of_surjOn._simp_1_3 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {M : Matroid α} {I X : Set α}, M.IsBasis' I X = M.IsBasis I (X ∩ M.E) | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.chevalley_mvPolynomialC._simp_1_6 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} {x : M}, (x ∈ p ⊓ q) = (x ∈ p ∧ x ∈ q) | false |
CategoryTheory.plusPlusAdjunction | Mathlib.CategoryTheory.Sites.ConcreteSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(D : Type w) →
[inst_1 : CategoryTheory.Category.{w', w} D] →
{FD : D → D → Type u_1} →
{CD : D → Type t} →
[inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (CD Y)] →
[instCC : CategoryTheory.ConcreteCategory D FD] →
[inst_3 :
∀ {X : C} (S : J.Cover X),
CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Limits.WalkingMulticospan S.shape)
(CategoryTheory.forget D)] →
[inst_4 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X),
CategoryTheory.Limits.HasMultiequalizer (S.index P)] →
[inst_5 : ∀ (X : C), CategoryTheory.Limits.HasColimitsOfShape (J.Cover X)ᵒᵖ D] →
[inst_6 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfShape (J.Cover X)ᵒᵖ (CategoryTheory.forget D)] →
[inst_7 : (CategoryTheory.forget D).ReflectsIsomorphisms] →
CategoryTheory.plusPlusSheaf J D ⊣ CategoryTheory.sheafToPresheaf J D | true |
Lean.Expr.letE | Lean.Expr | Lean.Name → Lean.Expr → Lean.Expr → Lean.Expr → Bool → Lean.Expr | true |
Std.DTreeMap.Internal.Impl.ExplorationStep.gt.inj | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} {inst : Ord α} {k : α → Ordering} {a : List ((a : α) × β a)} {a_1 : α}
{a_2 : k a_1 = Ordering.gt} {a_3 : β a_1} {a_4 : List ((a : α) × β a)} {a_5 : α} {a_6 : k a_5 = Ordering.gt}
{a_7 : β a_5},
Std.DTreeMap.Internal.Impl.ExplorationStep.gt a a_1 a_2 a_3 =
Std.DTreeMap.Internal.Impl.ExplorationStep.gt a_4 a_5 a_6 a_7 →
a = a_4 ∧ a_1 = a_5 ∧ a_3 ≍ a_7 | true |
Set.mapsTo_sUnion | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_2} {S : Set (Set α)} {t : Set β} {f : α → β},
Set.MapsTo f (⋃₀ S) t ↔ ∀ s ∈ S, Set.MapsTo f s t | true |
SubAddAction.ofStabilizer.addConjMap_comp | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : AddGroup G] {α : Type u_2} [inst_1 : AddAction G α] {g h k : G} {a b c : α} (hg : b = g +ᵥ a)
(hh : c = h +ᵥ b) (hk : c = k +ᵥ a) (H : k = h + g),
(SubAddAction.ofStabilizer.conjMap hh).comp (SubAddAction.ofStabilizer.conjMap hg) =
SubAddAction.ofStabilizer.conjMap hk | true |
_private.Init.Data.UInt.Bitwise.0.USize.toUInt8_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | false |
Lean.Grind.Ring.toIntModule | Init.Grind.Ring.Basic | {α : Type u} → [I : Lean.Grind.Ring α] → Lean.Grind.IntModule α | true |
RingCat.Colimits.ColimitType.AddGroup._proof_2 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat) (n : ℕ)
(x : RingCat.Colimits.ColimitType F), nsmulRec (n + 1) x = nsmulRec n x + x | false |
SpecialLinearGroup.baseChange._proof_3 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_3} {V : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {S : Type u_2}
[inst_3 : CommRing S] [inst_4 : Algebra R S] [inst_5 : Module.Free R V] [inst_6 : Module.Finite R V]
(x y : SpecialLinearGroup R V),
↑⟨LinearEquiv.baseChange R S V V ↑(x * y), ⋯⟩ =
↑(⟨LinearEquiv.baseChange R S V V ↑x, ⋯⟩ * ⟨LinearEquiv.baseChange R S V V ↑y, ⋯⟩) | false |
CategoryTheory.GradedObject.mapBifunctor₁₂BifunctorDesc.congr_simp | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_5, u_5} C₁₂] {F₁₂ : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₁₂)}
{G : CategoryTheory.Functor C₁₂ (CategoryTheory.Functor C₃ C₄)} {I₁ : Type u_7} {I₂ : Type u_8} {I₃ : Type u_9}
{J : Type u_10} {r : I₁ × I₂ × I₃ → J} {ρ₁₂ : CategoryTheory.GradedObject.BifunctorComp₁₂IndexData r}
{X₁ : CategoryTheory.GradedObject I₁ C₁} {X₂ : CategoryTheory.GradedObject I₂ C₂}
{X₃ : CategoryTheory.GradedObject I₃ C₃}
[inst_5 : (((CategoryTheory.GradedObject.mapBifunctor F₁₂ I₁ I₂).obj X₁).obj X₂).HasMap ρ₁₂.p]
[inst_6 :
(((CategoryTheory.GradedObject.mapBifunctor G ρ₁₂.I₁₂ I₃).obj
(CategoryTheory.GradedObject.mapBifunctorMapObj F₁₂ ρ₁₂.p X₁ X₂)).obj
X₃).HasMap
ρ₁₂.q]
[H : CategoryTheory.GradedObject.HasGoodTrifunctor₁₂Obj F₁₂ G ρ₁₂ X₁ X₂ X₃] {j : J} {A : C₄}
(f f_1 :
(i₁ : I₁) → (i₂ : I₂) → (i₃ : I₃) → r (i₁, i₂, i₃) = j → ((G.obj ((F₁₂.obj (X₁ i₁)).obj (X₂ i₂))).obj (X₃ i₃) ⟶ A)),
f = f_1 →
CategoryTheory.GradedObject.mapBifunctor₁₂BifunctorDesc f =
CategoryTheory.GradedObject.mapBifunctor₁₂BifunctorDesc f_1 | true |
Lean.Meta.AbstractMVars.State.recOn | Lean.Meta.AbstractMVars | {motive : Lean.Meta.AbstractMVars.State → Sort u} →
(t : Lean.Meta.AbstractMVars.State) →
((ngen : Lean.NameGenerator) →
(lctx : Lean.LocalContext) →
(mctx : Lean.MetavarContext) →
(nextParamIdx : ℕ) →
(paramNames : Array Lean.Name) →
(fvars mvars : Array Lean.Expr) →
(lmap : Std.HashMap Lean.LMVarId Lean.Level) →
(emap : Std.HashMap Lean.MVarId Lean.Expr) →
(abstractLevels : Bool) →
motive
{ ngen := ngen, lctx := lctx, mctx := mctx, nextParamIdx := nextParamIdx,
paramNames := paramNames, fvars := fvars, mvars := mvars, lmap := lmap, emap := emap,
abstractLevels := abstractLevels }) →
motive t | false |
Seminorm.continuous_iff_continuous_comp | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ {𝕝 : Type u_4} {𝕝₂ : Type u_5} {E : Type u_6} {F : Type u_7} {ι' : Type u_10} [inst : AddCommGroup E]
[inst_1 : NormedField 𝕝] [inst_2 : Module 𝕝 E] [inst_3 : AddCommGroup F] [inst_4 : NormedField 𝕝₂]
[inst_5 : Module 𝕝₂ F] {τ₁₂ : 𝕝 →+* 𝕝₂} [inst_6 : RingHomIsometric τ₁₂] {q : SeminormFamily 𝕝₂ F ι'}
[inst_7 : TopologicalSpace E] [IsTopologicalAddGroup E] [inst_9 : TopologicalSpace F],
WithSeminorms q → ∀ (f : E →ₛₗ[τ₁₂] F), Continuous ⇑f ↔ ∀ (i : ι'), Continuous ⇑((q i).comp f) | true |
ContinuousMap.sigmaCodHomeomorph.match_1 | Mathlib.Topology.ContinuousMap.Sigma | ∀ (X : Type u_3) {ι : Type u_1} (Y : ι → Type u_2) [inst : TopologicalSpace X]
[inst_1 : (i : ι) → TopologicalSpace (Y i)] (f : C(X, (i : ι) × Y i))
(motive : (∃ i g, f = (ContinuousMap.sigmaMk i).comp g) → Prop) (x : ∃ i g, f = (ContinuousMap.sigmaMk i).comp g),
(∀ (i : ι) (g : C(X, Y i)) (hg : f = (ContinuousMap.sigmaMk i).comp g), motive ⋯) → motive x | false |
Lean.Lsp.DocumentFilter.ctorIdx | Lean.Data.Lsp.Basic | Lean.Lsp.DocumentFilter → ℕ | false |
_private.Init.Data.Dyadic.Basic.0.Dyadic.ble_iff_toRat._simp_1_1 | Init.Data.Dyadic.Basic | ∀ {x y : Dyadic}, (x.blt y = true) = (x.toRat < y.toRat) | false |
NNRat.cast_zpow | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionSemiring α] [CharZero α] (q : ℚ≥0) (p : ℤ), ↑(q ^ p) = ↑q ^ p | true |
OrderIso.subRight_symm_apply | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LE α] [inst_2 : AddRightMono α] (a b : α),
(RelIso.symm (OrderIso.subRight a)) b = b + a | true |
Submodule.isHilbertSumOrthogonal | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (K : Submodule 𝕜 E) [hK : CompleteSpace ↥K],
IsHilbertSum 𝕜 (fun b => ↥(bif b then K else Kᗮ)) fun b => (bif b then K else Kᗮ).subtypeₗᵢ | true |
List.min | Init.Data.List.Basic | {α : Type u} → [Min α] → (l : List α) → l ≠ [] → α | true |
Filter.empty_notMem | Mathlib.Order.Filter.Basic | ∀ {α : Type u} (f : Filter α) [f.NeBot], ∅ ∉ f | true |
SeparationQuotient.instNormalSpace | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [NormalSpace X], NormalSpace (SeparationQuotient X) | true |
Lean.VersoModuleDocs.Snippet.addBlock | Lean.DocString.Extension | Lean.VersoModuleDocs.Snippet → Lean.Doc.Block Lean.ElabInline Lean.ElabBlock → Lean.VersoModuleDocs.Snippet | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft._proof_5 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.RotateLeft | ∀ {w : ℕ} (distance curr : ℕ), curr < w → ¬curr + 1 ≤ w → False | false |
Norm.mk | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → (E → ℝ) → Norm E | true |
«term_∨_» | Init.Notation | Lean.TrailingParserDescr | true |
ceilDiv_le_iff_le_mul | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : CeilDiv α α] {a b c : α},
0 < a → (b ⌈/⌉ a ≤ c ↔ b ≤ a * c) | true |
BoundedOrderHom.dual_apply_toOrderHom | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] (f : BoundedOrderHom α β), (BoundedOrderHom.dual f).toOrderHom = OrderHom.dual f.toOrderHom | true |
DivisionRing.continuousConstSMul_rat | Mathlib.Topology.Algebra.Algebra.Rat | ∀ {A : Type u_1} [inst : DivisionRing A] [inst_1 : TopologicalSpace A] [SeparatelyContinuousMul A]
[inst_3 : CharZero A], ContinuousConstSMul ℚ A | true |
RatFunc.denom_div_dvd | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] (p q : Polynomial K),
((algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q).denom ∣ q | true |
Fin.map_rev_findRev? | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {p : Fin n → Bool}, Option.map Fin.rev (Fin.findRev? fun x => p x.rev) = Fin.find? p | true |
CategoryTheory.CategoryOfElements.map._proof_2 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {F₁ F₂ : CategoryTheory.Functor C (Type u_1)}
(α : F₁ ⟶ F₂) (X : F₁.Elements),
⟨↑(CategoryTheory.CategoryStruct.id X), ⋯⟩ = CategoryTheory.CategoryStruct.id ⟨X.fst, α.app X.fst X.snd⟩ | false |
ProbabilityTheory.integrable_cauchyPDFReal | Mathlib.Probability.Distributions.Cauchy | ∀ (x₀ : ℝ) {γ : NNReal}, MeasureTheory.Integrable (ProbabilityTheory.cauchyPDFReal x₀ γ) MeasureTheory.volume | true |
_private.Mathlib.Data.Fin.Basic.0.Fin.coe_int_sub_eq_mod._proof_1_3 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} (u v : Fin n), ¬0 ≤ ↑↑u - ↑↑v + ↑n → False | false |
dist_le_dist_of_le_pi | Mathlib.Analysis.Normed.Order.UpperLower | ∀ {ι : Type u_2} [inst : Fintype ι] {a₁ a₂ b₁ b₂ : ι → ℝ}, a₂ ≤ a₁ → a₁ ≤ b₁ → b₁ ≤ b₂ → dist a₁ b₁ ≤ dist a₂ b₂ | true |
ClosedAddSubgroup.mk.sizeOf_spec | Mathlib.Topology.Algebra.Group.ClosedSubgroup | ∀ {G : Type u} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : SizeOf G] (toAddSubgroup : AddSubgroup G)
(isClosed' : IsClosed toAddSubgroup.carrier),
sizeOf { toAddSubgroup := toAddSubgroup, isClosed' := isClosed' } = 1 + sizeOf toAddSubgroup + sizeOf isClosed' | true |
_private.Mathlib.MeasureTheory.Measure.Hausdorff.0.MeasureTheory.Measure.hausdorffMeasure_zero_singleton._simp_1_2 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {α : Type u_3} [inst : Preorder α] [IsDirectedOrder α] {p : α → Prop} [Nonempty α],
(∀ᶠ (x : α) in Filter.atTop, p x) = ∃ a, ∀ b ≥ a, p b | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LitValue.impureTypeScalarNumLit._sparseCasesOn_2 | Lean.Compiler.LCNF.Basic | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
FreeAddGroup.mk | Mathlib.GroupTheory.FreeGroup.Basic | {α : Type u} → List (α × Bool) → FreeAddGroup α | true |
Nat.floor_natCast | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] [IsStrictOrderedRing R]
(n : ℕ), ⌊↑n⌋₊ = n | true |
CategoryTheory.LaxMonoidalFunctor.Hom.ctorIdx | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{D : Type u₂} →
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} →
{inst_3 : CategoryTheory.MonoidalCategory D} → {F G : CategoryTheory.LaxMonoidalFunctor C D} → F.Hom G → ℕ | false |
_private.Init.Data.String.Decode.0.parseFirstByte_eq_done_of_utf8DecodeChar?_eq_some | Init.Data.String.Decode | ∀ {b : ByteArray} {i : ℕ} {c : Char},
b.utf8DecodeChar? i = some c →
c.utf8Size = 1 →
∀ (h' : i < b.size), ByteArray.utf8DecodeChar?.parseFirstByte b[i] = ByteArray.utf8DecodeChar?.FirstByte.done | true |
Aesop.SearchM.instMonad | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Monad (Aesop.SearchM Q) | true |
NNReal.rpow_sub_one' | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {y : ℝ}, y - 1 ≠ 0 → ∀ (x : NNReal), x ^ (y - 1) = x ^ y / x | true |
cyclotomicCharacter.toFun._proof_1 | Mathlib.NumberTheory.Cyclotomic.CyclotomicCharacter | ∀ (p : ℕ) [Fact (Nat.Prime p)] (x : ℕ), NeZero (p ^ x) | false |
Quiver.Path.vertices_ne_nil | Mathlib.Combinatorics.Quiver.Path.Vertices | ∀ {V : Type u_1} [inst : Quiver V] {a b : V} (p : Quiver.Path a b), p.vertices ≠ [] | true |
Pi.constMonoidHom._proof_2 | Mathlib.Algebra.Group.Pi.Lemmas | ∀ (α : Type u_1) (β : Type u_2) [inst : MulOneClass β] (x x_1 : β),
Function.const α (x * x_1) = Function.const α (x * x_1) | false |
CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.ofIso._proof_3 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : CategoryTheory.SimplicialObject.Augmented C}
(e : X ≅ Y) (ed : X.ExtraDegeneracy),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.SimplicialObject.Augmented.drop.mapIso e).inv.app (Opposite.op (SimplexCategory.mk 0)))
(CategoryTheory.CategoryStruct.comp (ed.s 0)
((CategoryTheory.SimplicialObject.Augmented.drop.mapIso e).hom.app
(Opposite.op (SimplexCategory.mk (0 + 1))))))
(Y.left.δ 1) =
CategoryTheory.CategoryStruct.comp (Y.hom.app (Opposite.op (SimplexCategory.mk 0)))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.SimplicialObject.Augmented.point.mapIso e).inv
(CategoryTheory.CategoryStruct.comp ed.s'
((CategoryTheory.SimplicialObject.Augmented.drop.mapIso e).hom.app (Opposite.op (SimplexCategory.mk 0))))) | false |
IsDedekindFiniteAddMonoid.rec | Mathlib.Algebra.Group.Defs | {M : Type u_2} →
[inst : AddZero M] →
{motive : IsDedekindFiniteAddMonoid M → Sort u} →
((add_eq_zero_symm : ∀ {a b : M}, a + b = 0 → b + a = 0) → motive ⋯) →
(t : IsDedekindFiniteAddMonoid M) → motive t | false |
Lean.Meta.MVarRenaming.mk.injEq | Lean.Meta.Match.MVarRenaming | ∀ (map map_1 : Lean.MVarIdMap Lean.MVarId), ({ map := map } = { map := map_1 }) = (map = map_1) | true |
Lean.Elab.WF.GuessLex.RecCallWithContext.rec | Lean.Elab.PreDefinition.WF.GuessLex | {motive : Lean.Elab.WF.GuessLex.RecCallWithContext → Sort u} →
((ref : Lean.Syntax) →
(caller : ℕ) →
(params : Array Lean.Expr) →
(callee : ℕ) →
(args : Array Lean.Expr) →
(ctxt : Lean.Elab.WF.GuessLex.SavedLocalContext) →
motive
{ ref := ref, caller := caller, params := params, callee := callee, args := args, ctxt := ctxt }) →
(t : Lean.Elab.WF.GuessLex.RecCallWithContext) → motive t | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₄_eq_some_of_toBitVec._simp_1_6 | Init.Data.String.Decode | ∀ {n : ℕ} {x y : BitVec n}, (x ≤ y) = (x.toNat ≤ y.toNat) | false |
TopCat.uliftFunctor._proof_2 | Mathlib.Topology.Category.TopCat.ULift | ∀ (X : TopCat),
TopCat.ofHom
{ toFun := ULift.map ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)),
continuous_toFun := ⋯ } =
CategoryTheory.CategoryStruct.id (TopCat.of (ULift.{u_2, u_1} ↑X)) | false |
FormalMultilinearSeries.iteratedFDerivSeries._proof_5 | Mathlib.Analysis.Analytic.IteratedFDeriv | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (k : ℕ),
ContinuousAdd (ContinuousMultilinearMap 𝕜 (fun i => E) F) | false |
Complex.real_le_real | Mathlib.Analysis.Complex.Order | ∀ {x y : ℝ}, ↑x ≤ ↑y ↔ x ≤ y | true |
NumberField.ComplexEmbedding.IsConj.ext_iff | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_1} [inst : Field K] {k : Type u_2} [inst_1 : Field k] [inst_2 : Algebra k K] {φ : K →+* ℂ}
{σ₁ σ₂ : Gal(K/k)}, NumberField.ComplexEmbedding.IsConj φ σ₁ → (σ₁ = σ₂ ↔ NumberField.ComplexEmbedding.IsConj φ σ₂) | true |
CategoryTheory.StrictlyUnitaryPseudofunctor.casesOn | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{motive : CategoryTheory.StrictlyUnitaryPseudofunctor B C → Sort u} →
(t : CategoryTheory.StrictlyUnitaryPseudofunctor B C) →
((toPseudofunctor : CategoryTheory.Pseudofunctor B C) →
(map_id :
∀ (X : B),
toPseudofunctor.map (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id (toPseudofunctor.obj X)) →
(mapId_eq_eqToIso : ∀ (X : B), toPseudofunctor.mapId X = CategoryTheory.eqToIso ⋯) →
motive
{ toPseudofunctor := toPseudofunctor, map_id := map_id, mapId_eq_eqToIso := mapId_eq_eqToIso }) →
motive t | false |
Std.DHashMap.Internal.Raw₀.Const.insertMany_list_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF →
(↑m₂).WF →
(↑m₁).Equiv ↑m₂ →
∀ {l : List (α × β)},
(↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m₁ l)).Equiv
↑↑(Std.DHashMap.Internal.Raw₀.Const.insertMany m₂ l) | true |
SetLike.gsemiring._proof_7 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : AddMonoid ι] [inst_1 : Semiring R] [inst_2 : SetLike σ R]
[AddSubmonoidClass σ R] (A : ι → σ) [SetLike.GradedMonoid A] (n : ℕ), ↑n ∈ A 0 | false |
_private.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.insertAux.match_1 | Lean.Data.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(motive : Lean.PersistentHashMap.CollisionNode α β → Sort u_3) →
(newNode : Lean.PersistentHashMap.CollisionNode α β) →
((es : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) →
(h : Lean.PersistentHashMap.IsCollisionNode (Lean.PersistentHashMap.Node.entries es)) →
motive ⟨Lean.PersistentHashMap.Node.entries es, h⟩) →
((keys : Array α) →
(vals : Array β) →
(heq : keys.size = vals.size) →
(property :
Lean.PersistentHashMap.IsCollisionNode (Lean.PersistentHashMap.Node.collision keys vals heq)) →
motive ⟨Lean.PersistentHashMap.Node.collision keys vals heq, property⟩) →
motive newNode | false |
Height.logHeight₁_div_eq_logHeight | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] (x y : K),
Height.logHeight₁ (x / y) = Height.logHeight ![x, y] | true |
Mathlib.Meta.NormNum.IsNat.nnreal_rpow_eq_nnreal_pow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {b : ℝ} {n : ℕ}, Mathlib.Meta.NormNum.IsNat b n → ∀ (a : NNReal), a ^ b = a ^ n | true |
Lean.LOption.casesOn | Lean.Data.LOption | {α : Type u} →
{motive : Lean.LOption α → Sort u_1} →
(t : Lean.LOption α) →
motive Lean.LOption.none → ((a : α) → motive (Lean.LOption.some a)) → motive Lean.LOption.undef → motive t | false |
_private.Mathlib.CategoryTheory.Sites.IsSheafFor.0.CategoryTheory.Presieve.isSheafFor_bind._proof_1_11 | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X : C} (P : CategoryTheory.Functor Cᵒᵖ (Type u_1))
(U : CategoryTheory.Sieve X) (B : ⦃Y : C⦄ → ⦃f : Y ⟶ X⦄ → U.arrows f → CategoryTheory.Sieve Y)
(hB : ∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄ (hf : U.arrows f), CategoryTheory.Presieve.IsSheafFor P (B hf).arrows)
(s : CategoryTheory.Presieve.FamilyOfElements P (CategoryTheory.Sieve.bind U.arrows B).arrows)
(hy :
∀ ⦃Y : C⦄ ⦃f : Y ⟶ X⦄ (hf : U.arrows f),
CategoryTheory.Presieve.FamilyOfElements.Compatible
((fun Y f hf Z g hg => s (CategoryTheory.CategoryStruct.comp g f) ⋯) Y f hf))
⦃Z W : C⦄ (f : Z ⟶ X) (h : W ⟶ Z) (hf : U.arrows f) ⦃Y : C⦄ ⦃l : Y ⟶ W⦄ (hl : (B ⋯).arrows l) ⦃M : C⦄ ⦃m : M ⟶ Y⦄
(this :
(CategoryTheory.Sieve.bind U.arrows B).arrows
(CategoryTheory.CategoryStruct.comp m
(CategoryTheory.CategoryStruct.comp l (CategoryTheory.CategoryStruct.comp h f)))),
P.map m.op
(P.map l.op
((fun Y f hf => ⋯.amalgamate ((fun Y f hf Z g hg => s (CategoryTheory.CategoryStruct.comp g f) ⋯) Y f hf) ⋯) W
(CategoryTheory.CategoryStruct.comp h f) ⋯)) =
(fun Y f hf Z g hg => s (CategoryTheory.CategoryStruct.comp g f) ⋯) W (CategoryTheory.CategoryStruct.comp h f) ⋯ M
(CategoryTheory.CategoryStruct.comp m l) ⋯ →
P.map m.op
(P.map l.op
((fun Y f hf => ⋯.amalgamate ((fun Y f hf Z g hg => s (CategoryTheory.CategoryStruct.comp g f) ⋯) Y f hf) ⋯) W
(CategoryTheory.CategoryStruct.comp h f) ⋯)) =
s
(CategoryTheory.CategoryStruct.comp m
(CategoryTheory.CategoryStruct.comp l (CategoryTheory.CategoryStruct.comp h f)))
this | false |
SuccAddOrder.noConfusionType | Mathlib.Algebra.Order.SuccPred | Sort u →
{α : Type u_1} →
[inst : Preorder α] →
[inst_1 : Add α] →
[inst_2 : One α] →
SuccAddOrder α →
{α' : Type u_1} → [inst' : Preorder α'] → [inst'_1 : Add α'] → [inst'_2 : One α'] → SuccAddOrder α' → Sort u | false |
CategoryTheory.Mon.trivial_mon_mul | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C],
CategoryTheory.MonObj.mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitTraceNodesM.go.match_1 | Mathlib.Tactic.DefEqAbuse | {α : Type} →
(motive : Lean.MessageData.VisitStep✝ α → Sort u_1) →
(__do_lift : Lean.MessageData.VisitStep✝¹ α) →
((a? : Option α) → motive (Lean.MessageData.VisitStep.descend✝ a?)) →
((a? : Option α) → motive (Lean.MessageData.VisitStep.ascend✝ a?)) → motive __do_lift | false |
_private.Mathlib.Data.Finset.Disjoint.0.Finset.disjoint_singleton_left._simp_1_3 | Mathlib.Data.Finset.Disjoint | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | false |
Metric.Snowflaking.uniformContinuous_toSnowflaking | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : UniformSpace X],
UniformContinuous ⇑Metric.Snowflaking.toSnowflaking | true |
continouousOn_union_iff_of_isClosed | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {s t : Set α} {f : α → β},
IsClosed s → IsClosed t → (ContinuousOn f (s ∪ t) ↔ ContinuousOn f s ∧ ContinuousOn f t) | true |
Algebra.FiniteType.mk._flat_ctor | Mathlib.RingTheory.FiniteType | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
⊤.FG → Algebra.FiniteType R A | false |
_private.Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence.0.Mathlib.Tactic.Bicategory._aux_Mathlib_Tactic_CategoryTheory_Bicategory_PureCoherence___unexpand_CategoryTheory_Bicategory_whiskerLeftIso_1 | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | Lean.PrettyPrinter.Unexpander | false |
AddSubgroup.isOpen_of_mem_nhds | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [SeparatelyContinuousAdd G] (H : AddSubgroup G)
{g : G}, ↑H ∈ nhds g → IsOpen ↑H | true |
fderivWithin_comp_derivWithin | Mathlib.Analysis.Calculus.Deriv.Comp | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type w} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E] {f : 𝕜 → F} (x : 𝕜)
{s : Set 𝕜} {l : F → E} {t : Set F},
DifferentiableWithinAt 𝕜 l t (f x) →
DifferentiableWithinAt 𝕜 f s x →
Set.MapsTo f s t → derivWithin (l ∘ f) s x = (fderivWithin 𝕜 l t (f x)) (derivWithin f s x) | true |
LinearMap.BilinForm.ker_restrict_eq_of_codisjoint | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M},
Codisjoint p q →
∀ {B : LinearMap.BilinForm R M},
(∀ x ∈ p, ∀ y ∈ q, (B x) y = 0) → LinearMap.ker (B.restrict p) = Submodule.comap p.subtype (LinearMap.ker B) | true |
Std.HashMap.Raw.size_alter_le_size | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : LawfulBEq α]
{k : α} {f : Option β → Option β}, m.WF → (m.alter k f).size ≤ m.size + 1 | true |
contDiff_norm_sq | Mathlib.Analysis.InnerProductSpace.Calculus | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [InnerProductSpace 𝕜 E]
[inst : NormedSpace ℝ E] {n : WithTop ℕ∞}, ContDiff ℝ n fun x => ‖x‖ ^ 2 | true |
CategoryTheory.Functor.partialRightAdjoint._proof_2 | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D) {X Y Z : F.PartialRightAdjointSource}
(f : X ⟶ Y) (g : Y ⟶ Z),
F.partialRightAdjointMap (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (F.partialRightAdjointMap f) (F.partialRightAdjointMap g) | false |
PiTensorProduct.dualDistribInvOfBasis._proof_3 | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {ι : Type u_2} {R : Type u_1} {M : ι → Type u_3} [inst : CommRing R] [inst_1 : (i : ι) → AddCommGroup (M i)]
[inst_2 : (i : ι) → Module R (M i)], SMulCommClass R ℕ (PiTensorProduct R fun i => Module.Dual R (M i)) | false |
CategoryTheory.Mat.equivalenceSingleObjInverse._proof_1 | Mathlib.CategoryTheory.Preadditive.Mat | ∀ (R : Type) [inst : Ring R] (X : CategoryTheory.Mat_ (CategoryTheory.SingleObj Rᵐᵒᵖ)),
(fun i j => MulOpposite.unop (CategoryTheory.CategoryStruct.id X i j)) =
CategoryTheory.CategoryStruct.id (FintypeCat.of X.ι) | false |
Std.DTreeMap.Internal.RocSlice | Std.Data.DTreeMap.Internal.Zipper | (α : Type u_1) → (α → Type u_2) → [Ord α] → Type (max u_2 u_1) | true |
_private.Lean.Meta.Tactic.TryThis.0.Lean.Meta.Tactic.TryThis.tryThisProvider | Lean.Meta.Tactic.TryThis | Lean.Server.CodeActionProvider | true |
Lean.Linter.UnusedVariables.References.recOn | Lean.Linter.UnusedVariables | {motive : Lean.Linter.UnusedVariables.References → Sort u} →
(t : Lean.Linter.UnusedVariables.References) →
((constDecls : Std.HashSet Lean.Syntax.Range) →
(fvarDefs : Std.HashMap Lean.Syntax.Range Lean.Linter.UnusedVariables.FVarDefinition) →
(fvarUses : Std.HashSet Lean.FVarId) →
(fvarAliases : Std.HashMap Lean.FVarId Lean.FVarId) →
(assignments : Array (Lean.PersistentHashMap Lean.MVarId Lean.Expr)) →
motive
{ constDecls := constDecls, fvarDefs := fvarDefs, fvarUses := fvarUses, fvarAliases := fvarAliases,
assignments := assignments }) →
motive t | false |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.collectStructFields._unsafe_rec | Lean.PrettyPrinter.Delaborator.Builtins | Lean.Name →
List Lean.Level →
Array Lean.Expr →
Array (Lean.TSyntax `Lean.Parser.Term.structInstField) →
Lean.NameMap Lean.Expr →
Lean.ConstructorVal →
Lean.PrettyPrinter.Delaborator.DelabM
(Lean.NameMap Lean.Expr × Array (Lean.TSyntax `Lean.Parser.Term.structInstField)) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.