name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyze.analyzeLet | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.AnalyzeM Unit | true |
_private.Mathlib.Analysis.Normed.Algebra.GelfandMazur.0.NormedAlgebra.Complex.norm_sub_eq_norm_sub_of_isMinOn._simp_1_1 | Mathlib.Analysis.Normed.Algebra.GelfandMazur | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (n : ℕ), a * a ^ n = a ^ (n + 1) | false |
CategoryTheory.GrothendieckTopology.W.isLocallySurjective | Mathlib.CategoryTheory.Sites.LocallyBijective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u'}
[inst_1 : CategoryTheory.Category.{v', u'} A] {FA : A → A → Type u_1} {CA : A → Type w'}
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)] [inst_3 : CategoryTheory.ConcreteCategory A FA]
[J.WEqualsLocallyBijective A] {X Y : CategoryTheory.Functor Cᵒᵖ A} {f : X ⟶ Y},
J.W f → CategoryTheory.Presheaf.IsLocallySurjective J f | true |
CategoryTheory.ShiftedHom.map_smul | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {M : Type u_4} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : CategoryTheory.HasShift D M] {X Y : C} {R : Type u_5}
[inst_5 : Ring R] [inst_6 : CategoryTheory.Preadditive C] [inst_7 : CategoryTheory.Linear R C]
[inst_8 : CategoryTheory.Preadditive D] [inst_9 : CategoryTheory.Linear R D] (r : R) {a : M}
(α : CategoryTheory.ShiftedHom X Y a) (F : CategoryTheory.Functor C D) [inst_10 : F.CommShift M]
[CategoryTheory.Functor.Linear R F], (r • α).map F = r • α.map F | true |
Module.End.instDivisionRing._proof_2 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Module.End R M)] [inst_4 : IsSimpleModule R M] (a : Module.End R M), zpowRec npowRec 0 a = 1 | false |
Lean.Grind.CommRing.Mon.denote_concat | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] (ctx : Lean.Grind.CommRing.Context α) (m₁ m₂ : Lean.Grind.CommRing.Mon),
Lean.Grind.CommRing.Mon.denote ctx (m₁.concat m₂) =
Lean.Grind.CommRing.Mon.denote ctx m₁ * Lean.Grind.CommRing.Mon.denote ctx m₂ | true |
TrivialStar.isStarNormal | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Mul R] [inst_1 : StarMul R] [TrivialStar R] {x : R}, IsStarNormal x | true |
OpenNormalAddSubgroup.instInfOpenNormalAddSubgroup | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → Min (OpenNormalAddSubgroup G) | true |
linearOrderOfSTO._proof_2 | Mathlib.Order.RelClasses | ∀ {α : Type u_1} (r : α → α → Prop) [inst : IsStrictTotalOrder α r] (x y : α), x ≤ y ∨ y ≤ x | false |
CategoryTheory.Under.eqToHom_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (e : U = V),
(CategoryTheory.eqToHom e).right = CategoryTheory.eqToHom ⋯ | true |
_private.Mathlib.Geometry.Euclidean.Circumcenter.0.EuclideanGeometry.existsUnique_dist_eq_of_insert._proof_1_2 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : AffineSubspace ℝ P} [inst_4 : s.direction.HasOrthogonalProjection] {p : P}
(this : Nonempty ↥s) (cc : P) (cr : ℝ),
dist p ↑((EuclideanGeometry.orthogonalProjection s) p) ≠ 0 →
∀ (cc₃ : P) (cr₃ t₃ : ℝ),
cc₃ = t₃ • (p -ᵥ ↑((EuclideanGeometry.orthogonalProjection s) p)) +ᵥ cc →
cr₃ =
√(cr * cr +
t₃ * dist p ↑((EuclideanGeometry.orthogonalProjection s) p) *
(t₃ * dist p ↑((EuclideanGeometry.orthogonalProjection s) p))) →
dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) +
(1 - t₃) * (1 - t₃) *
(dist p ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist p ↑((EuclideanGeometry.orthogonalProjection s) p)) =
cr * cr +
t₃ * dist p ↑((EuclideanGeometry.orthogonalProjection s) p) *
(t₃ * dist p ↑((EuclideanGeometry.orthogonalProjection s) p)) →
{ center := cc₃, radius := cr₃ } =
{
center :=
((dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) +
dist p ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist p ↑((EuclideanGeometry.orthogonalProjection s) p) -
cr * cr) /
(2 * dist p ↑((EuclideanGeometry.orthogonalProjection s) p)) /
dist p ↑((EuclideanGeometry.orthogonalProjection s) p)) •
(p -ᵥ ↑((EuclideanGeometry.orthogonalProjection s) p)) +ᵥ
cc,
radius :=
√(cr * cr +
(dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) +
dist p ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist p ↑((EuclideanGeometry.orthogonalProjection s) p) -
cr * cr) /
(2 * dist p ↑((EuclideanGeometry.orthogonalProjection s) p)) *
((dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist cc ↑((EuclideanGeometry.orthogonalProjection s) p) +
dist p ↑((EuclideanGeometry.orthogonalProjection s) p) *
dist p ↑((EuclideanGeometry.orthogonalProjection s) p) -
cr * cr) /
(2 * dist p ↑((EuclideanGeometry.orthogonalProjection s) p)))) } | false |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.ExpandedFields | Lean.Elab.StructInst | Type | true |
associatedPrimes | Mathlib.RingTheory.Ideal.AssociatedPrime.Basic | (R : Type u_1) → [inst : CommSemiring R] → (M : Type u_2) → [inst_1 : AddCommMonoid M] → [Module R M] → Set (Ideal R) | true |
preNormEDS'.eq_4 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), preNormEDS' b c d 3 = c | true |
Std.ExtDHashMap.isSome_getKey?_iff_mem._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a : α}, ((m.getKey? a).isSome = true) = (a ∈ m) | false |
_private.Mathlib.Data.List.AList.0.AList.union_assoc._simp_1_1 | Mathlib.Data.List.AList | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | false |
LinearOrderedCommGroup.closure_equiv_closure._simp_5 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
CategoryTheory.Limits.IndObjectPresentation.yoneda_I | Mathlib.CategoryTheory.Limits.Indization.IndObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C),
(CategoryTheory.Limits.IndObjectPresentation.yoneda X).I = CategoryTheory.Discrete PUnit.{v + 1} | true |
DirectLimit.Ring.of._proof_2 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_2}
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] [inst_2 : (i : ι) → NonAssocSemiring (G i)]
[∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)] (i j : ι) (h : i ≤ j), MulHomClass (T h) (G i) (G j) | false |
Seminorm.ext | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E]
{p q : Seminorm 𝕜 E}, (∀ (x : E), p x = q x) → p = q | true |
CategoryTheory.Presieve.Arrows.pullbackCompatible_iff | 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} (π : (i : I) → X i ⟶ B)
[inst_1 : (CategoryTheory.Presieve.ofArrows X π).HasPairwisePullbacks] (x : (i : I) → P.obj (Opposite.op (X i))),
CategoryTheory.Presieve.Arrows.Compatible P π x ↔ CategoryTheory.Presieve.Arrows.PullbackCompatible P π x | true |
Algebra.PreSubmersivePresentation.isUnit_jacobian_iff_aevalDifferential_bijective | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(P : Algebra.PreSubmersivePresentation R S ι σ) [inst_3 : Finite σ],
IsUnit P.jacobian ↔ Function.Bijective ⇑P.aevalDifferential | true |
BialgEquiv.noConfusion | Mathlib.RingTheory.Bialgebra.Equiv | {P : Sort u_1} →
{R : Type u} →
{inst : CommSemiring R} →
{A : Type v} →
{B : Type w} →
{inst_1 : Semiring A} →
{inst_2 : Semiring B} →
{inst_3 : Algebra R A} →
{inst_4 : Algebra R B} →
{inst_5 : CoalgebraStruct R A} →
{inst_6 : CoalgebraStruct R B} →
{t : A ≃ₐc[R] B} →
{R' : Type u} →
{inst' : CommSemiring R'} →
{A' : Type v} →
{B' : Type w} →
{inst'_1 : Semiring A'} →
{inst'_2 : Semiring B'} →
{inst'_3 : Algebra R' A'} →
{inst'_4 : Algebra R' B'} →
{inst'_5 : CoalgebraStruct R' A'} →
{inst'_6 : CoalgebraStruct R' B'} →
{t' : A' ≃ₐc[R'] B'} →
R = R' →
inst ≍ inst' →
A = A' →
B = B' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
inst_3 ≍ inst'_3 →
inst_4 ≍ inst'_4 →
inst_5 ≍ inst'_5 →
inst_6 ≍ inst'_6 →
t ≍ t' → BialgEquiv.noConfusionType P t t' | false |
CategoryTheory.Subobject.le_of_comm | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B : C} {X Y : CategoryTheory.Subobject B}
(f : CategoryTheory.Subobject.underlying.obj X ⟶ CategoryTheory.Subobject.underlying.obj Y),
CategoryTheory.CategoryStruct.comp f Y.arrow = X.arrow → X ≤ Y | true |
ZFSet.coeEquiv | Mathlib.SetTheory.ZFC.Class | ZFSet.{u} ≃ { s // Small.{u, u + 1} ↑s } | true |
CategoryTheory.Mon.EquivLaxMonoidalFunctorPUnit.monToLaxMonoidal_laxMonoidalToMon_obj_mul | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(F : CategoryTheory.Mon C),
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.mul (CategoryTheory.CategoryStruct.id F.X) | true |
MulAction.selfEquivSigmaOrbitsQuotientStabilizer'.eq_1 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ (α : Type u) (β : Type v) [inst : Group α] [inst_1 : MulAction α β] {φ : Quotient (MulAction.orbitRel α β) → β}
(hφ : Function.LeftInverse Quotient.mk'' φ),
MulAction.selfEquivSigmaOrbitsQuotientStabilizer' α β hφ =
Trans.trans (MulAction.selfEquivSigmaOrbits' α β)
(Equiv.sigmaCongrRight fun ω => (Equiv.setCongr ⋯).trans (MulAction.orbitEquivQuotientStabilizer α (φ ω))) | true |
Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred.recOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_2 : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof → Sort u} →
{motive_3 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_4 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred → Sort u} →
{motive_5 : Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Sort u} →
{motive_6 : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof → Sort u} →
{motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
{motive_8 : Lean.Meta.Grind.Arith.Cutsat.LeCnstr → Sort u} →
{motive_9 : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof → Sort u} →
{motive_10 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr → Sort u} →
{motive_11 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof → Sort u} →
{motive_12 : Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u} →
{motive_13 : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u} →
{motive_14 : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_15 : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u} →
{motive_16 : Array (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u} →
{motive_17 : List (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Sort u} →
{motive_18 : List (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → Sort u} →
{motive_19 : Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
{motive_20 : Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Sort u} →
{motive_21 : ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred) →
((p : Int.Linear.Poly) →
(h : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) →
motive_2 h → motive_1 { p := p, h := h }) →
((a zero : Lean.Expr) →
motive_2 (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core0 a zero)) →
((a b : Lean.Expr) →
(p₁ p₂ : Int.Linear.Poly) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.core a b p₁ p₂)) →
((a b toIntThm : Lean.Expr) →
(lhs rhs : Int.Linear.Expr) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.coreToInt a b
toIntThm lhs rhs)) →
((e : Lean.Expr) →
(p : Int.Linear.Poly) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defn e p)) →
((h : Lean.Expr) →
(x : Int.Linear.Var) →
(e' : Int.Linear.Expr) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNat h x
e')) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.norm c)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.divCoeffs
c)) →
((x : Int.Linear.Var) →
(c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c₁ →
motive_1 c₂ →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.subst
x c₁ c₂)) →
((c₁ c₂ : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
motive_8 c₁ →
motive_8 c₂ →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.ofLeGe
c₁ c₂)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.reorder
c)) →
((c : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
(e : Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(p : Lean.Grind.CommRing.Poly) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.commRingNorm
c e p)) →
((e : Lean.Expr) →
(p : Int.Linear.Poly) →
(re :
Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(rp : Lean.Grind.CommRing.Poly) →
(p' : Int.Linear.Poly) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnCommRing
e p re rp p')) →
((h : Lean.Expr) →
(x : Int.Linear.Var) →
(e' : Int.Linear.Expr) →
(p : Int.Linear.Poly) →
(re :
Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(rp : Lean.Grind.CommRing.Poly) →
(p' : Int.Linear.Poly) →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNatCommRing
h x e' p re rp p')) →
((a? : Option Lean.Expr) →
(cs :
Array
(Lean.Expr ×
ℤ ×
Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
motive_13 cs →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mul
a? cs)) →
((k : ℤ) →
(y? : Option Int.Linear.Var) →
(c :
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.div
k y? c)) →
((k : ℤ) →
(y? : Option Int.Linear.Var) →
(c :
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_1 c →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.mod
k y? c)) →
((ka : ℤ) →
(ca? :
Option
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
(kb : ℕ) →
(cb? :
Option
Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
motive_14 ca? →
motive_14 cb? →
motive_2
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.pow
ka ca? kb cb?)) →
((d : ℤ) →
(p : Int.Linear.Poly) →
(h :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
motive_7 h →
motive_3
{ d := d, p := p,
h := h }) →
((left : Bool) →
(c₁ c₂ :
Lean.Meta.Grind.Arith.Cutsat.LeCnstr) →
(c₃? :
Option
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_8 c₁ →
motive_8 c₂ →
motive_15 c₃? →
motive_4
{ left := left,
c₁ := c₁, c₂ := c₂,
c₃? := c₃? }) →
((pred :
Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred) →
(k : ℕ) →
(h :
Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof) →
motive_4 pred →
motive_6 h →
motive_5
{ pred := pred,
k := k, h := h }) →
((h : Lean.FVarId) →
motive_6
(Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof.dec
h)) →
((hs :
Array
(Lean.FVarId ×
Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
(decVars :
Array Lean.FVarId) →
motive_16 hs →
motive_6
(Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof.last
hs decVars)) →
((e : Lean.Expr) →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.core
e)) →
((e thm : Lean.Expr) →
(d : ℕ) →
(a :
Int.Linear.Expr) →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.coreOfNat
e thm d a)) →
((c :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.norm
c)) →
((c :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.divCoeffs
c)) →
((c₁ c₂ :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c₁ →
motive_3 c₂ →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.solveCombine
c₁ c₂)) →
((c₁ c₂ :
Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
motive_3 c₁ →
motive_3 c₂ →
motive_7
(Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.solveElim
c₁
c₂)) →
⋯ | false |
Primrec₂.unpaired' | Mathlib.Computability.Primrec.Basic | ∀ {f : ℕ → ℕ → ℕ}, Nat.Primrec (Nat.unpaired f) ↔ Primrec₂ f | true |
Lean.Elab.Term.Quotation.HeadCheck.unconditional.sizeOf_spec | Lean.Elab.Quotation | sizeOf Lean.Elab.Term.Quotation.HeadCheck.unconditional = 1 | true |
BiheytingHom.noConfusion | Mathlib.Order.Heyting.Hom | {P : Sort u} →
{α : Type u_6} →
{β : Type u_7} →
{inst : BiheytingAlgebra α} →
{inst_1 : BiheytingAlgebra β} →
{t : BiheytingHom α β} →
{α' : Type u_6} →
{β' : Type u_7} →
{inst' : BiheytingAlgebra α'} →
{inst'_1 : BiheytingAlgebra β'} →
{t' : BiheytingHom α' β'} →
α = α' → β = β' → inst ≍ inst' → inst_1 ≍ inst'_1 → t ≍ t' → BiheytingHom.noConfusionType P t t' | false |
ConvexOn.hasDerivWithinAt_rightDeriv_of_mem_interior | Mathlib.Analysis.Convex.Deriv | ∀ {S : Set ℝ} {f : ℝ → ℝ} {x : ℝ},
ConvexOn ℝ S f → x ∈ interior S → HasDerivWithinAt f (derivWithin f (Set.Ioi x) x) (Set.Ioi x) x | true |
Int16.reduceNe._regBuiltin.Int16.reduceNe.declare_2._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.780327193._hygCtx._hyg.3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
Lean.Grind.CommRing.Expr.add.elim | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} →
(t : Lean.Grind.CommRing.Expr) → t.ctorIdx = 5 → ((a b : Lean.Grind.CommRing.Expr) → motive (a.add b)) → motive t | false |
_private.Mathlib.Topology.Order.Monotone.0.MonotoneOn.tendsto_nhdsWithin_Ioo_left._simp_1_1 | Mathlib.Topology.Order.Monotone | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
_private.Init.Data.BitVec.Bootstrap.0.BitVec.getElem_cons._proof_1_1 | Init.Data.BitVec.Bootstrap | ∀ {n i : ℕ}, i < n → n ≤ i → False | false |
_private.Mathlib.Util.TermReduce.0.Mathlib.Util.TermReduce.elabDelta.match_1 | Mathlib.Util.TermReduce | (motive : Option Lean.Expr → Sort u_1) →
(__discr : Option Lean.Expr) →
((t : Lean.Expr) → motive (some t)) → ((x : Option Lean.Expr) → motive x) → motive __discr | false |
_private.Lean.Data.Json.Basic.0.Lean.instHashableJsonNumber.hash.match_1 | Lean.Data.Json.Basic | (motive : Lean.JsonNumber → Sort u_1) →
(x : Lean.JsonNumber) → ((a : ℤ) → (a_1 : ℕ) → motive { mantissa := a, exponent := a_1 }) → motive x | false |
MeasureTheory.Content.rec | Mathlib.MeasureTheory.Measure.Content | {G : Type w} →
[inst : TopologicalSpace G] →
{motive : MeasureTheory.Content G → Sort u} →
((toFun : TopologicalSpace.Compacts G → NNReal) →
(mono' : ∀ (K₁ K₂ : TopologicalSpace.Compacts G), ↑K₁ ⊆ ↑K₂ → toFun K₁ ≤ toFun K₂) →
(sup_disjoint' :
∀ (K₁ K₂ : TopologicalSpace.Compacts G),
Disjoint ↑K₁ ↑K₂ → IsClosed ↑K₁ → IsClosed ↑K₂ → toFun (K₁ ⊔ K₂) = toFun K₁ + toFun K₂) →
(sup_le' : ∀ (K₁ K₂ : TopologicalSpace.Compacts G), toFun (K₁ ⊔ K₂) ≤ toFun K₁ + toFun K₂) →
motive { toFun := toFun, mono' := mono', sup_disjoint' := sup_disjoint', sup_le' := sup_le' }) →
(t : MeasureTheory.Content G) → motive t | false |
_private.Lean.Meta.ExprLens.0.Lean.Meta.lensCoord._sparseCasesOn_1 | Lean.Meta.ExprLens | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fn arg : Lean.Expr) → motive (fn.app arg)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((data : Lean.MData) → (expr : Lean.Expr) → motive (Lean.Expr.mdata data expr)) →
(Nat.hasNotBit 3552 t.ctorIdx → motive t) → motive t | false |
Lean.Linter.LinterOptions.rec | Lean.Linter.Basic | {motive : Lean.Linter.LinterOptions → Sort u} →
((toOptions : Lean.Options) →
(linterSets : Lean.Linter.LinterSets) → motive { toOptions := toOptions, linterSets := linterSets }) →
(t : Lean.Linter.LinterOptions) → motive t | false |
_private.Mathlib.Topology.UniformSpace.Basic.0.«term_∘₂_» | Mathlib.Topology.UniformSpace.Basic | Lean.TrailingParserDescr | true |
CategoryTheory.Limits.limit.toStructuredArrow._proof_4 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] (F : CategoryTheory.Functor J C)
[inst_2 : CategoryTheory.Limits.HasLimit F] {X Y Z : J} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.StructuredArrow.homMk (CategoryTheory.CategoryStruct.comp f g) ⋯ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.homMk f ⋯)
(CategoryTheory.StructuredArrow.homMk g ⋯) | false |
_private.Init.Data.Order.Lemmas.0.Std.lt_of_le_of_ne._simp_1_2 | Init.Data.Order.Lemmas | ∀ {a : Prop}, (a → False) = ¬a | false |
unary_relation_sInf_iff | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_8} (s : Set (α → Prop)) {a : α}, sInf s a ↔ ∀ r ∈ s, r a | true |
ContinuousENorm.rec | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} →
[inst : TopologicalSpace E] →
{motive : ContinuousENorm E → Sort u} →
([toENorm : ENorm E] →
(continuous_enorm : Continuous enorm) → motive { toENorm := toENorm, continuous_enorm := continuous_enorm }) →
(t : ContinuousENorm E) → motive t | false |
Std.Time.DateTime.toPlainDate | Std.Time.Zoned | {tz : Std.Time.TimeZone} → Std.Time.DateTime tz → Std.Time.PlainDate | true |
Lean.Parser.Term.binrel._regBuiltin.Lean.Parser.Term.binrel.formatter_9 | Lean.Parser.Term | IO Unit | false |
Submodule.reflection_orthogonal | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection],
Kᗮ.reflection = K.reflection.trans (LinearIsometryEquiv.neg 𝕜) | true |
ContinuousLinearMap.analyticOn_uncurry_of_multilinear | Mathlib.Analysis.Analytic.CPolynomial | ∀ {𝕜 : Type u_1} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {ι : Type u_5}
{Em : ι → Type u_6} [inst_5 : (i : ι) → NormedAddCommGroup (Em i)] [inst_6 : (i : ι) → NormedSpace 𝕜 (Em i)]
[inst_7 : Fintype ι] (f : G →L[𝕜] ContinuousMultilinearMap 𝕜 Em F) {s : Set (G × ((i : ι) → Em i))},
AnalyticOn 𝕜 (fun p => (f p.1) p.2) s | true |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.RedRed.of_false.match_1_3 | Batteries.Data.RBMap.WF | ∀ {p : Prop} {α : Type u_1} {n : ℕ} (motive : (t : Batteries.RBNode α) → Batteries.RBNode.RedRed p t n → Prop)
(t : Batteries.RBNode α) (x : Batteries.RBNode.RedRed p t n),
(∀ (t : Batteries.RBNode α) (c : Batteries.RBColor) (h : t.Balanced c n), motive t ⋯) →
(∀ (a : Batteries.RBNode α) (c₁ : Batteries.RBColor) (b : Batteries.RBNode α) (c₂ : Batteries.RBColor) (x : α)
(hp : p) (a_1 : a.Balanced c₁ n) (a_2 : b.Balanced c₂ n),
motive (Batteries.RBNode.node Batteries.RBColor.red a x b) ⋯) →
motive t x | false |
Real.HolderTriple.of_pos | Mathlib.Data.Real.ConjExponents | ∀ {p q : ℝ}, 0 < p → 0 < q → p.HolderTriple q (p⁻¹ + q⁻¹)⁻¹ | true |
CategoryTheory.Bicategory.Adj.lIso._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {adj₁ adj₂ : a ⟶ b}
(e : adj₁ ≅ adj₂), CategoryTheory.CategoryStruct.comp e.hom.τl e.inv.τl = CategoryTheory.CategoryStruct.id adj₁.l | false |
List.rtakeWhile_idempotent | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.rtakeWhile p (List.rtakeWhile p l) = List.rtakeWhile p l | true |
PowerBasis.ofAdjoinEqTop_dim | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {K : Type u_1} {S : Type u_2} [inst : Field K] [inst_1 : CommRing S] [inst_2 : Algebra K S] {x : S}
(hx : IsIntegral K x) (hx' : Algebra.adjoin K {x} = ⊤),
(PowerBasis.ofAdjoinEqTop hx hx').dim = (minpoly K x).natDegree | true |
Nat.modCore_eq | Init.Data.Nat.Div.Basic | ∀ (x y : ℕ), x.modCore y = if 0 < y ∧ y ≤ x then (x - y).modCore y else x | true |
Vector.getElem_set | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ} {x : α} (hi : i < n) {j : ℕ} (hj : j < n),
(xs.set i x hi)[j] = if i = j then x else xs[j] | true |
Ordinal.bsup'_eq_iSup | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_4} (r : ι → ι → Prop) [inst : IsWellOrder ι r] (f : ι → Ordinal.{max u_4 u_5}),
(Ordinal.type r).bsup (Ordinal.bfamilyOfFamily' r f) = iSup f | true |
CategoryTheory.IsCardinalFiltered.mk | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {κ : Cardinal.{w}} [inst_1 : Fact κ.IsRegular],
(∀ {A : Type w} [inst_2 : CategoryTheory.SmallCategory A] (F : CategoryTheory.Functor A J),
HasCardinalLT (CategoryTheory.Arrow A) κ → Nonempty (CategoryTheory.Limits.Cocone F)) →
CategoryTheory.IsCardinalFiltered J κ | true |
DifferentiableWithinAt.smul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{s : Set E} {𝕜' : Type u_5} [inst_5 : NormedRing 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : Module 𝕜' F]
[IsBoundedSMul 𝕜' F] [IsScalarTower 𝕜 𝕜' F] {c : E → 𝕜'},
DifferentiableWithinAt 𝕜 c s x → ∀ (f : F), DifferentiableWithinAt 𝕜 (fun y => c y • f) s x | true |
Equiv.injective_pointReflection_left_of_injective_two_nsmul | Mathlib.Algebra.AddTorsor.Basic | ∀ {G : Type u_3} {P : Type u_4} [inst : AddCommGroup G] [inst_1 : AddTorsor G P],
(Function.Injective fun x => 2 • x) → ∀ (y : P), Function.Injective fun x => (Equiv.pointReflection x) y | true |
_private.Init.GrindInstances.Ring.UInt.0.UInt16.intCast_ofNat._simp_1_2 | Init.GrindInstances.Ring.UInt | ∀ (a : ℕ), (a ∣ a) = True | false |
CategoryTheory.Limits.coconeOfCoconeFiberwiseColimit_pt | Mathlib.CategoryTheory.Limits.Shapes.Grothendieck | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C CategoryTheory.Cat}
{H : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} H]
{G : CategoryTheory.Functor (CategoryTheory.Grothendieck F) H}
[inst_2 :
∀ {X Y : C} (f : X ⟶ Y),
CategoryTheory.Limits.HasColimit ((F.map f).toFunctor.comp ((CategoryTheory.Grothendieck.ι F Y).comp G))]
(c : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.fiberwiseColimit G)),
(CategoryTheory.Limits.coconeOfCoconeFiberwiseColimit c).pt = c.pt | true |
Mathlib.Tactic.Find.initFn._@.Mathlib.Tactic.Find.1863381662._hygCtx._hyg.2 | Mathlib.Tactic.Find | IO (Batteries.Tactic.DeclCache (Std.HashMap Lean.HeadIndex (Array Lean.Name))) | false |
IsUpperModularLattice.casesOn | Mathlib.Order.ModularLattice | {α : Type u_2} →
[inst : Lattice α] →
{motive : IsUpperModularLattice α → Sort u} →
(t : IsUpperModularLattice α) →
((covBy_sup_of_inf_covBy : ∀ {a b : α}, a ⊓ b ⋖ a → b ⋖ a ⊔ b) → motive ⋯) → motive t | false |
AlgHomClass.toRingHom_toAlgHom | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] {F : Type u_4} [inst_5 : FunLike F A B] [inst_6 : AlgHomClass F R A B]
(f : F), ↑↑f = ↑f | true |
Vector.flatMap.eq_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {β : Type u_2} {m : ℕ} (xs : Vector α n) (f : α → Vector β m),
xs.flatMap f = Vector.mk (Array.flatMap (fun a => (f a).toArray) xs.toArray) ⋯ | true |
Lean.Lsp.instInhabitedResolvableCompletionItem.default | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ResolvableCompletionItem | true |
MonadFinally.mk.noConfusion | Init.Control.Except | {m : Type u → Type v} →
{P : Sort u_1} →
{tryFinally' tryFinally'' : {α β : Type u} → m α → (Option α → m β) → m (α × β)} →
{ tryFinally' := tryFinally' } = { tryFinally' := tryFinally'' } → (tryFinally' ≍ tryFinally'' → P) → P | false |
Std.DTreeMap.Internal.Impl.getKey!_inter! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k : α},
(m₁.inter! m₂).getKey! k = if Std.DTreeMap.Internal.Impl.contains k m₂ = true then m₁.getKey! k else default | true |
_private.Batteries.Data.String.Lemmas.0.String.Legacy.Iterator.atEnd.eq_1 | Batteries.Data.String.Lemmas | ∀ (s : String) (i : String.Pos.Raw), { s := s, i := i }.atEnd = decide (i.byteIdx ≥ s.rawEndPos.byteIdx) | true |
Order.succ_iterate | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : AddMonoidWithOne α] [inst_2 : SuccAddOrder α] (x : α) (n : ℕ),
Order.succ^[n] x = x + ↑n | true |
instStreamRawChar | Init.Data.String.Stream | Std.Stream Substring.Raw Char | true |
ProbabilityTheory.map_eq_of_forall_ae_eq | Mathlib.Probability.Process.FiniteDimensionalLaws | ∀ {T : Type u_1} {Ω : Type u_2} {𝓧 : T → Type u_3} {mΩ : MeasurableSpace Ω} {mα : (t : T) → MeasurableSpace (𝓧 t)}
{X Y : (t : T) → Ω → 𝓧 t} {P : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure P],
AEMeasurable (fun ω x => X x ω) P →
AEMeasurable (fun ω x => Y x ω) P →
(∀ (t : T), X t =ᵐ[P] Y t) →
MeasureTheory.Measure.map (fun ω x => X x ω) P = MeasureTheory.Measure.map (fun ω x => Y x ω) P | true |
Set.fintypeLENat | Mathlib.Data.Set.Finite.Basic | (n : ℕ) → Fintype ↑{i | i ≤ n} | true |
StarAlgebra.adjoin_mono | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : StarRing A] [inst_5 : StarModule R A] {s t : Set A},
s ⊆ t → StarAlgebra.adjoin R s ≤ StarAlgebra.adjoin R t | true |
ContMDiffWithinAt.mpullback_vectorField_of_mem_nhdsWithin_of_eq | Mathlib.Geometry.Manifold.VectorField.Pullback | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {H' : Type u_5} [inst_6 : TopologicalSpace H']
{E' : Type u_6} [inst_7 : NormedAddCommGroup E'] [inst_8 : NormedSpace 𝕜 E'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {f : M → M'} {s : Set M} {x₀ : M}
{V : (x : M') → TangentSpace I' x} {m n : WithTop ℕ∞} {t : Set M'} {y₀ : M'} [CompleteSpace E]
[inst_12 : IsManifold I 1 M] [inst_13 : IsManifold I' 1 M'],
ContMDiffWithinAt I' (I'.prod (modelWithCornersSelf 𝕜 E')) m (fun x => ⟨x, V x⟩) t y₀ →
ContMDiffAt I I' n f x₀ →
(mfderiv% f x₀).IsInvertible →
m + 1 ≤ n →
f ⁻¹' t ∈ nhdsWithin x₀ s →
y₀ = f x₀ →
ContMDiffWithinAt I (I.prod (modelWithCornersSelf 𝕜 E)) m (fun x => ⟨x, VectorField.mpullback I I' f V x⟩)
s x₀ | true |
Lean.Lsp.TextDocumentIdentifier._sizeOf_1 | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentIdentifier → ℕ | false |
normalizedFactorsEquivOfQuotEquiv._proof_12 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_2} {A : Type u_1} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : IsDedekindDomain A] {I : Ideal R}
{J : Ideal A} [inst_3 : IsDedekindDomain R] (f : R ⧸ I ≃+* A ⧸ J) (hI : I ≠ ⊥) (hJ : J ≠ ⊥)
(x : ↑{M | M ∈ UniqueFactorizationMonoid.normalizedFactors J}),
⟨↑((idealFactorsEquivOfQuotEquiv f) ⟨↑⟨↑((idealFactorsEquivOfQuotEquiv f).symm ⟨↑x, ⋯⟩), ⋯⟩, ⋯⟩), ⋯⟩ = x | false |
FinVec.Forall._sunfold | Mathlib.Data.Fin.Tuple.Reflection | {α : Type u_1} → {m : ℕ} → ((Fin m → α) → Prop) → Prop | false |
Vector._sizeOf_1 | Init.Data.Vector.Basic | {α : Type u} → {n : ℕ} → [SizeOf α] → Vector α n → ℕ | false |
MeasureTheory.NullMeasurableSet.fundamentalInterior | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] (s : Set α) [Countable G]
[inst_3 : MeasurableSpace α] [MeasurableConstSMul G α] {μ : MeasureTheory.Measure α}
[MeasureTheory.SMulInvariantMeasure G α μ],
MeasureTheory.NullMeasurableSet s μ → MeasureTheory.NullMeasurableSet (MeasureTheory.fundamentalInterior G s) μ | true |
Lean.Meta.Grind.AC.State.mk.inj | Lean.Meta.Tactic.Grind.AC.Types | ∀ {structs : Array Lean.Meta.Grind.AC.Struct} {opIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)}
{exprToOpIds : Lean.PHashMap Lean.Meta.Sym.ExprPtr (List ℕ)} {steps : ℕ} {structs_1 : Array Lean.Meta.Grind.AC.Struct}
{opIdOf_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ)}
{exprToOpIds_1 : Lean.PHashMap Lean.Meta.Sym.ExprPtr (List ℕ)} {steps_1 : ℕ},
{ structs := structs, opIdOf := opIdOf, exprToOpIds := exprToOpIds, steps := steps } =
{ structs := structs_1, opIdOf := opIdOf_1, exprToOpIds := exprToOpIds_1, steps := steps_1 } →
structs = structs_1 ∧ opIdOf = opIdOf_1 ∧ exprToOpIds = exprToOpIds_1 ∧ steps = steps_1 | true |
mulMonoidWithZeroHom_apply | Mathlib.Algebra.GroupWithZero.Prod | ∀ {M₀ : Type u_1} [inst : CommMonoidWithZero M₀] (a : M₀ × M₀), mulMonoidWithZeroHom a = (↑mulMonoidHom).toFun a | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.PosLog.0.Real.posLog_sum._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Log.PosLog | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, 0 ≤ f i) → (0 ≤ ∑ i ∈ s, f i) = True | false |
HomologicalComplex.evalCompCoyonedaCorepresentableBySingle._proof_2 | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {ι : Type u_1} (c : ComplexShape ι) (i : ι) [inst_3 : DecidableEq ι]
(hi : ∀ (j : ι), ¬c.Rel i j) (X : C) {K : HomologicalComplex C c} (g : (HomologicalComplex.single C c i).obj X ⟶ K),
(fun f => HomologicalComplex.mkHomFromSingle f ⋯)
((fun g => CategoryTheory.CategoryStruct.comp (HomologicalComplex.singleObjXSelf c i X).inv (g.f i)) g) =
g | false |
_private.Mathlib.Algebra.Homology.Embedding.Connect.0.CochainComplex.ConnectData.homologyIsoPos._proof_7 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ (n : ℕ) (m : ℤ), m = ↑n → ↑n = m | false |
LightCondensed.instMonoidalLightCondSetLightCondModFree._aux_12 | Mathlib.Condensed.Light.Monoidal | (R : Type u_1) →
[inst : CommRing R] →
(X Y : LightCondSet) →
(LightCondensed.free R).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) ⟶
CategoryTheory.MonoidalCategoryStruct.tensorObj ((LightCondensed.free R).obj X) ((LightCondensed.free R).obj Y) | false |
CFC.negPart_eq_zero_of_not_isSelfAdjoint | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | ∀ {A : Type u_1} [inst : NonUnitalRing A] [inst_1 : Module ℝ A] [inst_2 : SMulCommClass ℝ A A]
[inst_3 : IsScalarTower ℝ A A] [inst_4 : StarRing A] [inst_5 : TopologicalSpace A]
[inst_6 : NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] {a : A}, ¬IsSelfAdjoint a → a⁻ = 0 | true |
PowerSeries.X_pow_mul_injective | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] {k : ℕ}, Function.Injective fun x => PowerSeries.X ^ k * x | true |
CompleteSublattice.instCompleteLattice._proof_3 | Mathlib.Order.CompleteSublattice | ∀ {α : Type u_1} [inst : CompleteLattice α] {L : CompleteSublattice α} {x y : ↥L}, ↑x < ↑y ↔ ↑x < ↑y | false |
Set.MapsTo.coe_restrict | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β} (h : Set.MapsTo f s t),
Subtype.val ∘ Set.MapsTo.restrict f s t h = s.restrict f | true |
Std.Sat.AIG | Std.Sat.AIG.Basic | (α : Type) → [DecidableEq α] → [Hashable α] → Type | true |
instCartesianMonoidalCategoryLightCondSet._proof_19 | Mathlib.Condensed.Light.CartesianClosed | autoParam
(∀ {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : LightCondSet} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f₁ f₂)
(CategoryTheory.MonoidalCategoryStruct.tensorHom g₁ g₂) =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.comp f₁ g₁)
(CategoryTheory.CategoryStruct.comp f₂ g₂))
CategoryTheory.MonoidalCategory.tensorHom_comp_tensorHom._autoParam | false |
Valuation.instLinearOrderedCommGroupWithZeroMrange | Mathlib.RingTheory.Valuation.Archimedean | {F : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Field F] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation F Γ₀} → LinearOrderedCommGroupWithZero ↥(MonoidHom.mrange v) | true |
Vector.toList_drop | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ}, (xs.drop i).toList = List.drop i xs.toList | true |
EsakiaHomClass | Mathlib.Topology.Order.Hom.Esakia | (F : Type u_6) →
(α : outParam (Type u_7)) →
(β : outParam (Type u_8)) →
[TopologicalSpace α] → [Preorder α] → [TopologicalSpace β] → [Preorder β] → [FunLike F α β] → Prop | true |
Function.Fiber.mk._proof_1 | Mathlib.Logic.Function.FiberPartition | ∀ {Y : Type u_1} {Z : Type u_2} (f : Y → Z) (y : Y), f ⁻¹' {f y} ∈ Set.range fun x => f ⁻¹' {↑x} | false |
CategoryTheory.Abelian.LeftResolution.chainComplex._proof_2 | Mathlib.Algebra.Homology.LeftResolution.Basic | ∀ {A : Type u_2} {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] {ι : CategoryTheory.Functor C A}
(Λ : CategoryTheory.Abelian.LeftResolution ι) (X : A) [inst_2 : CategoryTheory.Abelian A],
CategoryTheory.Limits.HasKernel (Λ.π.app X) | false |
Mathlib.Tactic.Translate.Reorder.brecOn_1.eq | Mathlib.Tactic.Translate.Reorder | ∀ {motive_1 : Mathlib.Tactic.Translate.Reorder → Sort u}
{motive_2 : Array (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u}
{motive_3 : List (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u}
{motive_4 : ℕ × Mathlib.Tactic.Translate.Reorder → Sort u} (t : Array (ℕ × Mathlib.Tactic.Translate.Reorder))
(F_1 : (t : Mathlib.Tactic.Translate.Reorder) → t.below → motive_1 t)
(F_2 : (t : Array (ℕ × Mathlib.Tactic.Translate.Reorder)) → Mathlib.Tactic.Translate.Reorder.below_1 t → motive_2 t)
(F_3 : (t : List (ℕ × Mathlib.Tactic.Translate.Reorder)) → Mathlib.Tactic.Translate.Reorder.below_2 t → motive_3 t)
(F_4 : (t : ℕ × Mathlib.Tactic.Translate.Reorder) → Mathlib.Tactic.Translate.Reorder.below_3 t → motive_4 t),
Mathlib.Tactic.Translate.Reorder.brecOn_1 t F_1 F_2 F_3 F_4 =
F_2 t (Mathlib.Tactic.Translate.Reorder.brecOn_1.go t F_1 F_2 F_3 F_4).2 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.