name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_succ_left_deg._simp_1_13 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | null | false |
Unitization.nonneg_of_inr._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.inv_naturality | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
{U V : (TopologicalSpace.Opens ↑X.toTopCat)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (X.presheaf.map i)
(AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.invApp f (Opposite.uno... | null | true |
_private.Mathlib.Data.Set.Finite.Lemmas.0.Set.exists_max_image.match_1_1 | Mathlib.Data.Set.Finite.Lemmas | ∀ {α : Type u_1} (s : Set α) (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (x : α) (hx : x ∈ s), motive ⋯) → motive x | null | false |
_private.Mathlib.Basic.Complex.Basic.0.Complex.eta.match_1_1 | Mathlib.Basic.Complex.Basic | ∀ (motive : ℂ → Prop) (x : ℂ), (∀ (re im : ℝ), motive { re := re, im := im }) → motive x | null | false |
LightCondensed.freeForgetAdjunction | Mathlib.Condensed.Light.Module | (R : Type u) → [inst : Ring R] → LightCondensed.free R ⊣ LightCondensed.forget R | The condensed version of the free-forgetful adjunction. | true |
Std.ExtDHashMap.contains_of_contains_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → (k == a) = false → m.contains a = true | null | true |
VonNeumannAlgebra.zero_mem'._inherited_default | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} {inst_2 : CompleteSpace H}
(carrier : Set (H →L[ℂ] H)), (∀ (r : ℂ), (algebraMap ℂ (H →L[ℂ] H)) r ∈ carrier) → 0 ∈ carrier | null | false |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.isNat.natElim.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {p : ℕ → Prop} (motive : (x x_1 : ℕ) → Mathlib.Meta.NormNum.IsNat x x_1 → p x_1 → Prop) (x x_1 : ℕ)
(x_2 : Mathlib.Meta.NormNum.IsNat x x_1) (x_3 : p x_1),
(∀ (n : ℕ) (h : p n), motive (↑n) n ⋯ h) → motive x x_1 x_2 x_3 | null | false |
DirectSum.lid | Mathlib.Algebra.DirectSum.Module | (R : Type u) →
[inst : Semiring R] →
(M : Type v) →
(ι : optParam (Type u_1) PUnit.{u_1 + 1}) →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → [Unique ι] → (DirectSum ι fun x => M) ≃ₗ[R] M | The natural linear equivalence between `⨁ _ : ι, M` and `M` when `Unique ι`. | true |
Array.back.congr_simp | Init.Data.List.ToArray | ∀ {α : Type u} (xs xs_1 : Array α) (e_xs : xs = xs_1) (h : 0 < xs.size), xs.back h = xs_1.back ⋯ | null | true |
Lean.IR.Alt.brecOn | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
{motive_2 : Lean.IR.FnBody → Sort u} →
{motive_3 : Array Lean.IR.Alt → Sort u} →
{motive_4 : List Lean.IR.Alt → Sort u} →
(t : Lean.IR.Alt) →
((t : Lean.IR.Alt) → t.below → motive_1 t) →
((t : Lean.IR.FnBody) → t.below → motive_2 t) →
... | null | false |
AddOpposite.instNeg.eq_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Neg α], AddOpposite.instNeg = { neg := fun x => AddOpposite.op (-AddOpposite.unop x) } | null | true |
Std.Internal.List.Const.getKeyD_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [inst_1 : EquivBEq α] {β : Type v} {f : α → β → Bool} {l : List ((_ : α) × β)}
{k fallback : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getKey? k l).pfilter fun x h => f x (Std.Int... | null | true |
Sum.swap_rightInverse | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v}, Function.RightInverse Sum.swap Sum.swap | null | true |
_private.Batteries.Recycling.MonadSatisfying.Basic.0.SatisfiesM_ExceptT_eq.match_1_16 | Batteries.Recycling.MonadSatisfying.Basic | ∀ {α ρ : Type u_1} {p : α → Prop} (motive : { a // ∀ (a_1 : α), a = Except.ok a_1 → p a_1 } → Prop)
(h : { a // ∀ (a_1 : α), a = Except.ok a_1 → p a_1 }),
(∀ (a : Except ρ α) (h : ∀ (a_1 : α), a = Except.ok a_1 → p a_1), motive ⟨a, h⟩) → motive h | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.forIn_filterMapWithPostcondition.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β₂ : Type u_1} (motive : Option β₂ → Sort u_2) (h_1 : (c : β₂) → motive (some c)) (h_2 : Unit → motive none),
(match none with
| some c => h_1 c
| none => h_2 ()) =
h_2 () | null | true |
ContinuousLinearEquiv.conjContinuousAlgEquiv_apply_apply | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {𝕜 : Type u_1} {G : Type u_4} {H : Type u_5} [inst : AddCommGroup G] [inst_1 : AddCommGroup H]
[inst_2 : NormedField 𝕜] [inst_3 : Module 𝕜 G] [inst_4 : Module 𝕜 H] [inst_5 : TopologicalSpace G]
[inst_6 : TopologicalSpace H] [inst_7 : IsTopologicalAddGroup G] [inst_8 : IsTopologicalAddGroup H]
[inst_9 : Cont... | null | true |
semicontinuous_restrict_iff._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {r : α → β → Prop} {s : Set α},
Semicontinuous (s.domRestrict r) = SemicontinuousOn r s | null | false |
FreeAddMonoid.toList.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, FreeAddMonoid.toList = Equiv.refl (FreeAddMonoid α) | null | true |
Complex.UnitClosedDisc.instMonoidWithZero._proof_11 | Mathlib.Analysis.Complex.UnitDisc.Basic | autoParam (∀ (n : ℕ) (x : Complex.UnitClosedDisc), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._autoParam | null | false |
Lean.Lsp.Command.recOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.Command → Sort u} →
(t : Lean.Lsp.Command) →
((title command : String) →
(arguments? : Option (Array Lean.Json)) →
motive { title := title, command := command, arguments? := arguments? }) →
motive t | null | false |
AlgebraicGeometry.Scheme.Modules.Hom.isIso_iff_isIso_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M N : X.Modules} {φ : M ⟶ N},
CategoryTheory.IsIso φ ↔ ∀ (U : X.Opens), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Modules.Hom.app φ U) | null | true |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.pathToStx.match_3 | Mathlib.Tactic.Widget.Conv | (motive : Mathlib.Tactic.Conv.Path → Sort u_1) →
(path : Mathlib.Tactic.Conv.Path) →
((arg : ℕ) →
(all : Bool) → (next : Mathlib.Tactic.Conv.Path) → motive (Mathlib.Tactic.Conv.Path.arg arg all next)) →
((next : Mathlib.Tactic.Conv.Path) → motive next.type) →
((name : Lean.Name) → (next : Ma... | null | false |
Nat.binaryRec'._proof_1 | Mathlib.Data.Nat.BinaryRec | ∀ {motive : ℕ → Sort u_1} (b : Bool) (n : ℕ) (ih : motive n), ¬(n = 0 → b = true) → Nat.bit b n = 0 | null | false |
PrincipalSeg.ordinal_type_lt | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s]
(h : PrincipalSeg r s), Ordinal.type r < Ordinal.type s | null | true |
Mathlib.Tactic.Abel.AbelNF.Config.mk._flat_ctor | Mathlib.Tactic.Abel | Lean.Meta.TransparencyMode → Bool → Bool → Mathlib.Tactic.Abel.AbelMode → Mathlib.Tactic.Abel.AbelNF.Config | null | false |
Mathlib.Tactic.ITauto.IProp.and'.noConfusion | Mathlib.Tactic.ITauto | {P : Sort u} →
{a : Mathlib.Tactic.ITauto.AndKind} →
{a_1 a_2 : Mathlib.Tactic.ITauto.IProp} →
{a' : Mathlib.Tactic.ITauto.AndKind} →
{a'_1 a'_2 : Mathlib.Tactic.ITauto.IProp} →
Mathlib.Tactic.ITauto.IProp.and' a a_1 a_2 = Mathlib.Tactic.ITauto.IProp.and' a' a'_1 a'_2 →
(a = a'... | null | false |
AlgebraicGeometry.Scheme.LocalRepresentability.glueData._proof_14 | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u_1)} {ι : Type u_1}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.obj}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) (i j k : ι),
CategoryTheory.CategoryStruct.comp
(⋯.lif... | null | false |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_1 | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorems → ℕ | null | false |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.matiyasevic.match_1_5 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a k x y : ℕ}
(motive :
(x = 1 ∧ y = 0 ∨
∃ u v s t b,
x * x - (a * a - 1) * y * y = 1 ∧
u * u - (a * a - 1) * v * v = 1 ∧
s * s - (b * b - 1) * t * t = 1 ∧
1 < b ∧ b ≡ 1 [MOD 4 * y] ∧ b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y... | null | false |
Affine.Simplex.instFintypePointsWithCircumcenterIndex.match_3 | Mathlib.Geometry.Euclidean.Circumcenter | (n : ℕ) →
(motive : Fin (n + 1) ⊕ Unit → Sort u_1) →
(x : Fin (n + 1) ⊕ Unit) →
((a : Fin (n + 1)) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x | null | false |
String.Slice.skipSuffix?_prop_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.Pred | ∀ {P : Char → Prop} [inst : DecidablePred P] {s : String.Slice} {pos : s.Pos},
s.skipSuffix? P = some pos ↔ ∃ (h : s.endPos ≠ s.startPos), pos = s.endPos.prev h ∧ P ((s.endPos.prev h).get ⋯) | null | true |
Submodule.annihilator | Mathlib.RingTheory.Ideal.Maps | {R : Type u_1} →
{M : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Submodule R M → Ideal R | `N.annihilator` is the ideal of all elements `r : R` such that `r • N = 0`. | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.stableUnderSpecialization_singleton._simp_1_5 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
WellFoundedLT.finite_of_iSupIndep | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_4} [inst : CompleteLattice α] [WellFoundedLT α] {ι : Type u_5} {t : ι → α},
iSupIndep t → (∀ (i : ι), t i ≠ ⊥) → Finite ι | null | true |
Std.Http.Header.Expect.parse | Std.Http.Data.Headers.Basic | Std.Http.Header.Value → Option Std.Http.Header.Expect | Parses an `Expect` header.
Succeeds only if the value is exactly `100-continue`
(case-insensitive, trimmed).
| true |
summable_star_iff' | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
[inst_2 : StarAddMonoid α] [ContinuousStar α] {f : β → α}, Summable (star f) L ↔ Summable f L | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCofiber.0.HomologicalComplex.homotopyCofiber.descSigma_ext_iff._simp_1_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) | null | false |
Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq | Lean.Meta.Tactic.Grind.Extension | ℕ → Lean.Meta.Grind.CnstrRHS → Lean.Meta.Grind.EMatchTheoremConstraint | A constraint of the form `lhs =/= rhs`.
The `lhs` is one of the bound variables, and the `rhs` an abstract term that must not be definitionally
equal to a term `t` assigned to `lhs`. | true |
LowerSet.coe_div._simp_2 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s t : LowerSet α),
↑s / ↑t = ↑(s / t) | null | false |
pinGroup.star_mul_self | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(pinGroup Q)), star x * x = 1 | null | true |
Lean.Grind.CommRing.instReprMon.repr._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → ℕ → Std.Format | null | false |
IsCyclotomicExtension.Rat.p_mem_span_zeta_sub_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
↑p ∈ Ideal.span {hζ.toInteger - 1} | null | true |
Bernoulli.not_sq_dvd_den_bernoulli | Mathlib.NumberTheory.Bernoulli | ∀ {k p : ℕ} [Fact (Nat.Prime p)], 0 < k → p - 1 ∣ 2 * k → ¬p ^ 2 ∣ (bernoulli (2 * k)).den | If `p` is prime, `0 < k`, and `p - 1 ∣ 2 * k`, then `p ^ 2` does not divide the denominator of
the Bernoulli number `B₂ₖ`: each prime occurs in the denominator with multiplicity one. | true |
AddSubgroup.coe_pathComponentZero | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
↑(AddSubgroup.pathComponentZero G) = pathComponent 0 | null | true |
spectrum.spectralRadius_le_liminf_pow_nnnorm_pow_one_div | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
[CompleteSpace A] (a : A), spectralRadius 𝕜 a ≤ Filter.liminf (fun n => ↑‖a ^ n‖₊ ^ (1 / ↑n)) Filter.atTop | null | true |
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod_symm_apply._proof_1 | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {p : ℕ} [Fact (Nat.Prime p)], Ideal.span {↑p} ≠ ⊥ | null | false |
CategoryTheory.BraidedCategory.ofCartesianMonoidalCategory._proof_10 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom
(CategoryTheory.CategoryStruct.comp
{
hom :=
Categ... | null | false |
LatticeHom.snd | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) β | Natural projection homomorphism from `α × β` to `β`. | true |
Lean.Linter.MissingDocs.mkHandler | Lean.Linter.MissingDocs | Lean.Name → Lean.ImportM Lean.Linter.MissingDocs.Handler | null | true |
CategoryTheory.ComposableArrows.isoMk₅._proof_14 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_453✝ ≅ g.obj' 0 _proof_453✝) (app₁ : f.obj' 1 _proof_454✝ ≅ g.obj' 1 _proof_454✝)
(app₂ : f.obj' 2 _proof_455✝ ≅ g.obj' 2 _proof_455✝) (app₃ : f.obj' 3 _proof_456✝ ≅ g.obj' 3 _proof_456... | null | false |
SimpleGraph.Coloring.sumEquiv | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_3} →
{W : Type u_5} →
{γ : Type u_7} → {G : SimpleGraph V} → {H : SimpleGraph W} → (G ⊕g H).Coloring γ ≃ G.Coloring γ × H.Coloring γ | Bijection between `(G ⊕g H).Coloring γ` and `G.Coloring γ × H.Coloring γ` | true |
Std.Net.AddressFamily.ipv4.sizeOf_spec | Std.Net.Addr | sizeOf Std.Net.AddressFamily.ipv4 = 1 | null | true |
Lake.ToolchainVer.toString | Lake.Util.Version | Lake.ToolchainVer → String | null | true |
Std.IterM.toArray_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Option γ} (it : Std.IterM m β),
(Std.IterM.filterMap f it).toArray = (fun x => Array.filterMap f x) <$> it.toArray | null | true |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.match_1.eq_2 | Lean.Data.Iterators.Producers.PersistentHashMap | ∀ {α : Type u_1} {β : Type u_2} (motive : Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β) → Sort u_3)
(key : α) (val : β)
(h_1 :
Lean.PersistentHashMap.Entry.entry key val = Lean.PersistentHashMap.Entry.null →
motive Lean.PersistentHashMap.Entry.null)
(h_2 :
(key_1 : α) →
(v... | null | true |
Rep.indResHomEquiv._proof_8 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} {G : Type u_4} {H : Type u_2} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{max u_3 u_2 u_1, u_1, u_4} k G) (B : Rep.{max u_3 u_2 u_1, u_1, u_2} k H) (x x_1 : Rep.ind φ A ⟶ B),
Rep.ofHom
{ toLinearMap := (Rep.Hom.hom (x + x_1)).toLinearMap ∘ₗ Representation.... | null | false |
Nat.nonempty_of_pos_sInf | Mathlib.Order.Lattice.Nat | ∀ {s : Set ℕ}, 0 < sInf s → s.Nonempty | null | true |
Subtype.mk_eq_bot_iff | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : OrderBot (Subtype p)],
p ⊥ → ∀ {x : α} (hx : p x), ⟨x, hx⟩ = ⊥ ↔ x = ⊥ | null | true |
AlgebraicGeometry.PresheafedSpace.restrict_presheaf | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {U : TopCat} (X : AlgebraicGeometry.PresheafedSpace C)
{f : U ⟶ ↑X} (h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
(X.restrict h).presheaf = h.functor.op.comp X.presheaf | null | true |
IsLocalRing.finrank_cotangentSpace_eq_zero_iff | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] [IsNoetherianRing R],
Module.finrank (IsLocalRing.ResidueField R) (IsLocalRing.CotangentSpace R) = 0 ↔ IsField R | null | true |
String.Slice.Pos.offset_str_le_offset_endExclusive | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, pos.str.offset ≤ s.endExclusive.offset | null | true |
Std.TreeMap.minKey?_eq_some_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.minKey? = some t.minKey! | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.base | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | {pat s : String.Slice} →
{needlePos stackPos : String.Pos.Raw} →
String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants✝ pat s needlePos stackPos → s.Pos | The start of the window, as a valid position in `s.` | true |
ENNReal.tsum_biUnion_le | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {ι : Type u_4} (f : α → ENNReal) (s : Finset ι) (t : ι → Set α),
∑' (x : ↑(⋃ i ∈ s, t i)), f ↑x ≤ ∑ i ∈ s, ∑' (x : ↑(t i)), f ↑x | null | true |
ProfiniteAddGrp.proj._proof_6 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ {P : ProfiniteAddGrp.{u_1}} (U : OpenNormalAddSubgroup ↑P.toProfinite.toTop) (x x_1 : ↑P.toProfinite.1),
↑(x + x_1) = ↑(x + x_1) | null | false |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Three.0.IsCyclotomicExtension.Rat.Three.lambda_dvd_or_dvd_sub_one_or_dvd_add_one._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | null | false |
Matrix.GeneralLinearGroup.val_transvection | Mathlib.LinearAlgebra.Matrix.ElementaryRowOperations | ∀ {R : Type u_1} {m : Type u_2} [inst : DecidableEq m] [inst_1 : CommRing R] [inst_2 : Fintype m] (i j : m) (h : i ≠ j)
(c : R), ↑(Matrix.GeneralLinearGroup.transvection i j h c) = Matrix.transvection i j c | null | true |
TensorPower.gmonoid._proof_3 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : GradedMonoid fun i => TensorPower R i M), 1 * x = x | null | false |
AddMonoid.End.mulRight | Mathlib.Algebra.Ring.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocSemiring R] → R →+ AddMonoid.End R | The right multiplication map: `(a, b) ↦ b * a`. See also `AddMonoidHom.mulRight`. | true |
TensorProduct.assoc_tensor' | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_4} {N : Type u_5} {Q : Type u_7} {S : Type u_8}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid Q] [inst_4 : AddCommMonoid S]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R Q] [inst_8 : Module R S],
TensorProduct.as... | null | true |
Std.TreeMap.Raw.insertMany_cons | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {l : List (α × β)} {k : α} {v : β},
t.insertMany ((k, v) :: l) = (t.insert k v).insertMany l | null | true |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic.cancelDenominatorsTarget | Mathlib.Tactic.CancelDenoms.Core | Lean.Elab.Tactic.TacticM Unit | null | true |
MvQPF.Fix.ind | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (p : MvQPF.Fix F α → Prop),
(∀ (x : F (α ::: MvQPF.Fix F α)), MvFunctor.LiftP (α.PredLast p) x → p (MvQPF.Fix.mk x)) → ∀ (x : MvQPF.Fix F α), p x | null | true |
Fin.val_addNat | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (m : ℕ) (i : Fin n), ↑(i.addNat m) = ↑i + m | null | true |
HasProd.nat_mul_neg_add_one | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] {m : M} {f : ℤ → M},
HasProd f m → HasProd (fun n => f ↑n * f (-(↑n + 1))) m | null | true |
IsOpenMap.domRestrict | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsOpenMap f → ∀ {s : Set X}, IsOpen s → IsOpenMap (s.domRestrict f) | null | true |
Int.Internal.Linear.norm_dvd_gcd_cert.eq_1 | Init.Data.Int.Linear | ∀ (k₁ : ℤ) (e₁ : Int.Internal.Linear.Expr) (k₂ : ℤ) (p₂ : Int.Internal.Linear.Poly) (k : ℤ),
Int.Internal.Linear.norm_dvd_gcd_cert k₁ e₁ k₂ p₂ k = Int.Internal.Linear.dvd_coeff_cert k₁ e₁.norm k₂ p₂ k | null | true |
dvd_of_mul_right_eq | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α} (c : α), a * c = b → a ∣ b | **Alias** of `Dvd.intro`. | true |
one_le_pow_mul_abs_eval_div | Mathlib.Algebra.Polynomial.DenomsClearable | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {f : Polynomial ℤ} {a b : ℤ},
0 < b →
Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f) ≠ 0 →
1 ≤ ↑b ^ f.natDegree * |Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f)| | Evaluating a polynomial with integer coefficients at a rational number and clearing
denominators, yields a number greater than or equal to one. The target can be any
`LinearOrderedField K`.
The assumption on `K` could be weakened to `LinearOrderedCommRing` assuming that the
image of the denominator is invertible in `K... | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_add_top_coe._simp_1_2 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (x y : ℝ), ↑x + ↑y = ↑(x + y) | null | false |
Std.DHashMap.Internal.AssocList.map | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} → ((a : α) → β a → γ a) → Std.DHashMap.Internal.AssocList α β → Std.DHashMap.Internal.AssocList α γ | Internal implementation detail of the hash map | true |
Matroid.IsCircuit | Mathlib.Combinatorics.Matroid.Circuit | {α : Type u_1} → Matroid α → Set α → Prop | `M.IsCircuit C` means that `C` is a minimal dependent set in `M`. | true |
Submodule.IsMinimalPrimaryDecomposition.mem_associatedPrimes | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {t : Finset (Submodule R M)},
N.IsMinimalPrimaryDecomposition t → ∀ {q : Submodule R M}, q ∈ t → (q.colon Set.univ).radical ∈ N.associatedPrimes | null | true |
CategoryTheory.SingleObj.toEnd | Mathlib.CategoryTheory.SingleObj | (M : Type u) → [inst : Monoid M] → M ≃* CategoryTheory.End (CategoryTheory.SingleObj.star M) | The endomorphisms monoid of the only object in `SingleObj M` is equivalent to the original
monoid `M`. | true |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.coe_mem_ker_iff._simp_1_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] {σ : R →+* S} {E : Type u_4} [inst_2 : AddCommGroup E]
[inst_3 : Module R E] {F : Type u_5} [inst_4 : AddCommGroup F] [inst_5 : Module S F] {f : E →ₛₗ.[σ] F} {x : E},
(x ∈ f.ker) = ∃ y, x = ↑y ∧ ↑f y = 0 | null | false |
_private.Mathlib.LinearAlgebra.Dimension.Free.0.Module.Free.rank_eq_mk_of_infinite_lt._simp_1_1 | Mathlib.LinearAlgebra.Dimension.Free | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [StrongRankCondition R], Cardinal.mk (Module.Free.ChooseBasisIndex R M) = Module.rank R M | null | false |
UInt32.ofBitVec_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin (2 ^ 32)), { toBitVec := { toFin := n } } = UInt32.ofFin n | null | true |
ImportGraph.Lake.BasePackage._sizeOf_inst | ImportGraph.WorkspaceModel.Base | SizeOf ImportGraph.Lake.BasePackage | null | false |
ModuleCat.ExtendRestrictScalarsAdj.HomEquiv.fromExtendScalars._proof_4 | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) {X : ModuleCat R}
{Y : ModuleCat S} (g : X ⟶ (ModuleCat.restrictScalars f).obj Y)
(a a_1 : TensorProduct R ↑((ModuleCat.restrictScalars f).obj ↧S) ↑X),
(TensorProduct.lift
{ toFun := fun s => ModuleCat.ExtendRestrictSc... | null | false |
Turing.TM0.Stmt.noConfusion | Mathlib.Computability.TuringMachine.PostTuringMachine | {P : Sort u} →
{Γ : Type u_1} →
{t : Turing.TM0.Stmt Γ} →
{Γ' : Type u_1} → {t' : Turing.TM0.Stmt Γ'} → Γ = Γ' → t ≍ t' → Turing.TM0.Stmt.noConfusionType P t t' | null | false |
_private.Mathlib.Computability.TuringMachine.Tape.0.Turing.Tape.write_nth.match_1_1 | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (motive : Turing.Tape Γ → ℤ → Prop) (x : Turing.Tape Γ) (x_1 : ℤ),
(∀ (x : Turing.Tape Γ), motive x 0) →
(∀ (x : Turing.Tape Γ) (n : ℕ), motive x (Int.ofNat n.succ)) →
(∀ (x : Turing.Tape Γ) (a : ℕ), motive x (Int.negSucc a)) → motive x x_1 | null | false |
HomologicalComplex₂.ofGradedObject | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) →
(X : CategoryTheory.GradedObject (I₁ × I₂) C) →
... | Constructor for bicomplexes taking as inputs a graded object, horizontal differentials
and vertical differentials satisfying suitable relations. | true |
accPt_iff_frequently | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {C : Set X},
AccPt x (Filter.principal C) ↔ ∃ᶠ (y : X) in nhds x, y ≠ x ∧ y ∈ C | `x` is an accumulation point of a set `C` iff
there are points near `x` in `C` and different from `x`. | true |
_private.Init.Data.SInt.Lemmas.0.Int16.toNatClampNeg_ofNat_of_lt._proof_1_2 | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, n < 2 ^ 15 → ¬-2 ^ 15 ≤ ↑n → False | null | false |
FirstOrder._aux_Mathlib_ModelTheory_LanguageMap___unexpand_FirstOrder_Language_withConstants_1 | Mathlib.ModelTheory.LanguageMap | Lean.PrettyPrinter.Unexpander | null | false |
CategoryTheory.Limits.colimit.ι_desc_apply | Mathlib.CategoryTheory.ConcreteCategory.Elementwise | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasColimit F] (c : CategoryTheory.Limits.Cocone F)
(j : J) {F_1 : C → C → Type uF} {carrier : C → Type w}
{instFunLike : (X Y : C) →... | null | true |
Lean.Elab.Term.elabOmission | Lean.Elab.BuiltinTerm | Lean.Elab.Term.TermElab | null | true |
_private.Lean.Compiler.IR.ToIR.0.Lean.IR.ToIR.lowerDecl.match_1 | Lean.Compiler.IR.ToIR | (motive : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.impure → Sort u_1) →
(x : Lean.Compiler.LCNF.DeclValue Lean.Compiler.LCNF.Purity.impure) →
((code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) →
motive (Lean.Compiler.LCNF.DeclValue.code code)) →
((externAttrData : Lean.... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.