name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Real.rpow_div_two_eq_sqrt | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x : ℝ} (r : ℝ), 0 ≤ x → x ^ (r / 2) = √x ^ r | null | true |
Algebra.FormallySmooth.of_restrictScalars | Mathlib.RingTheory.Smooth.Basic | ∀ (R : Type u_4) [inst : CommRing R] (A : Type u_5) [inst_1 : CommRing A] [inst_2 : Algebra R A] (B : Type u_6)
[inst_3 : CommRing B] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B]
[Algebra.FormallyUnramified R A] [Algebra.FormallySmooth R B], Algebra.FormallySmooth A B | null | true |
AddMonCat.limitAddMonoid._proof_4 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections],
autoParam
(∀ (x : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddMonCat))).pt), 0 • x ... | null | false |
OrderEmbedding.image_setOf_minimal | Mathlib.Order.Minimal | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {f : α ↪o β},
⇑f '' {x | Minimal (fun x => x ∈ s) x} = {x | Minimal (fun x => x ∈ ⇑f '' s) x} | null | true |
QuadraticMap.exists_companion' | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u} {M : Type v} {N : Type w} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (self : QuadraticMap R M N),
∃ B, ∀ (x y : M), self.toFun (x + y) = self.toFun x + self.toFun y + (B x) y | null | true |
IsDedekindDomain.HeightOneSpectrum.instIsLocalRingSubtypeMemSubalgebraOfFieldPrimeComplAsIdeal | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
IsLocalRing ↥(Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯) | null | true |
LawfulMonadStateOf.mk | Batteries.Control.LawfulMonadState | ∀ {σ : semiOutParam (Type u_1)} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m]
[toLawfulMonad : LawfulMonad m],
(∀ {α : Type u_1} (f : σ → α × σ),
modifyGet f = do
let z ← f <$> get
set z.2
pure z.1) →
(∀ {α : Type u_1} (mx : m α),
(do
le... | null | true |
List.decidableDuplicate.match_3 | Mathlib.Data.List.Duplicate | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((y : α) → (l : List α) → motive (y :: l)) → motive x | null | false |
RestrictedProduct.evalMonoidHom._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_2} (R : ι → Type u_1) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} (j : ι) [inst_1 : (i : ι) → Monoid (R i)] [inst_2 : ∀ (i : ι), SubmonoidClass (S i) (R i)],
1 j = 1 j | null | false |
Std.Sat.AIG.RefVec.map.go._unary | Std.Sat.AIG.RefVecOperator.Map | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{len : ℕ} →
(f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α) →
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] →
[Std.Sat.AIG.RefVec.LawfulMapOperator α f] →
(aig : Std.Sat.AIG... | null | false |
ContDiffAt.continuousLinearMap_comp | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} {x : E} {n : WithTop ℕ∞} ... | Composition by continuous linear maps on the left preserves `C^n` functions in a domain
at a point. | true |
FirstOrder.Language.LEquiv.onBoundedFormula_symm_apply | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} {n : ℕ} (φ : L ≃ᴸ L') (a : L'.BoundedFormula α n),
φ.onBoundedFormula.symm a = φ.invLHom.onBoundedFormula a | null | true |
padicNorm.padicNorm_p | Mathlib.NumberTheory.Padics.PadicNorm | ∀ {p : ℕ}, 1 < p → padicNorm p ↑p = (↑p)⁻¹ | The `p`-adic norm of `p` is `p⁻¹` if `p > 1`.
See also `padicNorm.padicNorm_p_of_prime` for a version assuming `p` is prime. | true |
_private.Mathlib.Topology.Semicontinuity.Hemicontinuity.0.upperHemicontinuous_iff_isClosed_compl_preimage_Iic_compl._simp_1_1 | Mathlib.Topology.Semicontinuity.Hemicontinuity | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | null | false |
CategoryTheory.ObjectProperty.IsMonoidal.mk | Mathlib.CategoryTheory.Monoidal.Subcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{P : CategoryTheory.ObjectProperty C} [toContainsUnit : P.ContainsUnit] [toTensorLE : P.TensorLE P P], P.IsMonoidal | null | true |
Continuous.matrixOf | Mathlib.Topology.Instances.Matrix | ∀ {α : Type u_2} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : TopologicalSpace α]
{f : α → m → n → R}, Continuous f → Continuous fun x => Matrix.of (f x) | **Alias** of the reverse direction of `continuous_matrixOf`. | true |
_private.Mathlib.Geometry.Manifold.Immersion.0.Manifold.isLocalSourceTargetProperty_immersionAtProp._proof_1_4 | Mathlib.Geometry.Manifold.Immersion | ∀ {𝕜 : Type u_4} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} {E'' : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] {H : Type u_7}
[inst_5 : TopologicalSpace H] {G : Type u_5} [inst_6 : TopologicalSpace G] {I : ModelWithCo... | null | false |
_private.Lean.Elab.DeclModifiers.0.Lean.Elab.expandDeclId.match_1 | Lean.Elab.DeclModifiers | (motive : Lean.Name × Lean.Name → Sort u_1) →
(x : Lean.Name × Lean.Name) → ((declName shortName : Lean.Name) → motive (declName, shortName)) → motive x | null | false |
MeasureTheory.VectorMeasure.enorm_setIntegral_le_of_enorm_le_const_ae | Mathlib.MeasureTheory.VectorMeasure.SetIntegral | ∀ {X : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup F] [inst_2 : NormedAddCommGroup G] {μ : MeasureTheory.VectorMeasure X F} {f : X → E}
{s : Set X} [inst_3 : NormedSpace ℝ E] [inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpa... | null | true |
Std.DTreeMap.Raw.Equiv.insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (k : α) (v : β k), (t₁.insert k v).Equiv (t₂.insert k v) | null | true |
IsDedekindDomain.adjoin_union_eq_top_of_isCoprime_differentialIdeal | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | ∀ (A : Type u_1) (B : Type u_2) {K : Type u_3} {L : Type u_4} [inst : CommRing A] [inst_1 : Field K]
[inst_2 : Algebra A K] [IsFractionRing A K] [inst_4 : CommRing B] [inst_5 : Field L] [inst_6 : Algebra B L]
[inst_7 : Algebra A L] [inst_8 : Algebra K L] [FiniteDimensional K L] [inst_10 : IsScalarTower A K L] (R₁ :... | null | true |
Lean.DeclarationLocation.recOn | Lean.Data.DeclarationRange | {motive : Lean.DeclarationLocation → Sort u} →
(t : Lean.DeclarationLocation) →
((module : Lean.Name) → (range : Lean.DeclarationRange) → motive { module := module, range := range }) → motive t | null | false |
iteratedDeriv_fun_id | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : ℕ} {x : 𝕜},
iteratedDeriv n (fun x => x) x = if n = 0 then x else if n = 1 then 1 else 0 | Eta-expanded form of `iteratedDeriv_id` | true |
Nat.lt_mul_of_div_lt | Init.Data.Nat.Lemmas | ∀ {a c b : ℕ}, a / c < b → 0 < c → a < b * c | null | true |
Mathlib.Tactic.Order.updateGraphWithNltInfSup | Mathlib.Tactic.Order | Mathlib.Tactic.Order.Graph → Array Mathlib.Tactic.Order.AtomicFact → Mathlib.Tactic.AtomM Mathlib.Tactic.Order.Graph | Adds edges to the `≤`-graph using two types of facts:
1. Each fact `¬ (x < y)` allows to add the edge `(x, y)` when `y` is reachable from `x` in the
graph.
2. Each fact `x ⊔ y = z` allows to add the edge `(z, s)` when `s` is reachable from both `x`
and `y`.
We repeat the process until no more edges can be added.... | true |
Aesop.RuleTacDescr.forwardMatches.noConfusion | Aesop.RuleTac.Descr | {P : Sort u} →
{ms ms' : Array Aesop.ForwardRuleMatch} →
Aesop.RuleTacDescr.forwardMatches ms = Aesop.RuleTacDescr.forwardMatches ms' → (ms = ms' → P) → P | null | false |
Representation.coind._proof_2 | Mathlib.RepresentationTheory.Coinduced | ∀ {k : Type u_3} {G : Type u_4} {H : Type u_1} [inst : Semiring k] [inst_1 : Monoid G] [inst_2 : Monoid H] (φ : G →* H)
{B : Type u_2} [inst_3 : AddCommMonoid B] [inst_4 : Module k B] (ρ : Representation k G B),
(LinearMap.funLeft k B fun x => x * 1).restrict ⋯ = 1 | null | false |
_private.Mathlib.Data.Finmap.0.Finmap.keysLookupEquiv._simp_11 | Mathlib.Data.Finmap | ∀ {α : Type u_1} {x : Option α}, (x.isSome = true) = ∃ a, x = some a | null | false |
HNNExtension.NormalWord.group_smul_toList | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} {d : HNNExtension.NormalWord.TransversalPair G A B} (g : G)
(w : HNNExtension.NormalWord d), (g • w).toList = w.toList | null | true |
Real.sin_add_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.sin (x + Real.pi) = -Real.sin x | null | true |
MeasureTheory.isTightMeasureSet_of_tendsto_measure_compl_closedBall | Mathlib.MeasureTheory.Measure.TightNormed | ∀ {E : Type u_1} {mE : MeasurableSpace E} {S : Set (MeasureTheory.Measure E)} [inst : PseudoMetricSpace E]
[ProperSpace E] {x : E},
Filter.Tendsto (fun r => ⨆ μ ∈ S, μ (Metric.closedBall x r)ᶜ) Filter.atTop (nhds 0) →
MeasureTheory.IsTightMeasureSet S | null | true |
CStarMatrix.ofMatrixStarAlgEquiv | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {n : Type u_2} →
{A : Type u_5} →
[inst : Fintype n] →
[inst_1 : SMul ℂ A] → [inst_2 : Semiring A] → [inst_3 : StarRing A] → Matrix n n A ≃⋆ₐ[ℂ] CStarMatrix n n A | `ofMatrix` bundled as a star algebra equivalence. | true |
HomologicalComplex.instHasMapProdObjGradedObjectFunctorMapBifunctorXπ | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_5, u_3} C₁₂]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
[inst_5 : C... | null | true |
GroupExtension.Equiv.mk.injEq | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : Group N] [inst_1 : Group E] [inst_2 : Group G]
{S : GroupExtension N E G} {E' : Type u_4} [inst_3 : Group E'] {S' : GroupExtension N E' G} (toMulEquiv : E ≃* E')
(inl_comm : ⇑toMulEquiv ∘ ⇑S.inl = ⇑S'.inl) (rightHom_comm : ⇑S'.rightHom ∘ ⇑toMulEquiv = ⇑S.rightH... | null | true |
Graph.not_isLink_of_notMem_edgeSet._simp_1 | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, e ∉ G.edgeSet → G.IsLink e x y = False | null | false |
CategoryTheory.Mon.mkIso.eq_1 | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{M N : CategoryTheory.Mon C} (e : M.X ≅ N.X)
(one_f : CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one e.hom = CategoryTheory.MonObj.one)
(mul_f :
CategoryTheory.CategoryStruct.comp CategoryThe... | null | true |
AddOpposite.op_nonpos | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] {a : α}, AddOpposite.op a ≤ 0 ↔ a ≤ 0 | null | true |
MvQPF.Const.mvqpf._proof_1 | Mathlib.Data.QPF.Multivariate.Constructions.Const | ∀ {n : ℕ} {A : Type u_1} {α : TypeVec.{u_1} n} (x : MvQPF.Const n A α),
MvPFunctor.const.get (MvPFunctor.const.mk n x) = x | null | false |
AddChar.toAddMonoidHom_apply | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {M : Type u_3} [inst : AddMonoid A] [inst_1 : Monoid M] (ψ : AddChar A M) (a : A),
ψ.toAddMonoidHom a = Additive.ofMul (ψ a) | null | true |
DistribMulActionHom.toAddActionHom_injective | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : DistribMulAction M A] {B : Type u_5} [inst_4 : AddMonoid B] [inst_5 : DistribMulAction N B]
{f g : A →ₑ+[φ] B}, ↑f = ↑g → f = g | null | true |
Std.Internal.List.eraseKey_cons | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {k k' : α} {v' : β k'},
Std.Internal.List.eraseKey k (⟨k', v'⟩ :: l) = bif k' == k then l else ⟨k', v'⟩ :: Std.Internal.List.eraseKey k l | null | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.sylvesterDeriv_updateRow._proof_1_6 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : Semiring R] (f : Polynomial R),
0 < f.natDegree →
∀ (j : ℕ),
j = f.natDegree - 2 → ¬(j ≤ 2 * f.natDegree - 2 ∧ 2 * f.natDegree ≤ j + f.natDegree + 2) → f.natDegree = 1 | null | false |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State | Std.Sync.Channel | Type → Type | The central state structure for an unbounded channel. Maintains the following invariants:
1. `values = ∅ ∨ consumers = ∅`
2. `closed = true → consumers = ∅`
| true |
Nat.Linear.PolyCnstr.ctorIdx | Init.Data.Nat.Linear | Nat.Linear.PolyCnstr → ℕ | null | false |
Turing.PartrecToTM2.trPosNum_natEnd | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (n : PosNum), ∀ x ∈ Turing.PartrecToTM2.trPosNum n, Turing.PartrecToTM2.natEnd x = false | null | true |
Localization.localRingEquiv._proof_5 | Mathlib.RingTheory.Localization.AtPrime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {P : Type u_2} [inst_1 : CommSemiring P], RingHomClass (P ≃+* R) P R | null | false |
PiTensorProduct.dualDistribInvOfBasis._proof_5 | Mathlib.LinearAlgebra.PiTensorProduct.Dual | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | null | false |
Std.TreeMap.minKeyD_alter_eq_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{f : Option β → Option β},
(t.alter k f).isEmpty = false →
∀ {fallback : α}, (t.alter k f).minKeyD fallback = k ↔ (f t[k]?).isSome = true ∧ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
Polynomial.div_prod_eq_quo_add_sum_rem_div | Mathlib.Algebra.Polynomial.PartialFractions | ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra (Polynomial R) K]
[FaithfulSMul (Polynomial R) K] (f : Polynomial R) {ι : Type u_3} {g : ι → Polynomial R} {s : Finset ι},
(∀ i ∈ s, (g i).Monic) →
((↑s).Pairwise fun i j => IsCoprime (g i) (g j)) →
∃ q r, (∀ i ∈ s, (... | Let `R` be an integral domain and `f : R[X]`. Let `s` be a finite index set.
Then a fraction of the form `f / ∏ i ∈ s, g i` evaluated in a field `K` containing `R[X]`
can be rewritten as `q + ∑ i ∈ s, r i / g i`, where
`degree (r i) < degree (g i)`, provided that the `g i` are monic and pairwise coprime.
See `quo_add_s... | true |
Std.HashSet.get_inter | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{k : α} {h_mem : k ∈ m₁ ∩ m₂}, (m₁ ∩ m₂).get k h_mem = m₁.get k ⋯ | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt64.reduceGE._regBuiltin.UInt64.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.4002762760._hygCtx._hyg.215 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
isClosedMap_fst_of_compactSpace | Mathlib.Topology.Maps.Proper.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [CompactSpace Y],
IsClosedMap Prod.fst | If `Y` is a compact topological space, then `Prod.fst : X × Y → X` is a closed map. | true |
Std.ExtTreeSet.isEmpty_union | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp],
(t₁ ∪ t₂).isEmpty = (t₁.isEmpty && t₂.isEmpty) | null | true |
_private.Mathlib.Data.Set.Prod.0.Set.Disjoint.set_prod_right.match_1_3 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {t₁ t₂ : Set β} (s₁ s₂ : Set α)
(motive : (x : α × β) → x ∈ s₁ ×ˢ t₁ → x ∈ s₂ ×ˢ t₂ → Prop) (x : α × β) (x_1 : x ∈ s₁ ×ˢ t₁) (x_2 : x ∈ s₂ ×ˢ t₂),
(∀ (_a : α) (_b : β) (x : (_a, _b) ∈ s₁ ×ˢ t₁) (x_3 : (_a, _b) ∈ s₂ ×ˢ t₂), motive (_a, _b) x x_3) → motive x x_1 x_2 | null | false |
_private.Lean.Server.Completion.SyntheticCompletion.0.Lean.Server.Completion.isSyntheticTacticCompletion | Lean.Server.Completion.SyntheticCompletion | Lean.FileMap → String.Pos.Raw → Lean.Syntax → Bool | null | true |
_private.Mathlib.Algebra.Order.BigOperators.Ring.Finset.0.Mathlib.Meta.Positivity.evalFinsetProd._proof_2 | Mathlib.Algebra.Order.BigOperators.Ring.Finset | failed to pretty print expression (use 'set_option pp.rawOnError true' for raw representation) | null | false |
MeasureTheory.OuterMeasure.instDistribMulAction._proof_1 | Mathlib.MeasureTheory.OuterMeasure.Operations | ∀ {α : Type u_1} {R : Type u_2} [inst : Monoid R] [inst_1 : DistribMulAction R ENNReal]
[inst_2 : IsScalarTower R ENNReal ENNReal] (a : R), a • 0 = 0 | null | false |
AlgebraicGeometry.Scheme.restrictRestrictComm._proof_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ (X : AlgebraicGeometry.Scheme) (U V : X.Opens),
AlgebraicGeometry.IsOpenImmersion
(CategoryTheory.CategoryStruct.comp ((TopologicalSpace.Opens.map U.ι.base).obj V).ι U.ι) | null | false |
CategoryTheory.StructuredArrow.isEquivalence_pre | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (S : D) (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D) [F.IsEquivalence], (CategoryTheory.StructuredArrow.pre S F G).... | If `F` is an equivalence, then so is the functor `(S, F ⋙ G) ⥤ (S, G)`. | true |
QuadraticMap.Isometry.fst_comp_inr | Mathlib.LinearAlgebra.QuadraticForm.Prod | ∀ {R : Type u_2} {M₁ : Type u_3} {M₂ : Type u_4} {P : Type u_7} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid P] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R P] (Q₁ : QuadraticMap R M₁ P),
(QuadraticMap.Isometry.fst M₂ Q₁).comp (Quadrat... | null | true |
derivationQuotKerSq._simp_4 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_5} [inst : CommRing R] (I : Ideal R), Ideal.Quotient.mk I = algebraMap R (R ⧸ I) | null | false |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.throwUnexpected | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | {α : Type} → Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Lean.Meta.Grind.GoalM α | null | true |
Lean.Meta.Grind.ActionResult.closed.sizeOf_spec | Lean.Meta.Tactic.Grind.Types | ∀ (seq : List Lean.Meta.Grind.TGrind), sizeOf (Lean.Meta.Grind.ActionResult.closed seq) = 1 + sizeOf seq | null | true |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic.match_1_1 | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) {a : K}
(motive : Polynomial.X - Polynomial.C a ∣ f /ₘ (Polynomial.X - Polynomial.C a) → Prop)
(hf : Polynomial.X - Polynomial.C a ∣ f /ₘ (Polynomial.X - Polynomial.C a)),
(∀ (u : Polynomial K) (hu : f /ₘ (Polynomial.X - Polynomial.C a) = (Polynomial.X - Polyno... | null | false |
Std.LawfulLeftIdentity.mk | Init.Core | ∀ {α : Sort u} {β : Sort u_1} {op : α → β → β} {o : outParam α} [toLeftIdentity : Std.LeftIdentity op o],
(∀ (a : β), op o a = a) → Std.LawfulLeftIdentity op o | null | true |
PresheafOfModules.Derivation.Universal.noConfusion | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | {P : Sort u_1} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} →
{F : CategoryTheory.Functor C D} →
{R : CategoryTheory.Functor Dᵒᵖ CommRin... | null | false |
HomologicalComplex.homotopyCofiber.d.eq_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} {F G : HomologicalComplex C c} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ]
[inst_3 : DecidableRel c.Rel] (i j : ι),
HomologicalComplex.homotopyCofiber.d φ i... | null | true |
lowerSemiContinuous_neg_iff._simp_1 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} [inst : TopologicalSpace α] {β : Type u_5} {f : α → β} [inst_1 : PartialOrder β]
[inst_2 : AddCommGroup β] [IsOrderedAddMonoid β], LowerSemicontinuous (-f) = UpperSemicontinuous f | null | false |
toIcoMod_zero_one | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] [inst_3 : FloorRing α]
(b : α), toIcoMod ⋯ 0 b = Int.fract b | null | true |
NumberField.IsCMField.unitsMulComplexConjInv._proof_1 | Mathlib.NumberTheory.NumberField.CMField | ∀ (K : Type u_1) [inst : Field K] [inst_1 : CharZero K] [NumberField K], Algebra.IsIntegral ℚ K | null | false |
Int.ModEq.prod | Mathlib.Algebra.BigOperators.ModEq | ∀ {α : Type u_1} {n : ℤ} {f g : α → ℤ} {s : Finset α},
(∀ x ∈ s, f x ≡ g x [ZMOD n]) → ∏ x ∈ s, f x ≡ ∏ x ∈ s, g x [ZMOD n] | null | true |
MvPolynomial.irreducible_of_disjoint_support | Mathlib.RingTheory.MvPolynomial.IrreducibleQuadratic | ∀ {n : Type u_1} {R : Type u_2} [inst : CommRing R] [IsDomain R] {f : MvPolynomial n R},
f.support.Nontrivial →
∀ {d : n →₀ ℕ},
d ∈ f.support →
∀ {i : n},
d i = 1 →
(↑f.support).PairwiseDisjoint Finsupp.support →
(∀ (r : R), (∀ (d : n →₀ ℕ), r ∣ MvPolynomial.coeff... | A multivariate polynomial `f` whose support is nontrivial,
such that some variable `i` appears with exponent `1` in one nontrivial monomial,
whose monomials have disjoint supports, and which is primitive, is irreducible. | true |
Prod.divisibleBy._proof_1 | Mathlib.GroupTheory.Divisible | ∀ {β : Type u_3} {B : Type u_1} {B' : Type u_2} [inst : SMul β B] [inst_1 : SMul β B'] [inst_2 : Zero β]
[inst_3 : AddMonoid B] [inst_4 : AddMonoid B'] [inst_5 : DivisibleBy B β] [inst_6 : DivisibleBy B' β] (_p : B × B'),
(DivisibleBy.div _p.1 0, DivisibleBy.div _p.2 0) = 0 | null | false |
groupHomology.mapShortComplexH2_τ₂ | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G H : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {A : Rep.{u, u, u} k G}
{B : Rep.{u, u, u} k H} (f : G →* H) (φ : A ⟶ Rep.res f B),
(groupHomology.mapShortComplexH2 f φ).τ₂ = groupHomology.chainsMap₂ f φ | null | true |
CategoryTheory.leftDual_rightDual | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X : C}
[inst_2 : CategoryTheory.HasRightDual X], ᘁXᘁ = X | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting.0.CategoryTheory.Limits.termG₁ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | Lean.ParserDescr | null | true |
Simps.projectionsInfo | Mathlib.Tactic.Simps.Basic | List Simps.ProjectionData → String → Lean.Name → Lean.MessageData | Returns the projection information of a structure. | true |
Lean.Lsp.DependencyBuildMode.ctorElimType | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.DependencyBuildMode → Sort u} → ℕ → Sort (max 1 u) | null | false |
ClassGroup.mk0_eq_mk0_inv_iff | Mathlib.RingTheory.ClassGroup.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDedekindDomain R]
{I J : ↥(nonZeroDivisors (Ideal R))}, ClassGroup.mk0 I = (ClassGroup.mk0 J)⁻¹ ↔ ∃ x, x ≠ 0 ∧ ↑I * ↑J = Ideal.span {x} | null | true |
Bundle.Trivialization.coordChangeHomeomorph_coe | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (e₁ e₂ : Bundle.Trivialization F proj) {b : B} (h₁ : b ∈ e₁.baseSet)
(h₂ : b ∈ e₂.baseSet), ⇑(e₁.coordChangeHomeomorph e₂ h₁ h₂) = e₁.coordChange e₂ b | null | true |
CategoryTheory.yonedaAddGrpFullyFaithful.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C],
CategoryTheory.yonedaAddGrpFullyFaithful =
{
preimage := fun {G H} α =>
CategoryTheory.AddGrp.homMk'
(CategoryTheory.yonedaAddMonFullyFaithful.preimage
(CategoryTheor... | null | true |
Submonoid.pow_coe | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] (n : M) (m : ℕ), ↑(Submonoid.pow n m) = n ^ m | null | true |
Aesop.EqualUpToIdsM.State.ctorIdx | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM.State → ℕ | null | false |
Array.instDecidableEq_csimp | Init.Data.Array.DecidableEq | @Array.instDecidableEq = @Array.instDecidableEqImpl | null | true |
OrderHom.range_eq_iff | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PartialOrder β] [Finite α] {f g : α →o β},
Function.Injective ⇑f → Function.Injective ⇑g → (Set.range ⇑f = Set.range ⇑g ↔ f = g) | null | true |
List.attach_toArray._proof_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {l : List α}, ∀ x ∈ l, x ∈ l.toArray | null | false |
WeierstrassCurve.Affine.Point.some.inj | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type r} {inst : CommRing R} {W' : WeierstrassCurve.Affine R} {x y : R} {h : W'.Nonsingular x y} {x_1 y_1 : R}
{h_1 : W'.Nonsingular x_1 y_1},
WeierstrassCurve.Affine.Point.some x y h = WeierstrassCurve.Affine.Point.some x_1 y_1 h_1 → x = x_1 ∧ y = y_1 | null | true |
PSet.instEmptyCollection | Mathlib.SetTheory.ZFC.PSet | EmptyCollection PSet.{u_1} | null | true |
HDiv.ctorIdx | Init.Prelude | {α : Type u} → {β : Type v} → {γ : outParam (Type w)} → HDiv α β γ → ℕ | null | false |
CategoryTheory.prodComonad_map | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : C) [inst_1 : CategoryTheory.Limits.HasBinaryProducts C]
{x x_1 : C} (g : x ⟶ x_1),
(CategoryTheory.prodComonad X).map g = CategoryTheory.Limits.prod.map (CategoryTheory.CategoryStruct.id X) g | null | true |
CategoryTheory.IsSplitEpi.mk._flat_ctor | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} {f : X ⟶ Y},
Nonempty (CategoryTheory.SplitEpi f) → CategoryTheory.IsSplitEpi f | null | false |
Std.Internal.List.Const.getValue?_alterKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] {β : Type v} [EquivBEq α] (k k' : α) (f : Option β → Option β) (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValue? k' (Std.Internal.List.Const.alterKey k f l) =
if (k == k') = true then f (Std.Internal.List.getValue? k l) else Std.Internal.L... | null | true |
Lean.Meta.AbstractMVars.State.ctorIdx | Lean.Meta.AbstractMVars | Lean.Meta.AbstractMVars.State → ℕ | null | false |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.Weekday.ofOrdinal.match_1 | Std.Time.Date.Unit.Weekday | (motive : Std.Time.Weekday.Ordinal → Sort u_1) →
(x : Std.Time.Weekday.Ordinal) →
(Unit → motive ⟨Int.ofNat 1, ⋯⟩) →
(Unit → motive ⟨Int.ofNat 2, ⋯⟩) →
(Unit → motive ⟨Int.ofNat 3, ⋯⟩) →
(Unit → motive ⟨Int.ofNat 4, ⋯⟩) →
(Unit → motive ⟨Int.ofNat 5, ⋯⟩) →
(Unit →... | null | false |
Complex.continuousAt_Gamma | Mathlib.Analysis.SpecialFunctions.Gamma.Deriv | ∀ (s : ℂ), (∀ (m : ℕ), s ≠ -↑m) → ContinuousAt Complex.Gamma s | null | true |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_eq_wfRank._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {ι : Type u_3} {f : ι → Ordinal.{u}} {a : Ordinal.{u}} [Small.{u, u_3} ι], (a < ⨆ i, f i) = ∃ i, a < f i | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0._aux_Mathlib_Analysis_SpecialFunctions_Trigonometric_Cotangent___unexpand_Complex_integerComplement_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | Lean.PrettyPrinter.Unexpander | null | false |
_private.Init.Data.Range.Lemmas.0.Std.Legacy.Range.forM_loop_eq_forM_range'._proof_1_3 | Init.Data.Range.Lemmas | ∀ {i : ℕ} (r : Std.Legacy.Range),
0 < r.step →
¬i < r.stop → ¬(0 * r.step ≤ r.stop - i + r.step - 1 ∧ r.stop - i + r.step - 1 ≤ 0 * r.step + r.step - 1) → False | null | false |
CategoryTheory.shrinkYonedaObjObjEquiv_obj_map | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] {X : C}
{Y Y' : Cᵒᵖ} (g : Y ⟶ Y') (f : (CategoryTheory.shrinkYoneda.{w, v, u}.obj X).obj Y),
CategoryTheory.shrinkYonedaObjObjEquiv
((CategoryTheory.ConcreteCategory.hom ((CategoryTheory.shrinkYoneda.{w... | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize.match_1.eq_1 | Init.Data.String.Decode | ∀ (motive : ByteArray.utf8DecodeChar?.FirstByte → Sort u_1)
(h_1 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.invalid)
(h_2 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.done)
(h_3 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.oneMore)
(h_4 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.