name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
spectralNorm.normedField._proof_7 | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ (K : Type u_1) [inst : NontriviallyNormedField K] (L : Type u_2) [inst_1 : Field L] [inst_2 : Algebra K L]
[Algebra.IsAlgebraic K L] [hu : IsUltrametricDist K] (x y : L), spectralNorm K L (x - y) = spectralNorm K L (-x + y) |
FourierModule.ctorIdx | Mathlib.Analysis.Fourier.Notation | {R : Type u_5} →
{E : Type u_6} →
{F : outParam (Type u_7)} →
{inst : Add E} → {inst_1 : Add F} → {inst_2 : SMul R E} → {inst_3 : SMul R F} → FourierModule R E F → ℕ |
CategoryTheory.Projective.zero_projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C],
CategoryTheory.Projective 0 |
Int.instLinearOrder | Mathlib.Data.Int.Order.Basic | LinearOrder ℤ |
CochainComplex.ofHom | Mathlib.Algebra.Homology.HomologicalComplex | {V : Type u} →
[inst : CategoryTheory.Category.{v, u} V] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] →
{α : Type u_2} →
[inst_2 : AddRightCancelSemigroup α] →
[inst_3 : One α] →
[inst_4 : DecidableEq α] →
(X : α → V) →
(d_X : (n : α) → X n ⟶ X (n + 1)) →
(sq_X : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_X n) (d_X (n + 1)) = 0) →
(Y : α → V) →
(d_Y : (n : α) → Y n ⟶ Y (n + 1)) →
(sq_Y : ∀ (n : α), CategoryTheory.CategoryStruct.comp (d_Y n) (d_Y (n + 1)) = 0) →
(f : (i : α) → X i ⟶ Y i) →
(∀ (i : α),
CategoryTheory.CategoryStruct.comp (f i) (d_Y i) =
CategoryTheory.CategoryStruct.comp (d_X i) (f (i + 1))) →
(CochainComplex.of X d_X sq_X ⟶ CochainComplex.of Y d_Y sq_Y) |
AlgebraicTopology.DoldKan.Γ₀.Obj.summand._proof_1 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | IsRightCancelAdd ℕ |
_private.Init.Data.Nat.Lemmas.0.Nat.sub_min_sub_right.match_1_1 | Init.Data.Nat.Lemmas | ∀ (motive : ℕ → ℕ → ℕ → Prop) (x x_1 x_2 : ℕ),
(∀ (x x_3 : ℕ), motive x x_3 0) → (∀ (x x_3 n : ℕ), motive x x_3 n.succ) → motive x x_1 x_2 |
instReprId | Init.Data.Repr | {α : Type u_1} → [Repr α] → Repr (id α) |
MeasureTheory.Measure.rnDeriv_smul_right_of_ne_top' | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (ν μ : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite ν]
[MeasureTheory.SigmaFinite μ] {r : ENNReal}, r ≠ 0 → r ≠ ⊤ → ν.rnDeriv (r • μ) =ᵐ[μ] r⁻¹ • ν.rnDeriv μ |
SubMulAction.instBot | Mathlib.GroupTheory.GroupAction.SubMulAction | {R : Type u} → {M : Type v} → [inst : SMul R M] → Bot (SubMulAction R M) |
CategoryTheory.Limits.colimit.ι_pre_assoc | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor J C)
[inst_3 : CategoryTheory.Limits.HasColimit F] (E : CategoryTheory.Functor K J)
[inst_4 : CategoryTheory.Limits.HasColimit (E.comp F)] (k : K) {Z : C} (h : CategoryTheory.Limits.colimit F ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι (E.comp F) k)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.pre F E) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.colimit.ι F (E.obj k)) h |
Std.ExtDTreeMap.Const.ofList | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : Type v} →
List (α × β) →
(cmp : autoParam (α → α → Ordering) Std.ExtDTreeMap.Const.ofList._auto_1) → Std.ExtDTreeMap α (fun x => β) cmp |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Basic.0.SimpleGraph.edgeDisjointTriangles_iff_mem_sym2_subsingleton._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Triangle.Basic | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∀ (a : α), a = a' ∨ q a → p a) = (p a' ∧ ∀ (a : α), q a → p a) |
LightCondMod | Mathlib.Condensed.Light.Module | (R : Type u) → [Ring R] → Type (u + 1) |
derivWithin_fun_const_smul' | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {s : Set 𝕜} {𝕝 : Type u_3} [inst_3 : DivisionSemiring 𝕝] [inst_4 : Module 𝕝 F]
[SMulCommClass 𝕜 𝕝 F] [ContinuousConstSMul 𝕝 F] (c : 𝕝) (f : 𝕜 → F),
derivWithin (fun y => c • f y) s x = c • derivWithin f s x |
_private.Mathlib.Tactic.NormNum.Basic.0.Mathlib.Meta.NormNum.Result.add._proof_1 | Mathlib.Tactic.NormNum.Basic | ∀ {u : Lean.Level} {α : Q(Type u)} (inst : Q(Add «$α»)) (_rα : Q(Ring «$α»)),
«$inst» =Q Ring.toNonAssocRing.toNonUnitalNonAssocSemiring.toDistrib.toAdd |
ContinuousMap.IccExtendCM | Mathlib.Topology.ContinuousMap.Interval | {α : Type u_1} →
[inst : LinearOrder α] →
[inst_1 : TopologicalSpace α] →
[OrderTopology α] →
{a b : α} → [Fact (a ≤ b)] → {E : Type u_2} → [inst_4 : TopologicalSpace E] → C(C(↑(Set.Icc a b), E), C(α, E)) |
BialgCat.MonoidalCategory.inducingFunctorData._proof_8 | Mathlib.Algebra.Category.BialgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (x : BialgCat R),
(AlgCat.Hom.hom
((CategoryTheory.forget₂ (BialgCat R) (AlgCat R)).map
(CategoryTheory.MonoidalCategoryStruct.rightUnitor x).hom)).comp
Algebra.TensorProduct.includeLeft =
(AlgCat.Hom.hom
(((CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.forget₂ (BialgCat R) (AlgCat R)).obj x)
((CategoryTheory.forget₂ (BialgCat R) (AlgCat R)).obj
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (BialgCat R))))).symm ≪≫
CategoryTheory.MonoidalCategory.tensorIso
(CategoryTheory.Iso.refl ((CategoryTheory.forget₂ (BialgCat R) (AlgCat R)).obj x))
(CategoryTheory.Iso.refl (CategoryTheory.MonoidalCategoryStruct.tensorUnit (AlgCat R))).symm) ≪≫
CategoryTheory.MonoidalCategoryStruct.rightUnitor
((CategoryTheory.forget₂ (BialgCat R) (AlgCat R)).obj x)).hom).comp
Algebra.TensorProduct.includeLeft |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv.0.Lean.Meta.Grind.Arith.Cutsat.checkDvds.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Inv | (motive : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr → Sort u_1) →
(c? : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) →
((c : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive (some c)) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → motive x) → motive c? |
compactOperator_topologicalClosure | Mathlib.Analysis.Normed.Operator.Compact | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
{M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : SeminormedAddCommGroup M₁] [inst_3 : AddCommGroup M₂]
[inst_4 : NormedSpace 𝕜₁ M₁] [inst_5 : Module 𝕜₂ M₂] [inst_6 : UniformSpace M₂] [inst_7 : IsUniformAddGroup M₂]
[inst_8 : ContinuousConstSMul 𝕜₂ M₂] [T2Space M₂] [CompleteSpace M₂],
(compactOperator σ₁₂ M₁ M₂).topologicalClosure = compactOperator σ₁₂ M₁ M₂ |
ZFSet.«_aux_Mathlib_SetTheory_ZFC_Basic___macroRules_ZFSet_term⋂₀__1» | Mathlib.SetTheory.ZFC.Basic | Lean.Macro |
Nat.findGreatest_of_not | Mathlib.Data.Nat.Find | ∀ {P : ℕ → Prop} [inst : DecidablePred P] {n : ℕ}, ¬P (n + 1) → Nat.findGreatest P (n + 1) = Nat.findGreatest P n |
DoubleCentralizer.toProdMulOppositeHom_apply | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (a : DoubleCentralizer 𝕜 A),
DoubleCentralizer.toProdMulOppositeHom a = a.toProdMulOpposite |
Std.DTreeMap.Internal.Impl.getKey?_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKey? k = none |
_private.Mathlib.Combinatorics.SimpleGraph.Clique.0.SimpleGraph.IsClique.of_induce._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) |
Aesop.RuleTerm.noConfusion | Aesop.RuleTac.RuleTerm | {P : Sort u} → {t t' : Aesop.RuleTerm} → t = t' → Aesop.RuleTerm.noConfusionType P t t' |
_private.Mathlib.Tactic.Algebraize.0.Mathlib.Tactic.Algebraize.addProperties.match_5 | Mathlib.Tactic.Algebraize | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(__discr : Option (Lean.Expr × Lean.Expr)) →
((val tp : Lean.Expr) → motive (some (val, tp))) →
((x : Option (Lean.Expr × Lean.Expr)) → motive x) → motive __discr |
ContinuousMapZero.instR1Space | Mathlib.Topology.ContinuousMap.ContinuousMapZero | ∀ {X : Type u_1} {R : Type u_3} [inst : Zero X] [inst_1 : Zero R] [inst_2 : TopologicalSpace X]
[inst_3 : TopologicalSpace R] [R1Space R], R1Space (ContinuousMapZero X R) |
Even.natAbs | Mathlib.Algebra.Ring.Int.Parity | ∀ {n : ℤ}, Even n → Even n.natAbs |
MultilinearMap.fromDFinsuppEquiv._proof_7 | Mathlib.LinearAlgebra.Multilinear.DFinsupp | ∀ {ι : Type u_2} (κ : ι → Type u_3) (R : Type u_4) [inst : CommSemiring R] {N : Type u_1} [inst_1 : AddCommMonoid N]
[inst_2 : Module R N], LinearMap.CompatibleSMul (Π₀ (i : (i : ι) → κ i), N) N R R |
AddCommGrpCat.preadditiveCoyonedaIso._proof_1 | Mathlib.CategoryTheory.Preadditive.Yoneda.Basic | ∀ (X : AddCommGrpCatᵒᵖ) {X_1 Y : AddCommGrpCat} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.preadditiveCoyoneda.obj X).map f)
((fun Y => AddCommGrpCat.homAddEquiv.toAddCommGrpIso) Y).hom =
CategoryTheory.CategoryStruct.comp ((fun Y => AddCommGrpCat.homAddEquiv.toAddCommGrpIso) X_1).hom
((AddCommGrpCat.coyoneda.obj X).map f) |
IsStrictOrderedRing.topologicalRing | Mathlib.Topology.Algebra.Order.Field | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [inst_3 : TopologicalSpace 𝕜]
[OrderTopology 𝕜], IsTopologicalRing 𝕜 |
Set.sub_nonempty._simp_1 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Sub α] {s t : Set α}, (s - t).Nonempty = (s.Nonempty ∧ t.Nonempty) |
_private.Mathlib.RingTheory.Ideal.GoingUp.0.Ideal.comap_ne_bot_of_root_mem.match_1_1 | Mathlib.RingTheory.Ideal.GoingUp | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {f : R →+* S} {I : Ideal S} {p : Polynomial R}
(motive : (∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ Ideal.comap f I) → Prop)
(x : ∃ i, p.coeff i ≠ 0 ∧ p.coeff i ∈ Ideal.comap f I),
(∀ (w : ℕ) (hi : p.coeff w ≠ 0) (mem : p.coeff w ∈ Ideal.comap f I), motive ⋯) → motive x |
List.disjoint_cons_right._simp_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α}, l₁.Disjoint (a :: l₂) = (a ∉ l₁ ∧ l₁.Disjoint l₂) |
Equiv.divLeft._proof_2 | Mathlib.Algebra.Group.Units.Equiv | ∀ {G : Type u_1} [inst : Group G] (a b : G), (fun b => a / b) ((fun b => b⁻¹ * a) b) = b |
_private.Mathlib.LinearAlgebra.Dimension.Torsion.Basic.0.rank_quotient_eq_of_le_torsion._simp_1_6 | Mathlib.LinearAlgebra.Dimension.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} {x : M} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(p : Submodule R M), (Submodule.Quotient.mk x = 0) = (x ∈ p) |
MvPolynomial.rename_comp_toMvPolynomial | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u_1} {σ : Type u_3} {τ : Type u_4} [inst : CommSemiring R] (f : σ → τ) (a : σ),
(MvPolynomial.rename f).comp (Polynomial.toMvPolynomial a) = Polynomial.toMvPolynomial (f a) |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionOfMonoidalFunctorToEndofunctor_actionHom | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)) [inst_3 : F.Monoidal] {c c' : C} {d d' : D} (f : d ⟶ d')
(g : c ⟶ c'),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom f g =
CategoryTheory.CategoryStruct.comp ((F.map g).app d) ((F.obj c').map f) |
PEquiv.mem_ofSet_self_iff | Mathlib.Data.PEquiv | ∀ {α : Type u} {s : Set α} [inst : DecidablePred fun x => x ∈ s] {a : α}, a ∈ (PEquiv.ofSet s) a ↔ a ∈ s |
Algebra.FinitePresentation.baseChange | Mathlib.RingTheory.FiniteStability | ∀ {R : Type w₁} [inst : CommRing R] {A : Type w₂} [inst_1 : CommRing A] [inst_2 : Algebra R A] (B : Type w₃)
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.FinitePresentation R A],
Algebra.FinitePresentation B (TensorProduct R B A) |
IsUltrametricDist.nnnorm_div_eq_max_of_nnnorm_div_ne_nnnorm_div | Mathlib.Analysis.Normed.Group.Ultra | ∀ {S : Type u_1} [inst : SeminormedGroup S] [IsUltrametricDist S] (x y z : S),
‖x / y‖₊ ≠ ‖y / z‖₊ → ‖x / z‖₊ = max ‖x / y‖₊ ‖y / z‖₊ |
CommRingCat.Colimits.cocone_naturality | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat) {j j' : J}
(f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (F.map f) (CommRingCat.Colimits.coconeMorphism F j') =
CommRingCat.Colimits.coconeMorphism F j |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.instHasPullbacksOfArrowsOfHasPullback.match_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {ι : Type u_3} (Z : ι → C)
(g : (i : ι) → Z i ⟶ X) (motive : (x : C) → (x_1 : x ⟶ X) → CategoryTheory.Presieve.ofArrows Z g x_1 → Prop) (x : C)
(x_1 : x ⟶ X) (x_2 : CategoryTheory.Presieve.ofArrows Z g x_1), (∀ (i : ι), motive (Z i) (g i) ⋯) → motive x x_1 x_2 |
Sym2.fromRel_bot_iff | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} {sym : Symmetric r}, Sym2.fromRel sym = ∅ ↔ r = ⊥ |
Lean.Grind.CommRing.Poly.NonnegCoeffs.num | Init.Grind.Ring.CommSemiringAdapter | ∀ c ≥ 0, (Lean.Grind.CommRing.Poly.num c).NonnegCoeffs |
_private.Init.Data.SInt.Lemmas.0.ISize.toInt64_lt._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, (x < y) = (x.toInt < y.toInt) |
SimpleGraph.Walk.IsCycle.mapLe | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G G' : SimpleGraph V} (h : G ≤ G') {u : V} {p : G.Walk u u},
p.IsCycle → (SimpleGraph.Walk.mapLe h p).IsCycle |
Lean.Grind.CommRing.lt_mul | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.CommRing α] [inst_1 : LE α] [inst_2 : LT α] [Std.LawfulOrderLT α]
[inst_4 : Std.IsPreorder α] [Lean.Grind.OrderedRing α] (ctx : Lean.Grind.CommRing.Context α)
(p₁ : Lean.Grind.CommRing.Poly) (k : ℤ) (p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.mul_ineq_cert p₁ k p = true →
Lean.Grind.CommRing.Poly.denote ctx p₁ < 0 → Lean.Grind.CommRing.Poly.denote ctx p < 0 |
CategoryTheory.Limits.preservesLimit_subsingleton | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] (K : CategoryTheory.Functor J C)
(F : CategoryTheory.Functor C D), Subsingleton (CategoryTheory.Limits.PreservesLimit K F) |
SSet.Truncated.Edge.CompStruct.d₀._autoParam | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | Lean.Syntax |
Metric.preimage_vadd_closedBall | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} {X : Type w} [inst : PseudoMetricSpace X] [inst_1 : AddGroup G] [inst_2 : AddAction G X]
[IsIsometricVAdd G X] (c : G) (x : X) (r : ℝ),
(fun x => c +ᵥ x) ⁻¹' Metric.closedBall x r = Metric.closedBall (-c +ᵥ x) r |
Lean.Meta.RefinedDiscrTree.ExprInfo.noConfusionType | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Sort u → Lean.Meta.RefinedDiscrTree.ExprInfo → Lean.Meta.RefinedDiscrTree.ExprInfo → Sort u |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.uniformity_eq_comap_nhds_zero._simp_1_1 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s : Set (α × α)},
(s ∈ uniformity α) = ∃ ε > 0, ∀ ⦃a b : α⦄, dist a b < ε → (a, b) ∈ s |
CategoryTheory.instFinallySmallOfHasTerminal | Mathlib.CategoryTheory.Limits.FinallySmall | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] [CategoryTheory.Limits.HasTerminal J],
CategoryTheory.FinallySmall J |
Std.DTreeMap.Internal.Impl.maxKeyD.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → α → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(x_1 : α) →
((fallback : α) → motive Std.DTreeMap.Internal.Impl.leaf fallback) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.Internal.Impl α β) →
(x : α) →
motive (Std.DTreeMap.Internal.Impl.inner size k v l Std.DTreeMap.Internal.Impl.leaf) x) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l r : Std.DTreeMap.Internal.Impl α β) →
(size_1 : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(h : r = Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r_1) →
(fallback : α) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v l
(namedPattern r (Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l_1 r_1) h))
fallback) →
motive x x_1 |
Path.Homotopic.pi_lift | Mathlib.Topology.Homotopy.Product | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {as bs : (i : ι) → X i}
(γ : (i : ι) → Path (as i) (bs i)),
(Path.Homotopic.pi fun i => Path.Homotopic.Quotient.mk (γ i)) = Path.Homotopic.Quotient.mk (Path.pi γ) |
Complex.cosh_two_mul | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℂ), Complex.cosh (2 * x) = Complex.cosh x ^ 2 + Complex.sinh x ^ 2 |
CategoryTheory.Functor.CoreMonoidal.mk'._auto_3 | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax |
instFiniteProp | Mathlib.Data.Fintype.EquivFin | ∀ (p : Prop), Finite p |
Primcodable.ulower | Mathlib.Computability.Primrec.Basic | {α : Type u_1} → [inst : Primcodable α] → Primcodable (ULower α) |
Std.IterM.toList_filter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {β : Type w} [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Bool} {it : Std.IterM m β},
(Std.IterM.filter f it).toList = List.filter f <$> it.toList |
Aesop.CasesTarget.ctorIdx | Aesop.RuleTac.Basic | Aesop.CasesTarget → ℕ |
_private.Mathlib.Analysis.AbsoluteValue.Equivalence.0.AbsoluteValue.exists_one_lt_lt_one_pi_of_not_isEquiv.match_1_11 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_1} {S : Type u_2} [inst : Field R] [inst_1 : Field S] [inst_2 : LinearOrder S] (ι : Type u_3)
(v : ι → AbsoluteValue R S) (i j : ι)
(motive :
(∃ a,
1 < (Subtype.restrict (fun k => k = i ∨ k = j) v ⟨i, ⋯⟩) a ∧
∀ (j_1 : { k // k = i ∨ k = j }), j_1 ≠ ⟨i, ⋯⟩ → (Subtype.restrict (fun k => k = i ∨ k = j) v j_1) a < 1) →
Prop)
(x :
∃ a,
1 < (Subtype.restrict (fun k => k = i ∨ k = j) v ⟨i, ⋯⟩) a ∧
∀ (j_1 : { k // k = i ∨ k = j }), j_1 ≠ ⟨i, ⋯⟩ → (Subtype.restrict (fun k => k = i ∨ k = j) v j_1) a < 1),
(∀ (b : R)
(hb :
1 < (Subtype.restrict (fun k => k = i ∨ k = j) v ⟨i, ⋯⟩) b ∧
∀ (j_1 : { k // k = i ∨ k = j }), j_1 ≠ ⟨i, ⋯⟩ → (Subtype.restrict (fun k => k = i ∨ k = j) v j_1) b < 1),
motive ⋯) →
motive x |
Ideal.Filtration.mem_submodule._simp_1 | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R}
(F : I.Filtration M) (f : PolynomialModule R M), (f ∈ F.submodule) = ∀ (i : ℕ), f i ∈ F.N i |
PiLp.basisFun.eq_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (ι : Type u_2) [inst : Finite ι] [inst_1 : Ring 𝕜],
PiLp.basisFun p 𝕜 ι = Module.Basis.ofEquivFun (WithLp.linearEquiv p 𝕜 (ι → 𝕜)) |
Std.Iterators.Types.ArrayIterator._sizeOf_1 | Std.Data.Iterators.Producers.Monadic.Array | {α : Type w} → [SizeOf α] → Std.Iterators.Types.ArrayIterator α → ℕ |
Finset.univ_finset_eq_singleton_empty_iff._simp_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_4}, (Set.univ = {∅}) = IsEmpty α |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRatAdd_ofArray._proof_1_2 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (i : ℕ), i + 1 ≤ { toList := [] }.size → i < { toList := [] }.size |
Cardinal.blsub_lt_ord_of_isRegular | Mathlib.SetTheory.Cardinal.Regular | ∀ {o : Ordinal.{max u_1 u_2}} {f : (a : Ordinal.{max u_1 u_2}) → a < o → Ordinal.{max u_1 u_2}}
{c : Cardinal.{max u_1 u_2}},
c.IsRegular → o.card < c → (∀ (i : Ordinal.{max u_1 u_2}) (hi : i < o), f i hi < c.ord) → o.blsub f < c.ord |
CategoryTheory.DifferentialObject.Hom.recOn | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
[inst : AddMonoidWithOne S] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_3 : CategoryTheory.HasShift C S] →
{X Y : CategoryTheory.DifferentialObject S C} →
{motive : X.Hom Y → Sort u_2} →
(t : X.Hom Y) →
((f : X.obj ⟶ Y.obj) →
(comm :
CategoryTheory.CategoryStruct.comp X.d ((CategoryTheory.shiftFunctor C 1).map f) =
CategoryTheory.CategoryStruct.comp f Y.d) →
motive { f := f, comm := comm }) →
motive t |
CategoryTheory.ShortComplex.cyclesMapIso_inv | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology],
(CategoryTheory.ShortComplex.cyclesMapIso e).inv = CategoryTheory.ShortComplex.cyclesMap e.inv |
CategoryTheory.Triangulated.TStructure.eTruncLTGEIsoGELT | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] →
[inst_5 : CategoryTheory.Pretriangulated C] →
(t : CategoryTheory.Triangulated.TStructure C) →
[CategoryTheory.IsTriangulated C] →
(a b : EInt) → (t.eTruncGE.obj a).comp (t.eTruncLT.obj b) ≅ (t.eTruncLT.obj b).comp (t.eTruncGE.obj a) |
Std.DTreeMap.Internal.Impl.Const.alterₘ | Std.Data.DTreeMap.Internal.Model | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
[Std.OrientedOrd α] →
α →
(Option β → Option β) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) → t.Balanced → Std.DTreeMap.Internal.Impl α fun x => β |
groupHomology.toCycles | Mathlib.RepresentationTheory.Homological.GroupHomology.Basic | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep k G) → (i j : ℕ) → (groupHomology.inhomogeneousChains A).X i ⟶ groupHomology.cycles A j |
LSeries.eq_of_LSeries_eventually_eq | Mathlib.NumberTheory.LSeries.Injectivity | ∀ {f g : ℕ → ℂ},
LSeries.abscissaOfAbsConv f < ⊤ →
LSeries.abscissaOfAbsConv g < ⊤ →
((fun x => LSeries f ↑x) =ᶠ[Filter.atTop] fun x => LSeries g ↑x) → ∀ {n : ℕ}, n ≠ 0 → f n = g n |
Lean.Meta.Grind.Arith.Cutsat.Search.Kind.recOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM | {motive : Lean.Meta.Grind.Arith.Cutsat.Search.Kind → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.Search.Kind) →
motive Lean.Meta.Grind.Arith.Cutsat.Search.Kind.rat → motive Lean.Meta.Grind.Arith.Cutsat.Search.Kind.int → motive t |
Std.DHashMap.Raw.all | Std.Data.DHashMap.RawDef | {α : Type u} → {β : α → Type v} → Std.DHashMap.Raw α β → ((a : α) → β a → Bool) → Bool |
_private.Std.Time.Time.Unit.Basic.0.Std.Time.Millisecond.Offset.ofHours._proof_1 | Std.Time.Time.Unit.Basic | 3600 / ↑3600000 = 1 / 1000 |
Fin.castPred_lt_castPred | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} {i j : Fin (n + 1)} (h : i < j) (hj : j ≠ Fin.last n), i.castPred ⋯ < j.castPred hj |
add_comm | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommMagma G] (a b : G), a + b = b + a |
Ordnode.eraseMax._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Ordnode α |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.MvPolynomial.universalFactorizationMapPresentation_jacobiMatrix._proof_1_3 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (m k : ℕ) (i i_1 : Fin m),
(if i_1 < i then 0
else if h : ↑i_1 - ↑i < k then MvPolynomial.X (Sum.inr ⟨↑i_1 - ↑i, ⋯⟩) else if ↑i_1 - ↑i = k then 1 else 0) =
if i ≤ i_1 ∧ ↑i_1 ≤ ↑i + k then
if h : ↑i_1 - ↑i < k then MvPolynomial.X (Sum.inr ⟨↑i_1 - ↑i, ⋯⟩) else if ↑i_1 - ↑i = k then 1 else 0
else 0 |
cantorToTernary._proof_1 | Mathlib.Topology.Instances.CantorSet | NeZero (2 + 1) |
Lean.Meta.Grind.Arith.CollectDecVars.State.ctorIdx | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Meta.Grind.Arith.CollectDecVars.State → ℕ |
AddSubgroup.le_prod_iff | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] {H : AddSubgroup G} {K : AddSubgroup N}
{J : AddSubgroup (G × N)},
J ≤ H.prod K ↔ AddSubgroup.map (AddMonoidHom.fst G N) J ≤ H ∧ AddSubgroup.map (AddMonoidHom.snd G N) J ≤ K |
Int8.toInt64_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int8), (a ^^^ b).toInt64 = a.toInt64 ^^^ b.toInt64 |
Lean.Meta.Grind.Arith.Linear.Case.recOn | Lean.Meta.Tactic.Grind.Arith.Linear.SearchM | {motive : Lean.Meta.Grind.Arith.Linear.Case → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.Case) →
((c : Lean.Meta.Grind.Arith.Linear.DiseqCnstr) →
(fvarId : Lean.FVarId) →
(saved : Lean.Meta.Grind.Arith.Linear.Struct) → motive { c := c, fvarId := fvarId, saved := saved }) →
motive t |
Localization.awayEquivAdjoin._proof_1 | Mathlib.RingTheory.Localization.Away.AdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (r : R), IsUnit ((AdjoinRoot.of (Polynomial.C r * Polynomial.X - 1)) r) |
AddSubgroup.ofAddUnitsEquivType.eq_1 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubgroup (AddUnits M)),
S.ofAddUnitsEquivType =
{ toFun := fun x => ⟨S.addUnit_of_mem_ofAddUnits ⋯, ⋯⟩, invFun := fun x => ⟨↑↑x, ⋯⟩, left_inv := ⋯, right_inv := ⋯,
map_add' := ⋯ } |
IsMax.of_succ_le | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : SuccOrder α] {a : α}, Order.succ a ≤ a → IsMax a |
Finset.sum_Icc_of_even_eq_range | Mathlib.Algebra.BigOperators.Group.Finset.Interval | ∀ {α : Type u_1} [inst : AddCommGroup α] {f : ℤ → α},
Function.Even f → ∀ (N : ℕ), ∑ m ∈ Finset.Icc (-↑N) ↑N, f m = 2 • ∑ m ∈ Finset.range (N + 1), f ↑m - f 0 |
Nat.multichoose._unary._proof_1 | Mathlib.Data.Nat.Choose.Basic | WellFounded (invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 |
Lean.TagAttributeExtra.getDecls | Batteries.Lean.AttributeExtra | Lean.TagAttributeExtra → Lean.Environment → Array Lean.Name |
AbsoluteValue.trivial.eq_1 | Mathlib.Analysis.AbsoluteValue.Equivalence | ∀ {R : Type u_5} [inst : Semiring R] [inst_1 : DecidablePred fun x => x = 0] [inst_2 : NoZeroDivisors R] {S : Type u_6}
[inst_3 : Semiring S] [inst_4 : PartialOrder S] [inst_5 : IsOrderedRing S] [inst_6 : Nontrivial S],
AbsoluteValue.trivial =
{ toFun := fun x => if x = 0 then 0 else 1, map_mul' := ⋯, nonneg' := ⋯, eq_zero' := ⋯, add_le' := ⋯ } |
Lean.Lsp.ResolveSupport.ctorIdx | Lean.Data.Lsp.Basic | Lean.Lsp.ResolveSupport → ℕ |
Batteries.RBSet.Slow.instDecidableEMem | Batteries.Data.RBMap.Basic | {α : Type u_1} →
{cmp : α → α → Ordering} →
{x : α} → [DecidableEq α] → {t : Batteries.RBSet α cmp} → Decidable (Batteries.RBSet.EMem x t) |
Int.sub_neg_of_lt | Init.Data.Int.Order | ∀ {a b : ℤ}, a < b → a - b < 0 |
TopologicalSpace.Opens.IsBasis | Mathlib.Topology.Sets.Opens | {α : Type u_2} → [inst : TopologicalSpace α] → Set (TopologicalSpace.Opens α) → Prop |
AddSubgroup.comap_sup_comap_le | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : AddGroup G] {N : Type u_5} [inst_1 : AddGroup N] (H K : AddSubgroup N) (f : G →+ N),
AddSubgroup.comap f H ⊔ AddSubgroup.comap f K ≤ AddSubgroup.comap f (H ⊔ K) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.