name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.CategoryTheory.Functor.TypeValuedFlat.0.CategoryTheory.FunctorToTypes.fromOverFunctorElementsEquivalence._proof_12 | Mathlib.CategoryTheory.Functor.TypeValuedFlat | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1)) {X : C}
(x : F.obj X) {X_1 Y : CategoryTheory.Over (F.elementsMk X x)} (f : X_1 ⟶ Y),
(CategoryTheory.ConcreteCategory.hom
((CategoryTheory.FunctorToTypes.fromOverFunctor F x).map
(CategoryTheo... | null | false |
CategoryTheory.Sheaf.freeYonedaHomEquiv | Mathlib.CategoryTheory.Generator.Sheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
[inst_2 : CategoryTheory.Limits.HasCoproducts A] →
[inst_3 : CategoryTheory.HasWeakSheafify J A] →
... | The bijection `(Sheaf.freeYoneda J X M ⟶ F) ≃ (M ⟶ F.val.obj (op X))`
when `F : Sheaf J A`, `X : C` and `M : A`. | true |
SSet.Subcomplex.Pairing.RankFunction.basicCell | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} →
{ι : Type v} →
[inst : LinearOrder ι] →
(f : P.RankFunction ι) →
[inst_1 : P.IsProper] → (i : ι) → (c : f.Cell i) → c.horn.toSSet ⟶ SSet.stdSimplex.obj { len := c.dim + 1 } | The horn inclusion corresponding to a cell of a rank function
for a proper pairing of a subcomplex of a simplicial set. | true |
ContDiff.continuous_deriv | Mathlib.Analysis.Calculus.ContDiff.Deriv | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} {f : 𝕜 → F}, ContDiff 𝕜 n f → 1 ≤ n → Continuous (deriv f) | null | true |
Lean.Elab.Tactic.Omega.MetaProblem.noConfusion | Lean.Elab.Tactic.Omega.Frontend | {P : Sort u} →
{t t' : Lean.Elab.Tactic.Omega.MetaProblem} → t = t' → Lean.Elab.Tactic.Omega.MetaProblem.noConfusionType P t t' | null | false |
Rep.indToCoind._proof_2 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {k : Type u_1} {G : Type u_2} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] (A : Rep.{u_3, u_1, u_2} k ↥S) (x : ↥S),
TensorProduct.lift
((Finsupp.linearCombination k fun g =>
LinearMap.codRestrict (Representation.coindV S.subtype A.... | null | false |
Nat.even_xor | Mathlib.Data.Nat.Bitwise | ∀ {m n : ℕ}, Even (m ^^^ n) ↔ (Even m ↔ Even n) | null | true |
ConvexOn.integrable_comp_rnDeriv_map | Mathlib.InformationTheory.KullbackLeibler.DataProcessing | ∀ {𝓧 : Type u_1} {𝓨 : Type u_2} {m𝓧 : MeasurableSpace 𝓧} {m𝓨 : MeasurableSpace 𝓨} {μ ν : MeasureTheory.Measure 𝓧}
[MeasureTheory.IsFiniteMeasure μ] [MeasureTheory.IsFiniteMeasure ν] {f : ℝ → ℝ} {g : 𝓧 → 𝓨},
μ.AbsolutelyContinuous ν →
Measurable g →
MeasureTheory.StronglyMeasurable f →
Con... | null | true |
Algebra.TensorProduct.piRightHom._proof_2 | Mathlib.RingTheory.TensorProduct.Pi | ∀ (R : Type u_1) (S : Type u_5) (A : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [inst_6 : IsScalarTower R S A] {ι : Type u_3}
(B : ι → Type u_4) [inst_7 : (i : ι) → Semiring (B i)] [inst_8 : (i : ι) → Algebra... | null | false |
Metric.Sum.dist | Mathlib.Topology.MetricSpace.Gluing | {X : Type u} → {Y : Type v} → [MetricSpace X] → [MetricSpace Y] → X ⊕ Y → X ⊕ Y → ℝ | Distance on a disjoint union. There are many (noncanonical) ways to put a distance compatible
with each factor.
If the two spaces are bounded, one can say for instance that each point in the first is at distance
`diam X + diam Y + 1` of each point in the second.
Instead, we choose a construction that works for unbounde... | true |
_private.Std.Data.DHashMap.Internal.AssocList.Basic.0.Std.DHashMap.Internal.AssocList.forInStep.go._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type w'} →
[Monad m] → ((a : α) → β a → δ → m (ForInStep δ)) → Std.DHashMap.Internal.AssocList α β → δ → m (ForInStep δ) | null | false |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.sUnion_lem.match_1_5 | Mathlib.SetTheory.ZFC.Basic | ∀ {α : Type u_1} (A : α → PSet.{u_1}) (a : { «Type» := α, Func := A }.Type) (γ : Type u_1) (Γ : γ → PSet.{u_1})
(ea : A a = { «Type» := γ, Func := Γ }) (δ : Type u_1) (Δ : δ → PSet.{u_1}) (c : (A a).Type)
(motive : (∃ b, (Γ (⋯.mp c)).Equiv (Δ b)) → Prop) (x : ∃ b, (Γ (⋯.mp c)).Equiv (Δ b)),
(∀ (d : δ) (hd : (Γ (⋯... | null | false |
Lean.Parser.Tactic.Grind.grindExact_ | Init.Grind.Interactive | Lean.ParserDescr | `exact e` closes the main goal if its target type matches that of `e`. | true |
Lean.Compiler.LCNF.JoinPointContextExtender.ExtendContext.currentJp? | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.JoinPointContextExtender.ExtendContext → Option Lean.FVarId | The `FVarId` of the current join point if we are currently inside one.
| true |
_private.Batteries.Data.Nat.Bisect.0.Nat.bisect._proof_1 | Batteries.Data.Nat.Bisect | ∀ {start stop : ℕ}, start < stop → (start + stop) / 2 < stop | null | false |
_private.Mathlib.Data.Nat.Factors.0.Nat.primeFactorsList.match_1.eq_1 | Mathlib.Data.Nat.Factors | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (k : ℕ) → motive k.succ.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| k.succ.succ => h_3 k) =
h_1 () | null | true |
Nat.getElem?_toList_rco_eq_some | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, i < n - m → (m...n).toList[i]? = some (m + i) | null | true |
Monoid.Coprod.instGroup._proof_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] (a : Monoid.Coprod G H), a ^ 0 = 1 | null | false |
ite_eq_or_eq | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} (P : Prop) [inst : Decidable P] (a b : α), (if P then a else b) = a ∨ (if P then a else b) = b | null | true |
Std.Async.ContextAsync.awaitCancellation | Std.Async.ContextAsync | Std.Async.ContextAsync Unit | Waits for the current context to be cancelled.
| true |
CategoryTheory.Limits.ImageFactorisation.isImage | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → (self : CategoryTheory.Limits.ImageFactorisation f) → CategoryTheory.Limits.IsImage self.F | Data exhibiting that a morphism `f` has an image. | true |
Lean.Lsp.Registration._sizeOf_inst | Lean.Data.Lsp.Client | SizeOf Lean.Lsp.Registration | null | false |
SimpleGraph.exists_adj_iff_not_isIsolated | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} {G : SimpleGraph V} {v : V}, (∃ u, G.Adj v u) ↔ ¬G.IsIsolated v | null | true |
RBTree.RBNode.instToStreamStream | Batteries.Recycling.RBTree.Basic | {α : Type u_1} → Std.ToStream (RBTree.RBNode α) (RBTree.RBNode.Stream α) | null | true |
Array.mapFinIdx_eq_singleton_iff | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β} {b : β},
xs.mapFinIdx f = #[b] ↔ ∃ a, ∃ (w : xs = #[a]), f 0 a ⋯ = b | null | true |
Set.image_val_sInter | Mathlib.Data.Set.Subset | ∀ {α : Type u_2} {A : Set α} {T : Set (Set ↑A)},
T.Nonempty → Subtype.val '' ⋂₀ T = ⋂₀ {x | ∃ B ∈ T, Subtype.val '' B = x} | null | true |
AddSubsemigroup.centerCongr.eq_1 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_2} {N : Type u_1} [inst : Add M] [inst_1 : Add N] (e : M ≃+ N),
AddSubsemigroup.centerCongr e =
{ toFun := fun r => ⟨e ↑r, ⋯⟩, invFun := fun s => ⟨e.symm ↑s, ⋯⟩, left_inv := ⋯, right_inv := ⋯, map_add' := ⋯ } | null | true |
Joined.refl | Mathlib.Topology.Connected.PathConnected | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X), Joined x x | null | true |
Float.Model.compare | Init.Data.Float.Model.Float | Float.Model → Float.Model → Option Ordering | Compute the ordering between two `Float.Model` as specified by IEEE. Returns an
`Option Ordering` to account for the fact that `NaN` is incomparable with everything.
Also, positive and negative zero are equal.
| true |
CommGrpCat.Hom._mkInternal._flat_ctor | Mathlib.Algebra.Category.Grp.Basic | {A B : CommGrpCat} → (↑A →* ↑B) → A.Hom B | null | false |
RBTree.RBNode.lowerBound?_reverse | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} (t : RBTree.RBNode α) (cut : α → Ordering) (lb : Option α),
RBTree.RBNode.lowerBound? cut t.reverse lb = RBTree.RBNode.upperBound? (fun x => (cut x).swap) t lb | null | true |
Complement.mk.noConfusion | Init.Prelude | {α : Type u} →
{P : Sort u_1} →
{complement complement' : α → α} →
{ complement := complement } = { complement := complement' } → (complement ≍ complement' → P) → P | null | false |
WeierstrassCurve.Affine.baseChange_negY | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W' : WeierstrassCurve.Affine R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsSca... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.showDeprecatedModules._regBuiltin.Lean.Parser.Command.showDeprecatedModules_1 | Lean.Parser.Command | IO Unit | null | false |
IsometryEquiv.coe_mk | Mathlib.Topology.MetricSpace.Isometry | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (e : α ≃ β)
(h : Isometry e.toFun), ⇑{ toEquiv := e, isometry_toFun := h } = ⇑e | null | true |
Matroid.map.congr_simp | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} (M M_1 : Matroid α) (e_M : M = M_1) (f f_1 : α → β) (e_f : f = f_1)
(hf : Set.InjOn f M.E), M.map f hf = M_1.map f_1 ⋯ | null | true |
NormedCommGroup.toMetricSpace | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} → [self : NormedCommGroup E] → MetricSpace E | null | true |
Std.StreamMap._sizeOf_inst | Std.Sync.StreamMap | (α β : Type) → [SizeOf α] → [SizeOf β] → SizeOf (Std.StreamMap α β) | null | false |
Order.Cofinal.mk.sizeOf_spec | Mathlib.Order.Ideal | ∀ {P : Type u_2} [inst : Preorder P] [inst_1 : SizeOf P] (carrier : Set P) (isCofinal : IsCofinal carrier),
sizeOf { carrier := carrier, isCofinal := isCofinal } = 1 | null | true |
CategoryTheory.Abelian.SpectralObject.shortComplex_g | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {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.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) Categ... | null | true |
Lean.Grind.CommRing.denoteTerm | Init.Grind.Ring.CommSolver | {α : Type u_1} → [Lean.Grind.Ring α] → Lean.Grind.CommRing.Context α → ℤ → Lean.Grind.CommRing.Mon → α | null | true |
le_of_isGLB_Ioi | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {b : α} (a : α), IsGLB (Set.Ioi a) b → a ≤ b | null | true |
Mathlib.Tactic.Module.NF.eval_neg | Mathlib.Tactic.Module | ∀ {R : Type u_2} {M : Type u_3} [inst : AddCommGroup M] [inst_1 : Ring R] [inst_2 : Module R M]
(l : Mathlib.Tactic.Module.NF R M), (-l).eval = -l.eval | null | true |
CategoryTheory.coherentTopology.exists_effectiveEpiFamily_iff_mem_induced | Mathlib.CategoryTheory.Sites.Coherent.SheafComparison | ∀ {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] (F : CategoryTheory.Functor C D)
[F.PreservesFiniteEffectiveEpiFamilies] [F.ReflectsFiniteEffectiveEpiFamilies] [F.Full] [F.Faithful]
[F.EffectivelyEnough] [inst_7 : CategoryTheory.Precohe... | null | true |
Ideal.Quotient.stabilizerHom_surjective_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}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [inst_5 : SMulCommClass G A B] [inst_6 : TopologicalSpace G]
[CompactSpace G] [TotallyDisconnectedSpace G] [IsTopologicalGroup G] [inst_10 : TopologicalSp... | The stabilizer subgroup of `Q` surjects onto `Aut((B/Q)/(A/P))`. | true |
MulChar.eq_one_iff | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] {χ : MulChar R R'},
χ = 1 ↔ ∀ (a : Rˣ), χ ↑a = 1 | null | true |
Polynomial.coeToPowerSeries.algHom_apply | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (φ : Polynomial R) (A : Type u_2) [inst_1 : Semiring A] [inst_2 : Algebra R A],
(Polynomial.coeToPowerSeries.algHom A) φ = (PowerSeries.map (algebraMap R A)) ↑φ | null | true |
_private.Mathlib.Condensed.Light.TopCatAdjunction.0.LightCondSet.coinducingCoprod | Mathlib.Condensed.Light.TopCatAdjunction | (X : LightCondSet) →
(i : (S : LightProfinite) × X.obj.obj (Opposite.op S)) × ↑i.fst.toTop → X.obj.obj (Opposite.op ↧PUnit.{u + 1}) | Auxiliary definition to define the topology on `X(*)` for a light condensed set `X`. | true |
OnePoint.IsBoundedAt.add | Mathlib.NumberTheory.ModularForms.BoundedAtCusp | ∀ {c : OnePoint ℝ} {f : UpperHalfPlane → ℂ} {k : ℤ} {f' : UpperHalfPlane → ℂ},
c.IsBoundedAt f k → c.IsBoundedAt f' k → c.IsBoundedAt (f + f') k | null | true |
AlgebraicClosure.instSMulOfIsScalarTower | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | (k : Type u) →
[inst : Field k] → {S : Type u_1} → [inst_1 : DistribSMul S k] → [IsScalarTower S k k] → SMul S (AlgebraicClosure k) | null | true |
exists_neg_mem_iff_exists_mem | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [AddSubgroupClass S G]
{P : G → Prop}, (∃ x ∈ H, P (-x)) ↔ ∃ x ∈ H, P x | null | true |
_private.Mathlib.RingTheory.Ideal.Maximal.0.Ideal.exists_maximal.match_1_1 | Mathlib.RingTheory.Ideal.Maximal | ∀ (α : Type u_1) [inst : Semiring α] (motive : (∃ M, M.IsMaximal ∧ ⊥ ≤ M) → Prop) (x : ∃ M, M.IsMaximal ∧ ⊥ ≤ M),
(∀ (I : Ideal α) (hI : I.IsMaximal) (right : ⊥ ≤ I), motive ⋯) → motive x | null | false |
_private.Mathlib.NumberTheory.Chebyshev.0.Chebyshev.sum_PrimePow_eq_sum_sum'._simp_1_15 | Mathlib.NumberTheory.Chebyshev | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α}, (x ∈ Finset.Icc a b) = (a ≤ x ∧ x ≤ b) | null | false |
CategoryTheory.ComposableArrows.scMapIso._proof_1 | Mathlib.Algebra.Homology.ExactSequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{n : ℕ} {S₁ S₂ : CategoryTheory.ComposableArrows C n} (e : S₁ ≅ S₂) (h₁ : S₁.IsComplex) (h₂ : S₂.IsComplex) (i : ℕ)
(hi : i + 2 ≤ n),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ComposableArro... | null | false |
CategoryTheory.GradedObject.TriangleIndexData.h₃ | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₃ : Type u_3} {J : Type u_4} [inst : Zero I₂] {r : I₁ × I₂ × I₃ → J}
{π : I₁ × I₃ → J} (self : CategoryTheory.GradedObject.TriangleIndexData r π) (i₃ : I₃), self.p₂₃ (0, i₃) = i₃ | null | true |
Lean.Elab.Tactic.Do.VCGen.Config.internalize._default | Std.Tactic.Do.Syntax | Bool | null | false |
Function.Injective.divInvMonoid._proof_2 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : Pow M₁ ℕ] [inst_3 : Pow M₁ ℤ]
[inst_4 : DivInvMonoid M₂] (f : M₁ → M₂) (hf : Function.Injective f) (one : f 1 = 1)
(mul : ∀ (x y : M₁), f (x * y) = f x * f y) (npow : ∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n),
(∀ (x : M₁) (n : ℤ), f (x ^... | null | false |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.measureAux.congr_simp | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : DenselyOrdered α] [inst_2 : TopologicalSpace α]
[inst_3 : OrderTopology α] [inst_4 : SecondCountableTopology α] [inst_5 : CompactIccSpace α] [hα : MeasurableSpace α]
[inst_6 : BorelSpace α] {E : Type u_2} [inst_7 : NormedAddCommGroup E] [inst_8 : CompleteSpace E] {f... | null | true |
_private.Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization.0.HomogeneousLocalization.map._simp_2 | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R}, IsLocalization.mk' (Localization M) = Localization.mk | null | false |
OmegaCompletePartialOrder.ContinuousHom.ext_iff | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
{f g : α →𝒄 β}, f = g ↔ ∀ (x : α), f x = g x | null | true |
SimplexCategory.Truncated.initial_incl._proof_2 | Mathlib.AlgebraicTopology.SimplexCategory.Truncated | ∀ {n m : ℕ}, n ≤ m → n ≤ m | null | false |
_private.Mathlib.MeasureTheory.PiSystem.0.piiUnionInter_singleton._simp_1_8 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u} (x : α), (x ∈ ∅) = False | null | false |
Int.Internal.Linear.Poly.insert.induct_unfolding | Init.Data.Int.Linear | ∀ (k : ℤ) (v : Int.Internal.Linear.Var) (motive : Int.Internal.Linear.Poly → Int.Internal.Linear.Poly → Prop),
(∀ (k_1 : ℤ),
motive (Int.Internal.Linear.Poly.num k_1) (Int.Internal.Linear.Poly.add k v (Int.Internal.Linear.Poly.num k_1))) →
(∀ (k_1 : ℤ) (v_1 : Int.Internal.Linear.Var) (p : Int.Internal.Linea... | null | true |
Std.Time.Minute.instReprOffset._aux_1 | Std.Time.Time.Unit.Minute | Std.Time.Minute.Offset → ℕ → Std.Format | null | false |
_private.Mathlib.Basic.Rel.0.SetRel.preimage_eq_biUnion._proof_1_1 | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2} {R : SetRel α β} {t : Set β}, R.preimage t = ⋃ y ∈ t, {x | (x, y) ∈ R} | null | false |
FP.Float.div.match_1 | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] →
(motive : FP.Float → FP.Float → Sort u_1) →
(x x_1 : FP.Float) →
((x : FP.Float) → motive FP.Float.nan x) →
((x : FP.Float) → motive x FP.Float.nan) →
((a a_1 : Bool) → motive (FP.Float.inf a) (FP.Float.inf a_1)) →
((s₁ : Bool) → (f₂ : FP.Float) → motive (FP... | null | false |
MeasureTheory.Lp.norm_const | Mathlib.MeasureTheory.Function.LpSpace.Indicator | ∀ {α : Type u_1} {E : Type u_2} {m : MeasurableSpace α} (p : ENNReal) (μ : MeasureTheory.Measure α)
[inst : NormedAddCommGroup E] [inst_1 : MeasureTheory.IsFiniteMeasure μ] (c : E) [NeZero μ],
p ≠ 0 → ‖(MeasureTheory.Lp.const p μ) c‖ = ‖c‖ * μ.real Set.univ ^ (1 / p.toReal) | null | true |
Lex.instNonUnitalCommSemiring | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [NonUnitalCommSemiring R] → NonUnitalCommSemiring (Lex R) | null | true |
CategoryTheory.FreeBicategory.Hom₂.ctorElimType | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive :
{a b : CategoryTheory.FreeBicategory B} →
(a_1 a_2 : a ⟶ b) → CategoryTheory.FreeBicategory.Hom₂ a_1 a_2 → Sort u_1} →
ℕ →
Sort
(max 1
(imax (u + 1) (u + 1) (u + 1) (u + 1) (max (u + 1) (v + 1)) (max (u + 1) (v + ... | null | false |
WithZero.coe_ne_zero._simp_1 | Mathlib.Algebra.Group.WithOne.Defs | ∀ {α : Type u} {a : α}, (↑a = 0) = False | null | false |
CategoryTheory.Limits.HasColimit.ι_isoOfNatIso_hom_assoc._to_dual_1 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
{F G : CategoryTheory.Functor J C} [inst_2 : CategoryTheory.Limits.HasLimit F]
[inst_3 : CategoryTheory.Limits.HasLimit G] (w : F ≅ G) (j : J) {Z : C} (h : Z ⟶ CategoryTheory.Limits.limit G),
Categ... | null | false |
_private.Mathlib.Topology.Semicontinuity.Defs.0.semicontinuous_iff_isOpen._simp_1_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen s = ∀ x ∈ s, s ∈ nhds x | null | false |
GradedAlgHom.ctorIdx | Mathlib.RingTheory.GradedAlgebra.AlgHom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{ι : Type u_4} →
{inst : CommSemiring R} →
{inst_1 : Semiring A} →
{inst_2 : Semiring B} →
{inst_3 : Algebra R A} →
{inst_4 : Algebra R B} →
{inst_5 : DecidableEq ι} →
... | null | false |
not_isUnit_prime_of_dvd_card | Mathlib.Algebra.CharP.CharAndCard | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Fintype R] {p : ℕ} [Fact (Nat.Prime p)], p ∣ Fintype.card R → ¬IsUnit ↑p | A prime that divides the cardinality of a finite commutative ring `R`
isn't a unit in `R`. | true |
Stream'.Seq.cons.eq_1 | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (a : α) (s : Stream'.Seq α), Stream'.Seq.cons a s = ⟨Stream'.cons (some a) ↑s, ⋯⟩ | null | true |
Equiv.continuousLinearEquiv | Mathlib.Topology.Algebra.Module.TransferInstance | (R : Type u_1) →
{α : Type u_2} →
{β : Type u_3} →
[inst : AddCommMonoid α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : AddCommMonoid β] → [inst_3 : Semiring R] → [inst_4 : Module R β] → (e : α ≃+ β) → α ≃L[R] β | **Alias** of `AddEquiv.continuousLinearEquiv`.
---
An additive equivalence `e : α ≃+ β` gives a continuous linear equivalence `α ≃L[R] β`
where the continuous `R`-module structure on `α` is the one obtained by transporting an
`R`-module structure on `β` back along `e`.
This is `e.linearEquiv` as a continuous linear ... | true |
List.reduceOption_eq_append_iff | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (l : List (Option α)) (l'₁ l'₂ : List α),
l.reduceOption = l'₁ ++ l'₂ ↔ ∃ l₁ l₂, l = l₁ ++ l₂ ∧ l₁.reduceOption = l'₁ ∧ l₂.reduceOption = l'₂ | null | true |
CategoryTheory.Limits.inr_pushoutRightPushoutInlIso_inv | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z) (f' : Y ⟶ W)
[inst_1 : CategoryTheory.Limits.HasPushout f g]
[inst_2 : CategoryTheory.Limits.HasPushout f' (CategoryTheory.Limits.pushout.inl f g)],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr ... | null | true |
CategoryTheory.Limits.isLimitOfCoconeUnopOfCone | Mathlib.CategoryTheory.Limits.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} J] →
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) →
{c : CategoryTheory.Limits.Cone F} →
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.coconeUnopOfCone c) →... | Turn a colimit for `F.unop : J ⥤ C` into a limit for `F : Jᵒᵖ ⥤ Cᵒᵖ`. | true |
_private.Batteries.Tactic.SqueezeScope.0.Batteries.Tactic._aux_Batteries_Tactic_SqueezeScope___elabRules__private_Batteries_Tactic_SqueezeScope_0_Batteries_Tactic_squeezeWrap_1.match_11 | Batteries.Tactic.SqueezeScope | (motive :
Option
(Lean.Syntax.TSepArray
[`Lean.Parser.Tactic.simpStar, `Lean.Parser.Tactic.simpErase, `Lean.Parser.Tactic.simpLemma] ",") →
Sort u_1) →
(args :
Option
(Lean.Syntax.TSepArray
[`Lean.Parser.Tactic.simpStar, `Lean.Parser.Tactic.simpErase, `Lean.Parser.T... | null | false |
iteratedFDerivWithin._proof_2 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F | null | false |
MeasureTheory.charFunDual_prod' | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {mE : MeasurableSpace E}
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {mF : MeasurableSpace F} {μ : MeasureTheory.Measure E}
{ν : MeasureTheory.Measure F} (p : ENNReal) [inst_4 : Fact (1 ≤ p)] [MeasureTheory.SFini... | The characteristic function of a product of measures is a product of
characteristic functions. This is `charFunDual_prod` for `WithLp`.
See `charFun_prod` for the Hilbert space version. | true |
Lean.Parser.ParserState.errorMsg | Lean.Parser.Types | Lean.Parser.ParserState → Option Lean.Parser.Error | null | true |
AddUnits.neg_eq_of_add_eq_zero_right | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : AddMonoid α] {u : AddUnits α} {a : α}, ↑u + a = 0 → ↑(-u) = a | null | true |
Module.Baer.extensionOfMaxAdjoin | Mathlib.Algebra.Module.Injective | {R : Type u} →
[inst : Ring R] →
{Q : Type v} →
[inst_1 : AddCommGroup Q] →
[inst_2 : Module R Q] →
{M : Type u_1} →
{N : Type u_2} →
[inst_3 : AddCommGroup M] →
[inst_4 : AddCommGroup N] →
[inst_5 : Module R M] →
... | The linear map `M ⊔ ⟨y⟩ ⟶ Q` by `x + r • y ↦ f x + φ r` is an extension of `f` | true |
MeasureTheory.integrable_finset_sum_measure | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} [inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε]
[TopologicalSpace.PseudoMetrizableSpace ε] {ι : Type u_7} {m : MeasurableSpace α} {f : α → ε}
{μ : ι → MeasureTheory.Measure α} {s : Finset ι},
MeasureTheory.Integrable f (∑ i ∈ s, μ i) ↔ ∀ i ∈ s, MeasureTheory.Integrable f (... | **Alias** of `MeasureTheory.integrable_finsetSum_measure`. | true |
ContinuousLinearEquiv.continuousMultilinearMapCongrRight._proof_3 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_5} {ι : Type u_1} (E : ι → Type u_2) {F : Type u_3} {G : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : TopologicalSpace F]
[inst_7 ... | null | false |
ADEInequality.lt_six | Mathlib.NumberTheory.ADEInequality | ∀ {r : ℕ+}, 1 < ADEInequality.sumInv {2, 3, r} → r < 6 | null | true |
_private.Mathlib.Topology.Semicontinuity.Basic.0.upperSemicontinuous_iff_isClosed_preimage._simp_1_1 | Mathlib.Topology.Semicontinuity.Basic | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | null | false |
Lean.JsonRpc.ErrorCode.ctorElimType | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.ErrorCode → Sort u} → ℕ → Sort (max 1 u) | null | false |
MaxTropical.instGroupOfAddGroup._proof_6 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u_1} [inst : AddGroup R] (x : MaxTropical R), x⁻¹ * x = 1 | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate.0.RootPairing.ker_rootForm_eq_dualAnnihilator._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {R : Type u_1} [inst_3 : Field R], SMulCommClass R R R | null | false |
Lean.Elab.Term.Do.ToTerm.Context.mk.noConfusion | Lean.Elab.Do.Legacy | {P : Sort u} →
{m returnType : Lean.Syntax} →
{uvars : Array Lean.Elab.Term.Do.Var} →
{kind : Lean.Elab.Term.Do.ToTerm.Kind} →
{m' returnType' : Lean.Syntax} →
{uvars' : Array Lean.Elab.Term.Do.Var} →
{kind' : Lean.Elab.Term.Do.ToTerm.Kind} →
{ m := m, returnType ... | null | false |
_private.Lean.Meta.Tactic.Rfl.0.Lean.MVarId.applyRfl.match_1 | Lean.Meta.Tactic.Rfl | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((lhs rhs : Lean.Expr) → motive (lhs, rhs)) → motive x | null | false |
Std.DHashMap.Raw.getKey?_filterMap | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α] {f : (a : α) → β a → Option (γ a)} {k : α} (h : m.WF),
(Std.DHashMap.Raw.filterMap f m).getKey? k = (m.getKey? k).pfilter fun x h' => (f x (m.get x ⋯)).isSome | null | true |
_private.Mathlib.Data.List.Cycle.0.List.prev.match_1.eq_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} (motive : (x : List α) → (x_1 : α) → x_1 ∈ x → Sort u_2) (x : α) (h : x ∈ [])
(h_1 : (x : α) → (h : x ∈ []) → motive [] x h) (h_2 : (y x : α) → (x_1 : x ∈ [y]) → motive [y] x x_1)
(h_3 : (y z : α) → (xs : List α) → (x : α) → (h : x ∈ y :: z :: xs) → motive (y :: z :: xs) x h),
(match [], x, h wit... | null | true |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.ExSum.cmp.match_1 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
(motive :
(b a : Q(«$α»)) →
Mathlib.Tactic.Ring.Common.ExSum bt sα a → Mathlib.Tactic.Ring.Common.ExSum bt sα b → Sort u_1) →
(b a : Q(«$α»)) →
(x : Mathlib.Tact... | null | false |
_private.Mathlib.Topology.MetricSpace.GromovHausdorff.0.GromovHausdorff.instMetricSpaceGHSpace._simp_3 | Mathlib.Topology.MetricSpace.GromovHausdorff | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | null | false |
Submodule.instInhabitedSubtypeSmallMem | Mathlib.RingTheory.Finiteness.Small | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Inhabited { P // Small.{u, u_2} ↥P } | null | true |
legendreSym.at_one | Mathlib.NumberTheory.LegendreSymbol.Basic | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)], legendreSym p 1 = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.