name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
List.le_sum_of_subadditive_on_pred | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {α : Type u_5} {β : Type u_6} [inst : AddMonoid α] [inst_1 : AddCommMonoid β] [inst_2 : Preorder β]
[IsOrderedAddMonoid β] (f : α → β) (p : α → Prop),
f 0 ≤ 0 →
p 0 →
(∀ (a b : α), p a → p b → f (a + b) ≤ f a + f b) →
(∀ (a b : α), p a → p b → p (a + b)) → ∀ (l : List α), (∀ a ∈ l, p a) → f l.sum ≤ (List.map f l).sum |
Units.ofPow._proof_1 | Mathlib.Algebra.Group.Commute.Units | ∀ {M : Type u_1} [inst : Monoid M] (u : Mˣ) (x : M) {n : ℕ}, n ≠ 0 → x ^ n = ↑u → x * x ^ (n - 1) = ↑u |
Array.exists_mem_empty | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (p : α → Prop), ¬∃ x, ∃ (_ : x ∈ #[]), p x |
Function.Injective.unique | Mathlib.Logic.Unique | {α : Sort u_1} → {β : Sort u_2} → {f : α → β} → [Inhabited α] → [Subsingleton β] → Function.Injective f → Unique α |
InnerProductSpace.Core.inner_smul_left | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x y : F) {r : 𝕜}, inner 𝕜 (r • x) y = (starRingEnd 𝕜) r * inner 𝕜 x y |
_private.Mathlib.RingTheory.PrincipalIdealDomain.0.Ideal.nonPrincipals_eq_empty_iff._simp_1_1 | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s |
_private.Mathlib.Analysis.SpecialFunctions.Complex.LogBounds.0.Complex.norm_log_sub_logTaylor_le._simp_1_8 | Mathlib.Analysis.SpecialFunctions.Complex.LogBounds | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False |
Lean.Lsp.DeclInfo.mk | Lean.Data.Lsp.Internal | ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ → Lean.Lsp.DeclInfo |
AddCommute.op | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Add α] {x y : α}, AddCommute x y → AddCommute (AddOpposite.op x) (AddOpposite.op y) |
CategoryTheory.Limits.Cone.fromStructuredArrow._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} C] {D : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} D]
(F : CategoryTheory.Functor C D) {X : D} (G : CategoryTheory.Functor J (CategoryTheory.StructuredArrow X F))
⦃X_1 Y : J⦄ (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj X).map f) (G.obj Y).hom =
CategoryTheory.CategoryStruct.comp (G.obj X_1).hom
((G.comp ((CategoryTheory.StructuredArrow.proj X F).comp F)).map f) |
_private.Mathlib.Order.Disjoint.0.disjoint_assoc._proof_1_1 | Mathlib.Order.Disjoint | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b c : α}, Disjoint (a ⊓ b) c ↔ Disjoint a (b ⊓ c) |
AlgebraicGeometry.IsFinite.rec | Mathlib.AlgebraicGeometry.Morphisms.Finite | {X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.IsFinite f → Sort u} →
([toIsAffineHom : AlgebraicGeometry.IsAffineHom f] →
(finite_app :
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U →
(CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) →
motive ⋯) →
(t : AlgebraicGeometry.IsFinite f) → motive t |
TestFunction.postcompCLM._proof_10 | Mathlib.Analysis.Distribution.TestFunction | ∀ {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {F' : Type u_3} [inst_6 : NormedAddCommGroup F']
[inst_7 : NormedSpace ℝ F'] [inst_8 : NormedSpace 𝕜 F'] {n : ℕ∞} [inst_9 : Algebra ℝ 𝕜]
[inst_10 : IsScalarTower ℝ 𝕜 F] [inst_11 : IsScalarTower ℝ 𝕜 F'] (T : F →L[𝕜] F') (K : TopologicalSpace.Compacts E)
(K_sub_Ω : ↑K ⊆ ↑Ω),
Continuous
((fun f => { toFun := ⇑T ∘ ⇑f, contDiff' := ⋯, hasCompactSupport' := ⋯, tsupport_subset' := ⋯ }) ∘
TestFunction.ofSupportedIn K_sub_Ω) |
Num.toZNum_inj | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, m.toZNum = n.toZNum ↔ m = n |
Std.DTreeMap.Internal.Impl.getEntryLT | Std.Data.DTreeMap.Internal.Queries | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
[Std.TransOrd α] →
(k : α) →
(t : Std.DTreeMap.Internal.Impl α β) → t.Ordered → (∃ a ∈ t, compare a k = Ordering.lt) → (a : α) × β a |
Lean.Meta.Grind.Arith.Cutsat.LeCnstr.brecOn.eq | 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.LeCnstr)
(F_1 : (t : Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof) → t.below → motive_2 t)
(F_3 : (t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → t.below → motive_3 t)
(F_4 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred) → t.below → motive_4 t)
(F_5 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplit) → t.below → motive_5 t)
(F_6 : (t : Lean.Meta.Grind.Arith.Cutsat.CooperSplitProof) → t.below → motive_6 t)
(F_7 : (t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) → t.below → motive_7 t)
(F_8 : (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) → t.below → motive_8 t)
(F_9 : (t : Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof) → t.below → motive_9 t)
(F_10 : (t : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) → t.below → motive_10 t)
(F_11 : (t : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof) → t.below → motive_11 t)
(F_12 : (t : Lean.Meta.Grind.Arith.Cutsat.UnsatProof) → t.below → motive_12 t)
(F_13 :
(t : Array (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_1 t → motive_13 t)
(F_14 :
(t : Option Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_2 t → motive_14 t)
(F_15 :
(t : Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_3 t → motive_15 t)
(F_16 :
(t : Array (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_4 t → motive_16 t)
(F_17 :
(t : List (Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_5 t → motive_17 t)
(F_18 :
(t : List (Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof)) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_6 t → motive_18 t)
(F_19 :
(t : Lean.Expr × ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_7 t → motive_19 t)
(F_20 :
(t : Lean.FVarId × Lean.Meta.Grind.Arith.Cutsat.UnsatProof) →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_8 t → motive_20 t)
(F_21 :
(t : ℤ × Lean.Meta.Grind.Arith.Cutsat.EqCnstr) → Lean.Meta.Grind.Arith.Cutsat.EqCnstr.below_9 t → motive_21 t),
t.brecOn F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9 F_10 F_11 F_12 F_13 F_14 F_15 F_16 F_17 F_18 F_19 F_20 F_21 =
F_8 t
(Lean.Meta.Grind.Arith.Cutsat.LeCnstr.brecOn.go t F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9 F_10 F_11 F_12 F_13 F_14
F_15 F_16 F_17 F_18 F_19 F_20 F_21).2 |
Metric.diam_cthickening_le | Mathlib.Topology.MetricSpace.Thickening | ∀ {ε : ℝ} {α : Type u_2} [inst : PseudoMetricSpace α] (s : Set α),
0 ≤ ε → Metric.diam (Metric.cthickening ε s) ≤ Metric.diam s + 2 * ε |
CategoryTheory.Monoidal.instMonoidalTransportedInverseEquivalenceTransported._proof_4 | Mathlib.CategoryTheory.Monoidal.Transport | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} D] (e : C ≌ D)
{X₁ Y₁ X₂ Y₂ : CategoryTheory.Monoidal.Transported e} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
e.inverse.map (CategoryTheory.MonoidalCategoryStruct.tensorHom f g) =
CategoryTheory.CategoryStruct.comp
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj X₁) (e.inverse.obj X₂))).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.tensorHom (e.inverse.map f) (e.inverse.map g))
(e.unitIso.app (CategoryTheory.MonoidalCategoryStruct.tensorObj (e.inverse.obj Y₁) (e.inverse.obj Y₂))).hom) |
Module.Grassmannian._sizeOf_inst | Mathlib.RingTheory.Grassmannian | (R : Type u) →
{inst : CommRing R} →
(M : Type v) →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} → (k : ℕ) → [SizeOf R] → [SizeOf M] → SizeOf (Module.Grassmannian R M k) |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetLimitCone_cone_π_app | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {α : Type w}
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C) (j : CategoryTheory.Discrete α),
(CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetLimitCone F).cone.π.app j =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.limit.π (CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinsetObj F)
(Opposite.op {j}))
(CategoryTheory.Limits.Pi.π (fun x => F.obj ↑x) ⟨j, ⋯⟩) |
Function.IsFixedPt.image_iterate | Mathlib.Dynamics.FixedPoints.Basic | ∀ {α : Type u} {f : α → α} {s : Set α},
Function.IsFixedPt (Set.image f) s → ∀ (n : ℕ), Function.IsFixedPt (Set.image f^[n]) s |
WittVector.instCommRing._proof_9 | Mathlib.RingTheory.WittVector.Basic | ∀ (p : ℕ) (R : Type u_1) [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] (z : ℤ)
(x : WittVector p (MvPolynomial R ℤ)),
WittVector.mapFun (⇑(MvPolynomial.counit R)) (z • x) = z • WittVector.mapFun (⇑(MvPolynomial.counit R)) x |
Lean.Compiler.LCNF.Simp.ConstantFold.folderExt | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.PersistentEnvExtension Lean.Compiler.LCNF.Simp.ConstantFold.FolderOleanEntry
Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry
(List Lean.Compiler.LCNF.Simp.ConstantFold.FolderEntry ×
Lean.SMap Lean.Name Lean.Compiler.LCNF.Simp.ConstantFold.Folder) |
ULift.seminormedRing._proof_17 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a : ULift.{u_1, u_2} α), -a + a = 0 |
Aesop.Nanos.nanos | Aesop.Nanos | Aesop.Nanos → ℕ |
Set.Ioc_add_bij | Mathlib.Algebra.Order.Interval.Set.Monoid | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [IsOrderedCancelAddMonoid M] [ExistsAddOfLE M]
(a b d : M), Set.BijOn (fun x => x + d) (Set.Ioc a b) (Set.Ioc (a + d) (b + d)) |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.setParentBump_rankD_lt._proof_1 | Batteries.Data.UnionFind.Basic | ∀ {arr' : Array Batteries.UFNode} {arr : Array Batteries.UFNode} {x : Fin arr.size} {y : Fin arr.size} {i : ℕ},
¬↑x < arr.size → False |
Polynomial.Monic.add_of_left | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R}, p.Monic → q.degree < p.degree → (p + q).Monic |
setOf_riemannianEDist_lt_subset_nhds' | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
(I : ModelWithCorners ℝ E H) {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M]
[inst_5 : Bundle.RiemannianBundle fun x => TangentSpace I x] [inst_6 : IsManifold I 1 M]
[IsContinuousRiemannianBundle E fun x => TangentSpace I x] [RegularSpace M] {x : M} {s : Set M},
s ∈ nhds x → ∃ c > 0, {y | Manifold.riemannianEDist I x y < c} ⊆ s |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_725 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] [g (g a)].length + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] [g (g a)].length <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
Bundle.Pullback.lift | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_2} →
{E : B → Type u_3} → {B' : Type u_4} → (f : B' → B) → Bundle.TotalSpace F (f *ᵖ E) → Bundle.TotalSpace F E |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.Y_eq_of_equiv._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 1 = u * P 1 |
Matrix.diagonalLinearMap._proof_1 | Mathlib.Data.Matrix.Basic | ∀ (n : Type u_2) (α : Type u_1) [inst : DecidableEq n] [inst_1 : AddCommMonoid α] (x y : n → α),
(↑(Matrix.diagonalAddMonoidHom n α)).toFun (x + y) =
(↑(Matrix.diagonalAddMonoidHom n α)).toFun x + (↑(Matrix.diagonalAddMonoidHom n α)).toFun y |
Turing.TM1.SupportsStmt.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (S : Finset Λ) (a : Γ → σ → Γ) (q : Turing.TM1.Stmt Γ Λ σ),
Turing.TM1.SupportsStmt S (Turing.TM1.Stmt.write a q) = Turing.TM1.SupportsStmt S q |
Ideal.exists_finset_card_eq_height_of_isNoetherianRing | Mathlib.RingTheory.Ideal.KrullsHeightTheorem | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] (p : Ideal R) [p.IsPrime],
∃ s, p ∈ (Ideal.span ↑s).minimalPrimes ∧ ↑s.card = p.height |
_private.Mathlib.Data.Fin.Tuple.Finset.0.Fin.mem_piFinset_iff_last_init._simp_1_2 | Mathlib.Data.Fin.Tuple.Finset | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = ((∀ (i : Fin n), P i.castSucc) ∧ P (Fin.last n)) |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.indices | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → List ℕ |
Lean.Meta.NormCast.NormCastExtension.up | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.NormCastExtension → Lean.Meta.SimpExtension |
CategoryTheory.Localization.Lifting | Mathlib.CategoryTheory.Localization.Predicate | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{E : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} E] →
CategoryTheory.Functor C D →
CategoryTheory.MorphismProperty C →
CategoryTheory.Functor C E → CategoryTheory.Functor D E → Type (max u_1 v_3) |
CategoryTheory.MorphismProperty.HasRightCalculusOfFractions.exists_rightFraction | Mathlib.CategoryTheory.Localization.CalculusOfFractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C}
[self : W.HasRightCalculusOfFractions] ⦃X Y : C⦄ (φ : W.LeftFraction X Y),
∃ ψ, CategoryTheory.CategoryStruct.comp ψ.s φ.f = CategoryTheory.CategoryStruct.comp ψ.f φ.s |
CategoryTheory.Limits.prod.inl.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X Y : C)
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y],
CategoryTheory.Limits.prod.inl X Y = CategoryTheory.Limits.prod.lift (CategoryTheory.CategoryStruct.id X) 0 |
Nat.succ_injective | Mathlib.Data.Nat.Basic | Function.Injective Nat.succ |
_private.Mathlib.RingTheory.Localization.Away.Basic.0.IsLocalization.Away.map_injective_iff._simp_1_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {M : Type u_1} [inst : Monoid M] (x z : M), (x ∈ Submonoid.powers z) = ∃ n, z ^ n = x |
LinearMap.isBigOTVS_rev_comp | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} (g : E →ₗ[𝕜] F),
Filter.comap (⇑g) (nhds 0) ≤ nhds 0 → f =O[𝕜; l] (⇑g ∘ f) |
CommMonCat.FilteredColimits.forget_preservesFilteredColimits | Mathlib.Algebra.Category.MonCat.FilteredColimits | CategoryTheory.Limits.PreservesFilteredColimits (CategoryTheory.forget CommMonCat) |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processId._sparseCasesOn_1 | Lean.Elab.PatternVar | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (Lean.ConstantInfo.ctorInfo val)) →
(Nat.hasNotBit 64 t.ctorIdx → motive t) → motive t |
Complex.im_mul_ofReal | Mathlib.Data.Complex.Basic | ∀ (z : ℂ) (r : ℝ), (z * ↑r).im = z.im * r |
ConvexOn.exists_lipschitzOnWith_of_isBounded | Mathlib.Analysis.Convex.Continuous | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x₀ : E} {r r' : ℝ},
ConvexOn ℝ (Metric.ball x₀ r) f →
r' < r → Bornology.IsBounded (f '' Metric.ball x₀ r) → ∃ K, LipschitzOnWith K f (Metric.ball x₀ r') |
_private.Mathlib.Analysis.Convex.Function.0.OrderIso.strictConvexOn_symm._simp_1_1 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u_1} [inst : LT α] {x y : α}, (x > y) = (y < x) |
CategoryTheory.Triangulated.SpectralObject.ω₂_map_hom₃ | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_6 : CategoryTheory.Pretriangulated C]
(X : CategoryTheory.Triangulated.SpectralObject C ι) {X_1 Y : CategoryTheory.ComposableArrows ι 2} (φ : X_1 ⟶ Y),
(X.ω₂.map φ).hom₃ = X.ω₁.map (CategoryTheory.ComposableArrows.homMk₁ (φ.app 1) (φ.app ⟨2, ⋯⟩) ⋯) |
CategoryTheory.PreOneHypercover.map_f | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (i : E.I₀),
(E.map F).f i = F.map (E.f i) |
Pi.instBiheytingAlgebra._proof_1 | Mathlib.Order.Heyting.Basic | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → BiheytingAlgebra (α i)] (a b c : (i : ι) → α i),
a \ b ≤ c ↔ a ≤ b ⊔ c |
Interval.commMonoid._proof_5 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (a : Interval α), a * 1 = a |
jacobiSum_one_one | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {F : Type u_1} {R : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : CommRing R],
jacobiSum 1 1 = ↑(Fintype.card F) - 2 |
Nat.decidableForallFin._proof_1 | Init.Data.Nat.Lemmas | ∀ {n : ℕ} (P : Fin n → Prop), (∀ (k : ℕ) (h : k < n), P ⟨k, h⟩) ↔ ∀ (i : Fin n), P i |
ContinuousMap.compactConvergenceUniformSpace | Mathlib.Topology.UniformSpace.CompactConvergence | {α : Type u₁} → {β : Type u₂} → [inst : TopologicalSpace α] → [inst_1 : UniformSpace β] → UniformSpace C(α, β) |
IsStarNormal.neg | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : StarAddMonoid R] {x : R} [IsStarNormal x], IsStarNormal (-x) |
Std.DTreeMap.Internal.Impl.insertMin.match_3.congr_eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} (motive : (t : Std.DTreeMap.Internal.Impl α β) → t.Balanced → Sort u_3)
(t : Std.DTreeMap.Internal.Impl α β) (hr : t.Balanced)
(h_1 : (hr : Std.DTreeMap.Internal.Impl.leaf.Balanced) → motive Std.DTreeMap.Internal.Impl.leaf hr)
(h_2 :
(sz : ℕ) →
(k' : α) →
(v' : β k') →
(l' r' : Std.DTreeMap.Internal.Impl α β) →
(hr : (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r').Balanced) →
motive (Std.DTreeMap.Internal.Impl.inner sz k' v' l' r') hr)
(hr_1 : Std.DTreeMap.Internal.Impl.leaf.Balanced),
t = Std.DTreeMap.Internal.Impl.leaf →
hr ≍ hr_1 →
(match t, hr with
| Std.DTreeMap.Internal.Impl.leaf, hr => h_1 hr
| Std.DTreeMap.Internal.Impl.inner sz k' v' l' r', hr => h_2 sz k' v' l' r' hr) ≍
h_1 hr_1 |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.einfsep_insert._simp_1_1 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Set α} {d : ENNReal}, (d ≤ s.einfsep) = ∀ x ∈ s, ∀ y ∈ s, x ≠ y → d ≤ edist x y |
NNRat.cast_div_of_ne_zero | Mathlib.Data.Rat.Cast.Defs | ∀ {α : Type u_3} [inst : DivisionSemiring α] {q r : ℚ≥0}, ↑q.den ≠ 0 → ↑r.num ≠ 0 → ↑(q / r) = ↑q / ↑r |
List.minOn_append._proof_1 | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} {xs ys : List α}, xs ≠ [] → xs ++ ys ≠ [] |
norm_deriv_eq_norm_fderiv | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, ‖deriv f x‖ = ‖fderiv 𝕜 f x‖ |
FreeGroup.Red.decidableRel._proof_3 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (x : α) (b : Bool) (tl : List (α × Bool)), FreeGroup.Red tl [(x, !b)] → FreeGroup.Red ((x, b) :: tl) [] |
RCLike.norm_coe_norm | Mathlib.Analysis.Normed.Module.RCLike.Basic | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E] {z : E}, ‖↑‖z‖‖ = ‖z‖ |
FreeAddGroup.Red.Step.sublist | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)}, FreeAddGroup.Red.Step L₁ L₂ → L₂.Sublist L₁ |
_private.Std.Data.DHashMap.Basic.0.Std.DHashMap.Const.modify._proof_1 | Std.Data.DHashMap.Basic | ∀ {α : Type u_1} {x : BEq α} {x_1 : Hashable α} {β : Type u_2} (m : Std.DHashMap α fun x => β) (a : α) (f : β → β),
(↑(Std.DHashMap.Internal.Raw₀.Const.modify ⟨m.inner, ⋯⟩ a f)).WF |
MvPowerSeries.eq_inv_iff_mul_eq_one | Mathlib.RingTheory.MvPowerSeries.Inverse | ∀ {σ : Type u_1} {k : Type u_3} [inst : Field k] {φ ψ : MvPowerSeries σ k},
MvPowerSeries.constantCoeff ψ ≠ 0 → (φ = ψ⁻¹ ↔ φ * ψ = 1) |
Set.singleton_inter_of_notMem | Mathlib.Data.Set.Insert | ∀ {α : Type u} {s : Set α} {a : α}, a ∉ s → {a} ∩ s = ∅ |
Lean.Parser.Term.optIdent.parenthesizer | Lean.Parser.Term.Basic | Lean.PrettyPrinter.Parenthesizer |
NumberField.mixedEmbedding.fundamentalCone.expMapBasis_nonneg | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.NormLeOne | ∀ {K : Type u_1} [inst : Field K] [inst_1 : NumberField K] (x : NumberField.mixedEmbedding.realSpace K)
(w : NumberField.InfinitePlace K), 0 ≤ ↑NumberField.mixedEmbedding.fundamentalCone.expMapBasis x w |
Batteries.BinomialHeap.Imp.FindMin.recOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{motive : Batteries.BinomialHeap.Imp.FindMin α → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin α) →
((before : Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α) →
(val : α) →
(node : Batteries.BinomialHeap.Imp.HeapNode α) →
(next : Batteries.BinomialHeap.Imp.Heap α) →
motive { before := before, val := val, node := node, next := next }) →
motive t |
_private.Mathlib.Combinatorics.Enumerative.Partition.Glaisher.0.Nat.Partition.aux_mul_one_sub_X_pow._proof_1_2 | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : CommRing R] {m : ℕ},
0 < m → ∀ (i : ↑(Function.mulSupport fun i => 1 - (PowerSeries.X ^ (i + 1)) ^ m)), (↑i + 1) * m - 1 + 1 = (↑i + 1) * m |
Lean.Grind.CommRing.Poly.cancelVar | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly |
CategoryTheory.Pseudofunctor.DescentData'.instCategory._proof_2 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃)}
(x : F.DescentData' sq sq₃) (i₁ i₂ : ι),
CategoryTheory.CategoryStruct.comp
((F.map (sq i₁ i₂).p₁.op.toLoc).toFunctor.map (CategoryTheory.CategoryStruct.id (x.obj i₁))) (x.hom i₁ i₂) =
CategoryTheory.CategoryStruct.comp (x.hom i₁ i₂)
((F.map (sq i₁ i₂).p₂.op.toLoc).toFunctor.map (CategoryTheory.CategoryStruct.id (x.obj i₂))) |
ContMDiffWithinAt.change_section_trivialization | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {M : Type u_5} {E : B → Type u_6}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_7} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_8} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B]
[inst_5 : ChartedSpace HB B] {EM : Type u_9} [inst_6 : NormedAddCommGroup EM] [inst_7 : NormedSpace 𝕜 EM]
{HM : Type u_10} [inst_8 : TopologicalSpace HM] {IM : ModelWithCorners 𝕜 EM HM} [inst_9 : TopologicalSpace M]
[inst_10 : ChartedSpace HM M] [inst_11 : (x : B) → AddCommMonoid (E x)] [inst_12 : (x : B) → Module 𝕜 (E x)]
[inst_13 : NormedAddCommGroup F] [inst_14 : NormedSpace 𝕜 F] [inst_15 : TopologicalSpace (Bundle.TotalSpace F E)]
[inst_16 : (x : B) → TopologicalSpace (E x)] [inst_17 : FiberBundle F E] [inst_18 : VectorBundle 𝕜 F E]
[ContMDiffVectorBundle n F E IB] {e e' : Bundle.Trivialization F Bundle.TotalSpace.proj} [MemTrivializationAtlas e]
[MemTrivializationAtlas e'] {s : Set M} {x : M} {f : M → Bundle.TotalSpace F E},
ContMDiffWithinAt IM IB n (Bundle.TotalSpace.proj ∘ f) s x →
ContMDiffWithinAt IM (modelWithCornersSelf 𝕜 F) n (fun y => (↑e (f y)).2) s x →
f x ∈ e.source → f x ∈ e'.source → ContMDiffWithinAt IM (modelWithCornersSelf 𝕜 F) n (fun y => (↑e' (f y)).2) s x |
MvPolynomial.monomial_zero' | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], ⇑(MvPolynomial.monomial 0) = ⇑MvPolynomial.C |
WittVector.succNthValUnits.congr_simp | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (n : ℕ) (a a_1 : kˣ),
a = a_1 →
∀ (A A_1 : WittVector p k),
A = A_1 →
∀ (bs bs_1 : Fin (n + 1) → k),
bs = bs_1 → WittVector.succNthValUnits n a A bs = WittVector.succNthValUnits n a_1 A_1 bs_1 |
Finset.measure_zero | Mathlib.MeasureTheory.Measure.Typeclasses.NoAtoms | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (s : Finset α) (μ : MeasureTheory.Measure α) [MeasureTheory.NoAtoms μ],
μ ↑s = 0 |
Lean.Meta.RefinedDiscrTree.Key.bvar | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ℕ → ℕ → Lean.Meta.RefinedDiscrTree.Key |
Lean.Grind.AC.diseq_simp_rhs_ac | Init.Grind.AC | ∀ {α : Sort u_1} (ctx : Lean.Grind.AC.Context α) {inst₁ : Std.Associative ctx.op} {inst₂ : Std.Commutative ctx.op}
(c lhs₁ rhs₁ lhs₂ rhs₂ rhs₂' : Lean.Grind.AC.Seq),
Lean.Grind.AC.simp_ac_cert c lhs₁ rhs₁ rhs₂ rhs₂' = true →
Lean.Grind.AC.Seq.denote ctx lhs₁ = Lean.Grind.AC.Seq.denote ctx rhs₁ →
Lean.Grind.AC.Seq.denote ctx lhs₂ ≠ Lean.Grind.AC.Seq.denote ctx rhs₂ →
Lean.Grind.AC.Seq.denote ctx lhs₂ ≠ Lean.Grind.AC.Seq.denote ctx rhs₂' |
Lean.isInstanceReducibleCore | Lean.ReducibilityAttrs | Lean.Environment → Lean.Name → Bool |
MulEquiv.withOneCongr._proof_2 | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] (e : α ≃* β) (x : WithOne α),
(WithOne.mapMulHom e.symm.toMulHom) ((WithOne.mapMulHom e.toMulHom) x) = x |
ONote.zero.elim | Mathlib.SetTheory.Ordinal.Notation | {motive : ONote → Sort u} → (t : ONote) → t.ctorIdx = 0 → motive ONote.zero → motive t |
Con.lift | Mathlib.GroupTheory.Congruence.Hom | {M : Type u_1} →
{P : Type u_3} →
[inst : MulOneClass M] → [inst_1 : MulOneClass P] → (c : Con M) → (f : M →* P) → c ≤ Con.ker f → c.Quotient →* P |
TopologicalSpace.Closeds.noncompactSpace_iff._simp_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], NoncompactSpace (TopologicalSpace.Closeds α) = NoncompactSpace α |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft | ∀ {w : ℕ} (distance curr idx : ℕ), idx < curr → ¬idx < curr + 1 → False |
Int.mul_fmod_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod a = 0 |
Lean.Parser.OrElseOnAntiquotBehavior.rec | Lean.Parser.Basic | {motive : Lean.Parser.OrElseOnAntiquotBehavior → Sort u} →
motive Lean.Parser.OrElseOnAntiquotBehavior.acceptLhs →
motive Lean.Parser.OrElseOnAntiquotBehavior.takeLongest →
motive Lean.Parser.OrElseOnAntiquotBehavior.merge → (t : Lean.Parser.OrElseOnAntiquotBehavior) → motive t |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.alterₘ.match_1.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_3} {β : α → Type u_1} (a : α) (motive : Option (β a) → Sort u_2) (b : β a) (h_1 : Unit → motive none)
(h_2 : (b : β a) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b |
Std.HashMap.getKey!_eq_getKeyD_default | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {a : α}, m.getKey! a = m.getKeyD a default |
_private.Init.Data.List.Count.0.List.count_erase.match_1_1 | Init.Data.List.Count | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (c : α) (l : List α), motive (c :: l)) → motive x |
LieModule.toEnd_eq_iff | Mathlib.Algebra.Lie.OfAssociative | ∀ (R : Type u) (L : Type v) (M : Type w) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[LieModule.IsFaithful R L M] {x y : L}, (LieModule.toEnd R L M) x = (LieModule.toEnd R L M) y ↔ x = y |
SSet.Subcomplex.PairingCore.index | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | {X : SSet} → {A : X.Subcomplex} → (self : A.PairingCore) → (s : self.ι) → Fin (self.dim s + 2) |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_eq_default._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Int.two_dvd_mul_add_one | Mathlib.Algebra.Ring.Int.Parity | ∀ (k : ℤ), 2 ∣ k * (k + 1) |
_private.Mathlib.Topology.EMetricSpace.Basic.0.EMetric.totallyBounded_iff'.match_1_1 | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {s : Set α} (ε : ENNReal)
(motive : (∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε) → Prop)
(x : ∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε),
(∀ (t : Set α) (left : t ⊆ s) (ft : t.Finite) (h : s ⊆ ⋃ y ∈ t, Metric.eball y ε), motive ⋯) → motive x |
Lean.Elab.Tactic.Omega.MetaProblem.ctorIdx | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.MetaProblem → ℕ |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.IsCyclic.monoidHomMulEquivRootsOfUnityOfGenerator._simp_2 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, (orderOf x ∣ n) = (x ^ n = 1) |
Order.krullDim_eq_iSup_length | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], Order.krullDim α = ↑(⨆ p, ↑p.length) |
Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit._proof_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α fun x => Unit) (h : t.Balanced) (a : α)
(r : Std.DTreeMap.Internal.Impl.Const.IteratedUnitInsertionInto t)
{P : (Std.DTreeMap.Internal.Impl α fun x => Unit) → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α fun x => Unit) (a : α) (h : t''.Balanced),
P t'' → P (Std.DTreeMap.Internal.Impl.insertIfNew a () t'' h).impl) →
P (Std.DTreeMap.Internal.Impl.insertIfNew a () ↑r ⋯).impl |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.