name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Mathlib.Tactic.ComputeDegree.natDegree_natCast_le | Mathlib.Tactic.ComputeDegree | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (↑n).natDegree ≤ 0 |
PresheafOfModules.evaluationJointlyReflectsColimits._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
(c : CategoryTheory.Limits.Cocone F)
(hc : (X : Cᵒᵖ) → CategoryTheory.Limits.IsColimit ((PresheafOfModules.evaluation R X).mapCocone c))
(s : CategoryTheory.Limits.Cocone F) {X Y : Cᵒᵖ} (f : X ⟶ Y) (j : J),
CategoryTheory.CategoryStruct.comp (((PresheafOfModules.evaluation R X).mapCocone c).ι.app j)
(CategoryTheory.CategoryStruct.comp (c.pt.map f)
((ModuleCat.restrictScalars (RingCat.Hom.hom (R.map f))).map
((hc Y).desc ((PresheafOfModules.evaluation R Y).mapCocone s)))) =
CategoryTheory.CategoryStruct.comp (((PresheafOfModules.evaluation R X).mapCocone c).ι.app j)
(CategoryTheory.CategoryStruct.comp ((hc X).desc ((PresheafOfModules.evaluation R X).mapCocone s)) (s.pt.map f)) |
Specialization.map_id | Mathlib.Topology.Specialization | ∀ {α : Type u_1} [inst : TopologicalSpace α], Specialization.map (ContinuousMap.id α) = OrderHom.id |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) |
Matrix.IsSymm.fromBlocks | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, A.IsSymm → B.transpose = C → D.IsSymm → (Matrix.fromBlocks A B C D).IsSymm |
Lean.Server.Reference.ci | Lean.Server.References | Lean.Server.Reference → Lean.Elab.ContextInfo |
Mathlib.pp.mathlib.binderPredicates | Mathlib.Util.PPOptions | Lean.Option Bool |
Set.iUnion_comm | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {ι' : Sort u_6} (s : ι → ι' → Set α), ⋃ i, ⋃ i', s i i' = ⋃ i', ⋃ i, s i i' |
Mathlib.Tactic.AtomM.Context.mk._flat_ctor | Mathlib.Util.AtomM | Lean.Meta.TransparencyMode → (Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result) → Mathlib.Tactic.AtomM.Context |
Units.val_eq_neg_one | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] {a : αˣ}, ↑a = -1 ↔ a = -1 |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.liftWith_trans._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) |
_private.Mathlib.Data.Finset.Lattice.Basic.0.Finset.instDistribLattice._simp_1 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ |
MulRingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : NonAssocRing R] → MulRingNorm R → AddGroupNorm R |
nnnorm_apply_le_nnnorm_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax |
Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite | Mathlib.RingTheory.Invariant.Profinite | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {G : Type u_3}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [SMulCommClass G A B] [inst_6 : TopologicalSpace G]
[CompactSpace G] [TotallyDisconnectedSpace G] [IsTopologicalGroup G] [inst_10 : TopologicalSpace B]
[DiscreteTopology B] [ContinuousSMul G B] [Algebra.IsInvariant A B G] (P Q : Ideal B) [P.IsPrime] [Q.IsPrime],
Ideal.under A P = Ideal.under A Q → ∃ g, Q = g • P |
Algebra.Extension.Hom.mk.inj | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S} {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} {inst_3 : CommRing R'} {inst_4 : CommRing S'} {inst_5 : Algebra R' S'}
{P' : Algebra.Extension R' S'} {inst_6 : Algebra R R'} {inst_7 : Algebra S S'} {toRingHom : P.Ring →+* P'.Ring}
{toRingHom_algebraMap :
∀ (x : R), toRingHom ((algebraMap R P.Ring) x) = (algebraMap R' P'.Ring) ((algebraMap R R') x)}
{algebraMap_toRingHom :
∀ (x : P.Ring), (algebraMap P'.Ring S') (toRingHom x) = (algebraMap S S') ((algebraMap P.Ring S) x)}
{toRingHom_1 : P.Ring →+* P'.Ring}
{toRingHom_algebraMap_1 :
∀ (x : R), toRingHom_1 ((algebraMap R P.Ring) x) = (algebraMap R' P'.Ring) ((algebraMap R R') x)}
{algebraMap_toRingHom_1 :
∀ (x : P.Ring), (algebraMap P'.Ring S') (toRingHom_1 x) = (algebraMap S S') ((algebraMap P.Ring S) x)},
{ toRingHom := toRingHom, toRingHom_algebraMap := toRingHom_algebraMap,
algebraMap_toRingHom := algebraMap_toRingHom } =
{ toRingHom := toRingHom_1, toRingHom_algebraMap := toRingHom_algebraMap_1,
algebraMap_toRingHom := algebraMap_toRingHom_1 } →
toRingHom = toRingHom_1 |
Perfection.coeff_mk | Mathlib.RingTheory.Perfection | ∀ {R : Type u₁} [inst : CommSemiring R] {p : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (f : ℕ → R)
(hf : ∀ (n : ℕ), f (n + 1) ^ p = f n) (n : ℕ), (Perfection.coeff R p n) ⟨f, hf⟩ = f n |
Function.Semiconj.comp_eq | Mathlib.Logic.Function.Conjugate | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β}, Function.Semiconj f ga gb → f ∘ ga = gb ∘ f |
Lean.Meta.Simp.Arith.Int.ToLinear.State.varMap._default | Lean.Meta.Tactic.Simp.Arith.Int.Basic | Lean.Meta.KExprMap ℕ |
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_none_iff._proof_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, ¬(¬xs.size - 1 < xs.size ↔ xs.size = 0) → False |
prod_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u_3} {β : Type u_4} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [ProperSpace α]
[ProperSpace β], ProperSpace (α × β) |
Preord.ofHom_id | Mathlib.Order.Category.Preord | ∀ {X : Type u} [inst : Preorder X],
Preord.ofHom OrderHom.id = CategoryTheory.CategoryStruct.id { carrier := X, str := inst } |
HasFDerivWithinAt.fun_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {f g : E → F}
{f' g' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt f f' s x → HasFDerivWithinAt g g' s x → HasFDerivWithinAt (fun i => f i - g i) (f' - g') s x |
Filter.le_limsup_iff' | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β}
[DenselyOrdered β] {x : β},
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._auto_1 →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._auto_3 →
(x ≤ Filter.limsup u f ↔ ∀ y < x, ∃ᶠ (a : α) in f, y ≤ u a) |
Lean.Meta.Sym.AlphaShareCommon.State.set._default | Lean.Meta.Sym.AlphaShareCommon | Lean.PHashSet Lean.Meta.Sym.AlphaKey |
MonadControl.noConfusionType | Init.Control.Basic | Sort u_1 →
{m : Type u → Type v} →
{n : Type u → Type w} →
MonadControl m n → {m' : Type u → Type v} → {n' : Type u → Type w} → MonadControl m' n' → Sort u_1 |
AlgebraicGeometry.«term_⤏_» | Mathlib.AlgebraicGeometry.RationalMap | Lean.TrailingParserDescr |
_private.Mathlib.Data.PNat.Basic.0.PNat.dvd_iff._simp_1_1 | Mathlib.Data.PNat.Basic | ∀ (n : ℕ+), (↑n = 0) = False |
CategoryTheory.InducedCategory.Hom.mk | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → (F X ⟶ F Y) → X.Hom Y |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntry?ₘ'.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
[inst : Ord α] →
(motive : (Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) → Sort u_3) →
(step : Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) →
((ky : α) →
(a : Ordering.lt = Ordering.lt) →
(y : β ky) →
(a_1 : List ((a : α) × β a)) → motive (Std.DTreeMap.Internal.Impl.ExplorationStep.lt ky a y a_1)) →
((a : List ((a : α) × β a)) →
(a_1 : Std.DTreeMap.Internal.Cell α β fun x => Ordering.lt) →
(r : List ((a : α) × β a)) → motive (Std.DTreeMap.Internal.Impl.ExplorationStep.eq a a_1 r)) →
motive step |
_private.Lean.Meta.Tactic.Simp.Arith.Nat.Simp.0.Lean.Meta.Simp.Arith.Nat.simpCnstr?.match_1 | Lean.Meta.Tactic.Simp.Arith.Nat.Simp | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(__discr : Option (Lean.Expr × Lean.Expr)) →
((eNew' h₂ : Lean.Expr) → motive (some (eNew', h₂))) →
((x : Option (Lean.Expr × Lean.Expr)) → motive x) → motive __discr |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.nz_of_isRat.match_1_1 | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n : ℤ} {d : ℕ} [inst : Ring A]
(motive : Mathlib.Meta.NormNum.IsRat e n d → decide (n < 0) = true → Prop) (x : Mathlib.Meta.NormNum.IsRat e n d)
(x_1 : decide (n < 0) = true),
(∀ (inv : Invertible ↑d) (eq : e = ↑n * ⅟↑d) (h : decide (n < 0) = true), motive ⋯ h) → motive x x_1 |
FiniteField.frobenius_pow | Mathlib.FieldTheory.Finite.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Fintype K] {p : ℕ} [inst_2 : Fact (Nat.Prime p)] [inst_3 : CharP K p]
{n : ℕ}, Fintype.card K = p ^ n → frobenius K p ^ n = 1 |
IsDiscreteValuationRing.unit_mul_pow_congr_unit | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsDiscreteValuationRing R] {ϖ : R},
Irreducible ϖ → ∀ (u v : Rˣ) (m n : ℕ), ↑u * ϖ ^ m = ↑v * ϖ ^ n → u = v |
ContinuousLinearEquiv.toDiffeomorph._proof_2 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(e : E ≃L[𝕜] E'), ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') ↑⊤ ⇑e |
Fin.foldrM_succ | Init.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Type u_1} [inst : Monad m] [LawfulMonad m] (f : Fin (n + 1) → α → m α),
Fin.foldrM (n + 1) f = fun x => Fin.foldrM n (fun i => f i.succ) x >>= f 0 |
Lean.ppNoDotAttr._regBuiltin.Lean.ppNoDotAttr.declRange_3 | Lean.PrettyPrinter.Delaborator.Attributes | IO Unit |
PiTensorProduct.mapLMonoidHom._proof_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {ι : Type u_2} [inst : Fintype ι] {𝕜 : Type u_3} [inst_1 : NontriviallyNormedField 𝕜] {E : ι → Type u_1}
[inst_2 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)],
ContinuousAdd (PiTensorProduct 𝕜 fun i => E i) |
Filter.CountableGenerateSets.below.basic | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_2} {g : Set (Set α)} {motive : (a : Set α) → Filter.CountableGenerateSets g a → Prop} {s : Set α}
(a : s ∈ g), Filter.CountableGenerateSets.below ⋯ |
List.sum_set | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (L : List M) (n : ℕ) (a : M),
(L.set n a).sum = ((List.take n L).sum + if n < L.length then a else 0) + (List.drop (n + 1) L).sum |
PartENat.add_lt_add_iff_right | Mathlib.Data.Nat.PartENat | ∀ {x y z : PartENat}, z ≠ ⊤ → (x + z < y + z ↔ x < y) |
LinearMap.convOne_apply | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_1} {A : Type u_2} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : Coalgebra R C] (c : C),
(WithConv.ofConv 1) c = (algebraMap R A) (CoalgebraStruct.counit c) |
Lean.IR.IRType.below | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} → Lean.IR.IRType → Sort (max 1 u) |
_private.Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno.0.OrderedFinpartition.eraseMiddle._simp_5 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (a b : Fin n), (a = b) = (↑a = ↑b) |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushPending | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Unit |
Localization.algEquiv_symm_mk | Mathlib.RingTheory.Localization.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
(Localization.algEquiv M S).symm (IsLocalization.mk' S x y) = Localization.mk x y |
String.ofList._proof_1 | Init.Prelude | ∀ (data : List Char), data.utf8Encode.IsValidUTF8 |
CategoryTheory.Limits.biprod.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(X X_1 : C) (e_X : X = X_1) (Y Y_1 : C) (e_Y : Y = Y_1) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
(X ⊞ Y) = (X_1 ⊞ Y_1) |
Std.Time.FormatType | Std.Time.Format.Basic | Type → Std.Time.FormatString → Type |
_private.Mathlib.RingTheory.MvPowerSeries.Trunc.0.MvPowerSeries.coeff_trunc'_mul_trunc'_eq_coeff_mul._proof_1_1 | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} [inst : DecidableEq σ] (n : σ →₀ ℕ) ⦃a b : σ →₀ ℕ⦄, b ≤ a → a ∈ ↑(Finset.Iic n) → b ∈ ↑(Finset.Iic n) |
IsIntegrallyClosed.of_iInf_eq_bot | Mathlib.RingTheory.LocalProperties.IntegrallyClosed | ∀ {R : Type u_1} {K : Type u_2} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{ι : Type u_3} (S : ι → Subalgebra R K), (∀ (i : ι), IsIntegrallyClosed ↥(S i)) → ⨅ i, S i = ⊥ → IsIntegrallyClosed R |
_private.Lean.Message.0.Lean.MessageData.hasSyntheticSorry.visit._sparseCasesOn_1 | Lean.Message | {motive_1 : Lean.MessageData → Sort u} →
(t : Lean.MessageData) →
((f : Option Lean.PPContext → BaseIO Dynamic) →
(hasSyntheticSorry : Lean.MetavarContext → Bool) → motive_1 (Lean.MessageData.ofLazy f hasSyntheticSorry)) →
((a : Lean.MessageDataContext) → (a_1 : Lean.MessageData) → motive_1 (Lean.MessageData.withContext a a_1)) →
((a : Lean.NamingContext) → (a_1 : Lean.MessageData) → motive_1 (Lean.MessageData.withNamingContext a a_1)) →
((a : ℕ) → (a_1 : Lean.MessageData) → motive_1 (Lean.MessageData.nest a a_1)) →
((a : Lean.MessageData) → motive_1 a.group) →
((a a_1 : Lean.MessageData) → motive_1 (a.compose a_1)) →
((a : Lean.Name) → (a_1 : Lean.MessageData) → motive_1 (Lean.MessageData.tagged a a_1)) →
((data : Lean.TraceData) →
(msg : Lean.MessageData) →
(children : Array Lean.MessageData) → motive_1 (Lean.MessageData.trace data msg children)) →
(Nat.hasNotBit 2040 t.ctorIdx → motive_1 t) → motive_1 t |
conjneg_ne_zero | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 0 ↔ f ≠ 0 |
_private.Lean.Elab.Print.0.Lean.Elab.Command.printStructure._sparseCasesOn_3 | Lean.Elab.Print | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t |
Lean.Elab.FieldRedeclInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.FieldRedeclInfo → Sort u} →
(t : Lean.Elab.FieldRedeclInfo) → ((stx : Lean.Syntax) → motive { stx := stx }) → motive t |
Multiset.disjoint_finset_sum_left | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {α : Type u_6} {i : Finset ι} {f : ι → Multiset α} {a : Multiset α},
Disjoint (i.sum f) a ↔ ∀ b ∈ i, Disjoint (f b) a |
Finsupp.mem_range_mapDomain_iff | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (f : α → β),
Function.Injective f → ∀ (x : β →₀ M), x ∈ Set.range (Finsupp.mapDomain f) ↔ ∀ b ∉ Set.range f, x b = 0 |
_private.Lean.Elab.PreDefinition.Main.0.Lean.Elab.isNonRecursive | Lean.Elab.PreDefinition.Main | Lean.Elab.PreDefinition → Bool |
Std.Time.DateTime.ofPlainDateTimeAssumingUTC | Std.Time.Zoned.DateTime | Std.Time.PlainDateTime → (tz : Std.Time.TimeZone) → Std.Time.DateTime tz |
Turing.ToPartrec.instDecidableEqCode | Mathlib.Computability.TMConfig | DecidableEq Turing.ToPartrec.Code |
CompactlyCoherentSpace.casesOn | Mathlib.Topology.Compactness.CompactlyCoherentSpace | {X : Type u_1} →
[inst : TopologicalSpace X] →
{motive : CompactlyCoherentSpace X → Sort u} →
(t : CompactlyCoherentSpace X) →
((isCoherentWith : Topology.IsCoherentWith {K | IsCompact K}) → motive ⋯) → motive t |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.snd_ne_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, 3 ≤ p.length → 1 ≤ p.length |
Real.sigmoid_pos | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 < x.sigmoid |
_private.Mathlib.Algebra.Category.MonCat.Basic.0.AddCommMonCat.Hom.mk.noConfusion | Mathlib.Algebra.Category.MonCat.Basic | {A B : AddCommMonCat} →
{P : Sort u_1} → {hom' hom'' : ↑A →+ ↑B} → { hom' := hom' } = { hom' := hom'' } → (hom' ≍ hom'' → P) → P |
_private.Init.Data.List.Nat.Sublist.0.List.append_sublist_of_sublist_right._proof_1_1 | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys zs : List α}, zs.length ≤ ys.length → xs.length + ys.length ≤ zs.length → ¬xs.length = 0 → False |
Module.AEval.restrict_equiv_mapSubmodule._proof_3 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), IsScalarTower R R ↥p |
Mathlib.Meta.NormNum.IsNNRat.to_eq | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : DivisionSemiring α] {n d : ℕ} {a n' d' : α},
Mathlib.Meta.NormNum.IsNNRat a n d → ↑n = n' → ↑d = d' → a = n' / d' |
Lean.Meta.Grind.instInhabitedEMatchTheoremConstraint | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheoremConstraint |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Nerve.0.CategoryTheory.nerve.δ₂_two._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ¬0 ≤ 1 → False |
Lean.Server.Test.Runner.Client.MsgEmbed.casesOn | Lean.Server.Test.Runner | {motive_1 : Lean.Server.Test.Runner.Client.MsgEmbed → Sort u} →
(t : Lean.Server.Test.Runner.Client.MsgEmbed) →
((a : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.SubexprInfo) →
motive_1 (Lean.Server.Test.Runner.Client.MsgEmbed.expr a)) →
((a : Lean.Server.Test.Runner.Client.InteractiveGoal) →
motive_1 (Lean.Server.Test.Runner.Client.MsgEmbed.goal a)) →
((wi : Lean.Server.Test.Runner.Client.WidgetInstance) →
(alt : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) →
motive_1 (Lean.Server.Test.Runner.Client.MsgEmbed.widget wi alt)) →
((indent : ℕ) →
(cls : Lean.Name) →
(msg : Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed) →
(collapsed : Bool) →
(children :
Lean.Server.Test.Runner.Client.StrictOrLazy
(Array (Lean.Widget.TaggedText Lean.Server.Test.Runner.Client.MsgEmbed)) Lean.Lsp.RpcRef) →
motive_1 (Lean.Server.Test.Runner.Client.MsgEmbed.trace indent cls msg collapsed children)) →
motive_1 t |
_private.Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound.0.Std.Tactic.BVDecide.LRAT.Internal.addEmptyCaseSound._proof_1_3 | Std.Tactic.BVDecide.LRAT.Internal.LRATCheckerSound | ∀ {α : Type u_2} {β : Type u_1} {σ : Type u_3} [inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β]
[inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ] [inst_2 : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(f : σ),
Std.Tactic.BVDecide.LRAT.Internal.Clause.empty ∈
Std.Tactic.BVDecide.LRAT.Internal.Formula.toList
(Std.Tactic.BVDecide.LRAT.Internal.Formula.insert f Std.Tactic.BVDecide.LRAT.Internal.Clause.empty) |
Localization.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] (S : Submonoid M), Localization S = OreLocalization S M |
Std.TreeMap.Raw.instCoeWFWFInner | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {t : Std.TreeMap.Raw α β cmp} → Coe t.WF t.inner.WF |
NNReal.iSup_div | Mathlib.Data.NNReal.Basic | ∀ {ι : Sort u_2} (f : ι → NNReal) (a : NNReal), (⨆ i, f i) / a = ⨆ i, f i / a |
List.dropWhile_eq_self_iff | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.dropWhile p l = l ↔ ∀ (hl : 0 < l.length), ¬p l[0] = true |
map_mem_separableClosure_iff | Mathlib.FieldTheory.SeparableClosure | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type w} [inst_3 : Field K]
[inst_4 : Algebra F K] (i : E →ₐ[F] K) {x : E}, i x ∈ separableClosure F K ↔ x ∈ separableClosure F E |
UInt32.toBitVec_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt32), n.toUInt8.toBitVec = BitVec.setWidth 8 n.toBitVec |
Aesop.PostponedSafeRule.mk._flat_ctor | Aesop.Tree.UnsafeQueue | Aesop.SafeRule → Aesop.RuleTacOutput → Aesop.PostponedSafeRule |
AddGroupSeminorm.toSeminormedAddGroup._proof_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : AddGroup E] (f : AddGroupSeminorm E) (x : E), f (-x + x) = 0 |
CategoryTheory.instHasLimitsInd | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimits C],
CategoryTheory.Limits.HasLimits (CategoryTheory.Ind C) |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_450 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
¬[g a, g (g a)].Nodup →
∀ (w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.findIdxNth (fun x => decide (x = w_1)) [g a, g (g a)] {g a, g (g a)}.card <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length |
Nat.choose_lt_pow | Mathlib.Data.Nat.Choose.Bounds | ∀ {n k : ℕ}, n ≠ 0 → 2 ≤ k → n.choose k < n ^ k |
String.Slice.SplitIterator.instIteratorIdSubslice.eq_1 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice},
String.Slice.SplitIterator.instIteratorIdSubslice =
{
IsPlausibleStep := fun x x_1 =>
match x, x_1 with
| { internalState := String.Slice.SplitIterator.operating currPos s_1 },
Std.IterStep.yield { internalState := String.Slice.SplitIterator.operating currPos_1 s' } out =>
s'.IsPlausibleSuccessorOf s_1
| { internalState := String.Slice.SplitIterator.operating currPos s_1 },
Std.IterStep.yield { internalState := String.Slice.SplitIterator.atEnd } out => True
| { internalState := String.Slice.SplitIterator.operating currPos s_1 },
Std.IterStep.skip { internalState := String.Slice.SplitIterator.operating currPos_1 s' } =>
s'.IsPlausibleSuccessorOf s_1
| { internalState := String.Slice.SplitIterator.operating currPos s },
Std.IterStep.skip { internalState := String.Slice.SplitIterator.atEnd } => False
| { internalState := String.Slice.SplitIterator.operating currPos s }, Std.IterStep.done => True
| { internalState := String.Slice.SplitIterator.atEnd }, Std.IterStep.yield it out => False
| { internalState := String.Slice.SplitIterator.atEnd }, Std.IterStep.skip it => False
| { internalState := String.Slice.SplitIterator.atEnd }, Std.IterStep.done => True,
step := fun x =>
match x with
| { internalState := String.Slice.SplitIterator.operating currPos searcher } =>
match h : searcher.step with
| ⟨Std.IterStep.yield searcher' (String.Slice.Pattern.SearchStep.matched startPos endPos), hps⟩ =>
have slice := s.subslice! currPos startPos;
let nextIt := { internalState := String.Slice.SplitIterator.operating endPos searcher' };
pure (Std.Shrink.deflate ⟨Std.IterStep.yield nextIt slice, ⋯⟩)
| ⟨Std.IterStep.yield searcher' (String.Slice.Pattern.SearchStep.rejected startPos endPos), hps⟩ =>
pure
(Std.Shrink.deflate
⟨Std.IterStep.skip { internalState := String.Slice.SplitIterator.operating currPos searcher' }, ⋯⟩)
| ⟨Std.IterStep.skip searcher', hps⟩ =>
pure
(Std.Shrink.deflate
⟨Std.IterStep.skip { internalState := String.Slice.SplitIterator.operating currPos searcher' }, ⋯⟩)
| ⟨Std.IterStep.done, property⟩ =>
have slice := s.subsliceFrom currPos;
pure
(Std.Shrink.deflate ⟨Std.IterStep.yield { internalState := String.Slice.SplitIterator.atEnd } slice, ⋯⟩)
| { internalState := String.Slice.SplitIterator.atEnd } => pure (Std.Shrink.deflate ⟨Std.IterStep.done, ⋯⟩) } |
BitVec.forall_zero_iff | Init.Data.BitVec.Decidable | ∀ {P : BitVec 0 → Prop}, (∀ (v : BitVec 0), P v) ↔ P 0#0 |
_private.Mathlib.Topology.DiscreteSubset.0.isClosed_and_discrete_iff._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) |
Subspace.orderIsoFiniteCodimDim._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : { W // FiniteDimensional K ↥W }ᵒᵈ), FiniteDimensional K (V ⧸ Submodule.dualCoannihilator ↑(OrderDual.ofDual W)) |
Lean.Compiler.LCNF.instBEqParam.beq | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Param pu → Lean.Compiler.LCNF.Param pu → Bool |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel.aux1.eq_1 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u} (l : List (Computation α)) (S : Stream'.WSeq (Computation α)),
Computation.parallel.aux1✝ (l, S) =
Computation.rmap
(fun l' =>
match Stream'.Seq.destruct S with
| none => (l', Stream'.Seq.nil)
| some (none, S') => (l', S')
| some (some c, S') => (c :: l', S'))
(Computation.parallel.aux2✝ l) |
ULift.seminormedRing | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_2} → [SeminormedRing α] → SeminormedRing (ULift.{u_5, u_2} α) |
TensorProduct.AlgebraTensorModule.congr_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMonoid P]
[inst_10 : Module R P] [inst_11 : Module A P] [inst_12 : IsScalarTower R A P] [inst_13 : AddCommMonoid Q]
[inst_14 : Module R Q] (f : M ≃ₗ[A] P) (g : N ≃ₗ[R] Q) (p : P) (q : Q),
(TensorProduct.AlgebraTensorModule.congr f g).symm (p ⊗ₜ[R] q) = f.symm p ⊗ₜ[R] g.symm q |
_private.Mathlib.RingTheory.QuasiFinite.Basic.0.Algebra.QuasiFinite.of_isIntegral_of_finiteType._simp_1_2 | Mathlib.RingTheory.QuasiFinite.Basic | ∀ (R : Type u) (S : Type v) (A : Type w) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [IsScalarTower R S A] (x : R),
(algebraMap S A) ((algebraMap R S) x) = (algebraMap R A) x |
CategoryTheory.Triangulated.SpectralObject.recOn | 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] →
{motive : CategoryTheory.Triangulated.SpectralObject C ι → Sort u} →
(t : CategoryTheory.Triangulated.SpectralObject C ι) →
((ω₁ : CategoryTheory.Functor (CategoryTheory.ComposableArrows ι 1) C) →
(δ' :
(CategoryTheory.ComposableArrows.functorArrows ι 1 2 2
CategoryTheory.Triangulated.SpectralObject._proof_2
CategoryTheory.Triangulated.SpectralObject._proof_4).comp
ω₁ ⟶
(CategoryTheory.ComposableArrows.functorArrows ι 0 1 2
CategoryTheory.Triangulated.SpectralObject._proof_6
CategoryTheory.Triangulated.SpectralObject._proof_2).comp
(ω₁.comp (CategoryTheory.shiftFunctor C 1))) →
(distinguished' :
∀ (D : CategoryTheory.ComposableArrows ι 2),
CategoryTheory.Pretriangulated.Triangle.mk
(ω₁.map
((CategoryTheory.ComposableArrows.mapFunctorArrows ι 0 1 0 2 2
CategoryTheory.Triangulated.SpectralObject._proof_6
CategoryTheory.Triangulated.SpectralObject._proof_8
CategoryTheory.Triangulated.SpectralObject._proof_10
CategoryTheory.Triangulated.SpectralObject._proof_2
CategoryTheory.Triangulated.SpectralObject._proof_4).app
D))
(ω₁.map
((CategoryTheory.ComposableArrows.mapFunctorArrows ι 0 2 1 2 2
CategoryTheory.Triangulated.SpectralObject._proof_8
CategoryTheory.Triangulated.SpectralObject._proof_2
CategoryTheory.Triangulated.SpectralObject._proof_6
CategoryTheory.Triangulated.SpectralObject._proof_4
CategoryTheory.Triangulated.SpectralObject._proof_4).app
D))
(δ'.app D) ∈
CategoryTheory.Pretriangulated.distinguishedTriangles) →
motive { ω₁ := ω₁, δ' := δ', distinguished' := distinguished' }) →
motive t |
List.min?_eq_none_iff._simp_1 | Init.Data.List.MinMax | ∀ {α : Type u_1} {xs : List α} [inst : Min α], (xs.min? = none) = (xs = []) |
_private.Mathlib.Order.Cover.0.WithTop.coe_wcovBy_top._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Ioo ↑a ⊤ = WithTop.some '' Set.Ioi a |
Std.DTreeMap.Internal.Impl.balanceLErase._proof_14 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner rs k v l r).Balanced →
∀ (ls : ℕ) (lk : α) (lv : β lk),
Std.DTreeMap.Internal.delta * rs < ls →
∀ (x : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size →
False |
_private.Mathlib.LinearAlgebra.Prod.0.Submodule.map_inl._simp_1_7 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_8}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {p : Submodule R M} {q : Submodule R M'} {x : M × M'},
(x ∈ p.prod q) = (x.1 ∈ p ∧ x.2 ∈ q) |
AddMonoidHom.ext_nat | Mathlib.Algebra.Group.Nat.Hom | ∀ {A : Type u_2} [inst : AddZeroClass A] {f g : ℕ →+ A}, f 1 = g 1 → f = g |
_private.Mathlib.Data.Option.Basic.0.Option.iget_of_mem.match_1_1 | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {a : α} (motive : (x : Option α) → a ∈ x → Prop) (x : Option α) (x_1 : a ∈ x),
(∀ (a_1 : Unit), motive (some a) ⋯) → motive x x_1 |
Complex.measurableEquivRealProd | Mathlib.MeasureTheory.Measure.Lebesgue.Complex | ℂ ≃ᵐ ℝ × ℝ |
Polynomial.divModByMonicAux.congr_simp | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (_p _p_1 : Polynomial R),
_p = _p_1 → ∀ {q q_1 : Polynomial R} (e_q : q = q_1) (a : q.Monic), _p.divModByMonicAux a = _p_1.divModByMonicAux ⋯ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.