name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.mkAbsurd | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | Given `hp : P` and `nhp : Not P`, returns an instance of type `e`. | true |
RootPairing._sizeOf_inst | Mathlib.LinearAlgebra.RootSystem.Defs | (ι : Type u_1) →
(R : Type u_2) →
(M : Type u_3) →
(N : Type u_4) →
{inst : CommRing R} →
{inst_1 : AddCommGroup M} →
{inst_2 : Module R M} →
{inst_3 : AddCommGroup N} →
{inst_4 : Module R N} → [SizeOf ι] → [SizeOf R] → [SizeOf M] → [SizeOf N] → Si... | null | false |
RingConGen.Rel.mul | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] {r : R → R → Prop} {w x y z : R},
RingConGen.Rel r w x → RingConGen.Rel r y z → RingConGen.Rel r (w * y) (x * z) | null | true |
ComputablePred.halting_problem_not_re | Mathlib.Computability.Halting | ∀ (n : ℕ), ¬REPred fun c => ¬(c.eval n).Dom | null | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Loop.0.Std.Iter.forIn'_toList.aux | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {ρ : Type u} {α : Type v} {γ : Type x} {m : Type x → Type x'} [Monad m] {x : Membership α ρ}
[inst : ForIn' m ρ α inferInstance] {r s : ρ} {init : γ} {f : (a : α) → a ∈ r → γ → m (ForInStep γ)} (h : r = s),
forIn' r init f = forIn' s init fun a h' acc => f a ⋯ acc | null | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryToUnit._proof_10 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ⦃X_1 Y : CategoryTheory.Over X⦄ (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Ov... | null | false |
LinearEquiv.domMulActCongrRight._proof_4 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {S : Type u_1} {R₁ : Type u_2} {R₁' : Type u_3} {R₂' : Type u_7} {M₁ : Type u_4} {M₁' : Type u_5} {M₂' : Type u_6}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁'... | null | false |
TopologicalSpace.IrreducibleCloseds.orderIsoOfIsOpenEmbedding._proof_5 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : β → α)
(h : Topology.IsOpenEmbedding f) {a b : TopologicalSpace.IrreducibleCloseds β},
{ toFun := fun T => ⟨TopologicalSpace.IrreducibleCloseds.map f ⋯ T, ⋯⟩,
invFun := fun V => { carrier := f ⁻¹' ↑↑V, isIrreduc... | null | false |
_private.Init.Data.Nat.Fold.0.Nat.dfold.loop._proof_3 | Init.Data.Nat.Fold | ∀ (n m : ℕ), n - m.succ ≤ n | null | false |
RatFunc.valuedRatFunc._proof_1 | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ (K : Type u_1) [inst : Field K], IsDedekindDomain (Polynomial K) | null | false |
Poly.instAddCommGroup._proof_6 | Mathlib.NumberTheory.Dioph | ∀ {α : Type u_1} (n : ℕ) (x : Poly α), (n + 1) • x = n • x + x | null | false |
Aesop.UnfoldRule.instHashable | Aesop.Rule | Hashable Aesop.UnfoldRule | null | true |
MeasureTheory.integral_pos_iff_support_of_nonneg | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ},
0 ≤ f → MeasureTheory.Integrable f μ → (0 < ∫ (x : α), f x ∂μ ↔ 0 < μ (Function.support f)) | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.ContinuousLinearMap.adjointAux._proof_5 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜], SMulCommClass 𝕜 𝕜 𝕜 | null | false |
_private.Mathlib.Algebra.QuadraticAlgebra.Basic.0.QuadraticAlgebra.instField._simp_9 | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
CategoryTheory.Oplax.OplaxTrans.Modification.id._proof_2 | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_6} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (η : F ⟶ G) {a b : B} (f : a ⟶ b),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft (F.map f) (CategoryTheory.CategoryStruct.id (η.app b)... | null | false |
Fin.preimage_castLE_uIoc_castLE | Mathlib.Order.Interval.Set.Fin | ∀ {m n : ℕ} (i j : Fin m) (h : m ≤ n), Fin.castLE h ⁻¹' Set.uIoc (Fin.castLE h i) (Fin.castLE h j) = Set.uIoc i j | null | true |
MulEquiv.map_finprod_mem | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} {N : Type u_6} [inst : CommMonoid M] [inst_1 : CommMonoid N] (g : M ≃* N) (f : α → M)
{s : Set α}, s.Finite → g (∏ᶠ (i : α) (_ : i ∈ s), f i) = ∏ᶠ (i : α) (_ : i ∈ s), g (f i) | null | true |
_private.Mathlib.NumberTheory.FLT.Polynomial.0.fermatLastTheoremWith'_polynomial._simp_1_3 | Mathlib.NumberTheory.FLT.Polynomial | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.natDegree = 0) = ∃ x, Polynomial.C x = p | null | false |
AlgebraicGeometry.ValuativeCriterion | Mathlib.AlgebraicGeometry.ValuativeCriterion | CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme | A morphism `f : X ⟶ Y` satisfies the valuative criterion if
every valuative commutative square over `f` has a unique lift. | true |
Lean.AsyncConstantInfo.mk | Lean.Environment | Lean.Name → Lean.ConstantKind → Task Lean.ConstantVal → Task Lean.ConstantInfo → Lean.AsyncConstantInfo | null | true |
SeminormedGroup.mem_closure_iff | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_4} [inst : SeminormedGroup E] {s : Set E} {a : E},
a ∈ closure s ↔ ∀ (ε : ℝ), 0 < ε → ∃ b ∈ s, ‖a⁻¹ * b‖ < ε | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Horn.0.SSet.horn.edge._simp_10 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
_private.Mathlib.RingTheory.WittVector.DiscreteValuationRing.0.WittVector.inverseCoeff.match_1._arg_pusher | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ (motive : ℕ → Sort u_1) (α : Sort u✝) (β : α → Sort v✝) (f : (x : α) → β x) (rel : ℕ → α → Prop) (x : ℕ)
(h_1 : Unit → ((y : α) → rel 0 y → β y) → motive 0) (h_2 : (n : ℕ) → ((y : α) → rel n.succ y → β y) → motive n.succ),
((match (motive := (x : ℕ) → ((y : α) → rel x y → β y) → motive x) x with
| 0 => fun ... | null | false |
TopCat.toDeltaGenerated | Mathlib.Topology.Category.DeltaGenerated | CategoryTheory.Functor TopCat DeltaGenerated | The faithful (but not full) functor taking each topological space to its delta-generated
coreflection. | true |
SeminormedAddCommGroup.mk.noConfusion | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
{P : Sort u} →
{toNorm : Norm E} →
{toAddCommGroup : AddCommGroup E} →
{toPseudoMetricSpace : PseudoMetricSpace E} →
{dist_eq : autoParam (∀ (x y : E), dist x y = ‖-x + y‖) SeminormedAddCommGroup.dist_eq._autoParam} →
{toNorm' : Norm E} →
{toAddCo... | null | false |
AlgCat.instBraidedModuleCatForget₂AlgHomCarrierLinearMapIdCarrier._proof_1 | Mathlib.Algebra.Category.AlgCat.Symmetric | ∀ {R : Type u_1} [inst : CommRing R] (X Y : AlgCat R),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)) X Y)
((CategoryTheory.forget₂ (AlgCat R) (ModuleCat R)).map (β_ X Y).hom) =
CategoryTheory.CategoryStruct.comp
(β_ ((C... | null | false |
List.IsZeckendorfRep.sum_fib_lt | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ {n : ℕ} {l : List ℕ}, l.IsZeckendorfRep → (∀ a ∈ (l ++ [0]).head?, a < n) → (List.map Nat.fib l).sum < Nat.fib n | null | true |
supsSupHom_apply | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} [inst : CompleteLattice α] (x : α × α), supsSupHom x = x.1 ⊔ x.2 | null | true |
_private.Mathlib.Algebra.Order.Antidiag.Pi.0.Finset.map_sym_eq_piAntidiag._simp_1_1 | Mathlib.Algebra.Order.Antidiag.Pi | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α] {n : ℕ} {m : Sym α n}, (m ∈ s.sym n) = ∀ a ∈ m, a ∈ s | null | false |
Mathlib.Meta.FunProp.DecompositionResult.comp | Mathlib.Tactic.FunProp.FunctionData | Lean.Expr → Lean.Expr → Mathlib.Meta.FunProp.DecompositionResult | The function can be decomposed in a non-trivial way. | true |
HasStrictDerivAt.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {f : ℝ → ℝ} {f' x : ℝ}, HasStrictDerivAt f f' x → HasStrictDerivAt (fun x => Real.sinh (f x)) (Real.cosh (f x) * f') x | null | true |
Ideal.le_of_map_algebraMap_le | Mathlib.RingTheory.Localization.Away.Lemmas | ∀ {R : Type u_2} (S : Type u_3) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x : R)
[IsLocalization.Away x S] {I J : Ideal R},
Ideal.map (algebraMap R S) I ≤ Ideal.map (algebraMap R S) J → (∀ (y : R), x * y ∈ J → y ∈ J) → I ≤ J | null | true |
SemilatticeSup.mk'._proof_1 | Mathlib.Order.Lattice | ∀ {α : Type u_1} [inst : Max α],
(∀ (a b c : α), a ⊔ b ⊔ c = a ⊔ (b ⊔ c)) → ∀ (a b c : α), a ⊔ b = b → b ⊔ c = c → a ⊔ c = c | null | false |
Sublocale.mk_le_mk._simp_1 | Mathlib.Order.Sublocale | ∀ {X : Type u_1} [inst : Order.Frame X] (carrier₁ carrier₂ : Set X) (sInf_mem'₁ : ∀ s ⊆ carrier₁, sInf s ∈ carrier₁)
(sInf_mem'₂ : ∀ s ⊆ carrier₂, sInf s ∈ carrier₂) (himp_mem'₁ : ∀ (a b : X), b ∈ carrier₁ → a ⇨ b ∈ carrier₁)
(himp_mem'₂ : ∀ (a b : X), b ∈ carrier₂ → a ⇨ b ∈ carrier₂),
({ carrier := carrier₁, sIn... | null | false |
Lean.Grind.Int.mul_emod_emod | Init.Grind.Homo.Extra | ∀ (m n k : ℤ), m * (n % k) % k = m * n % k | null | true |
MeasureTheory.VectorMeasure.etvDist_eq_iSup_finPartition_enorm | Mathlib.MeasureTheory.VectorMeasure.TotalVariation | ∀ {𝓧 : Type u_1} {M : Type u_2} {m𝓧 : MeasurableSpace 𝓧} [inst : NormedAddCommGroup M]
{μ ν : MeasureTheory.VectorMeasure 𝓧 M}, μ.etvDist ν = ⨆ P, ∑ x ∈ P.parts, ‖μ ↑x - ν ↑x‖ₑ | null | true |
_private.Lean.Meta.NatTable.0.Lean.mkNatLookupTable.go._unary._proof_2 | Lean.Meta.NatTable | ∀ (es : Array Lean.Expr) (start stop : ℕ), stop ≤ es.size → start + 1 = stop → start < es.size | null | false |
USize.xor_assoc | Init.Data.UInt.Bitwise | ∀ (a b c : USize), a ^^^ b ^^^ c = a ^^^ (b ^^^ c) | null | true |
Aesop.GoalKind.preNorm | Aesop.Stats.Basic | Aesop.GoalKind | null | true |
InitialSeg.mk.noConfusion | Mathlib.Order.InitialSeg | {α : Type u_4} →
{β : Type u_5} →
{r : α → α → Prop} →
{s : β → β → Prop} →
{P : Sort u} →
{toRelEmbedding : r ↪r s} →
{mem_range_of_rel' : ∀ (a : α) (b : β), s b (toRelEmbedding a) → b ∈ Set.range ⇑toRelEmbedding} →
{toRelEmbedding' : r ↪r s} →
{m... | null | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.floor_add_nsmul_self | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] {x : ι → ℕ}
{i : ↑(IsProperLinearSet.basisSet✝ hs)} {n : ℕ},
IsProperLinearSet.floor✝ hs (x + n • ↑i) i = IsProperLinearSet.floor✝ hs x i + ↑n | null | true |
_private.Std.Time.Notation.0.Std.Time.convertPlainTime | Std.Time.Notation | Std.Time.PlainTime → Lean.MacroM (Lean.TSyntax `term) | null | true |
Prod.instIsOrderBornology | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} [inst : Bornology α] [inst_1 : Preorder α] [IsOrderBornology α] {β : Type u_2} [inst_3 : Preorder β]
[inst_4 : Bornology β] [IsOrderBornology β], IsOrderBornology (α × β) | null | true |
IsCompact.exists_mapClusterPt_of_frequently | Mathlib.Topology.Compactness.Compact | ∀ {X : Type u} {ι : Type u_1} [inst : TopologicalSpace X] {s : Set X} {l : Filter ι} {f : ι → X},
IsCompact s → (∃ᶠ (x : ι) in l, f x ∈ s) → ∃ a ∈ s, MapClusterPt a l f | null | true |
Lean.Meta.Sym.Internal.AlphaShareBuilderM | Lean.Meta.Sym.AlphaShareBuilder | Type → Type | Helper monad for constructing maximally shared terms.
The `Bool` flag indicates whether it is debug-mode or not.
| true |
_private.Mathlib.Geometry.Manifold.VectorField.LieBracket.0.Filter.EventuallyEq.mlieBracketWithin_vectorField_eq._proof_1_12 | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {H : Type u_4} [inst_1 : TopologicalSpace H] {E : Type u_1}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {M : Type u_3}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {x : M}
(x_1 y z : TangentSpace (mode... | null | false |
CategoryTheory.Functor.leftDerivedZeroIsoSelf_inv_hom_id_app_assoc | Mathlib.CategoryTheory.Abelian.LeftDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasProjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
[inst_6 : Cate... | null | true |
Commute.symm | Mathlib.Algebra.Group.Commute.Defs | ∀ {S : Type u_3} [inst : Mul S] {a b : S}, Commute a b → Commute b a | If `a` commutes with `b`, then `b` commutes with `a`. | true |
_private.Mathlib.LinearAlgebra.Matrix.Circulant.0.Matrix.Fin.transpose_circulant.match_1_1 | Mathlib.LinearAlgebra.Matrix.Circulant | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
_private.Mathlib.Algebra.Homology.LocalCohomology.0.localCohomology.idealPowersToSelfLERadical._simp_1 | Mathlib.Algebra.Homology.LocalCohomology | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderTop α] {a : α}, (a ≤ ⊤) = True | null | false |
star_nnratCast | Mathlib.Algebra.Star.Rat | ∀ {R : Type u_1} [inst : DivisionSemiring R] [inst_1 : StarRing R] (q : ℚ≥0), star ↑q = ↑q | null | true |
CategoryTheory.Enriched.FunctorCategory.functorEnriched_id_comp_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] (F₁ F₂ : CategoryTheory.Functor J C)... | null | true |
Lean.Meta.Grind.SymbolPriorityEntry.mk._flat_ctor | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Name → ℕ → Lean.Meta.Grind.SymbolPriorityEntry | null | false |
GroupLike.toUnits._proof_1 | Mathlib.RingTheory.HopfAlgebra.GroupLike | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A],
{ val := ↑1, inv := (HopfAlgebraStruct.antipode R) ↑1, val_inv := ⋯, inv_val := ⋯ } = 1 | null | false |
Lean.Grind.CommRing.Expr.below | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} → Lean.Grind.CommRing.Expr → Sort (max 1 u) | null | false |
_private.Init.Data.List.Monadic.0.List.allM.eq_1 | Init.Data.List.Monadic | ∀ {m : Type → Type u} [inst : Monad m] {α : Type v} (p : α → m Bool), List.allM p [] = pure true | null | true |
Nat.isAlmostPrime_zero_iff._simp_1 | Mathlib.NumberTheory.AlmostPrime | ∀ {n : ℕ}, Nat.IsAlmostPrime 0 n = (n = 1) | null | false |
_private.Lean.Environment.0.Lean.instReprConstantKind.repr.match_1 | Lean.Environment | (motive : Lean.ConstantKind → Sort u_1) →
(x : Lean.ConstantKind) →
(Unit → motive Lean.ConstantKind.defn) →
(Unit → motive Lean.ConstantKind.thm) →
(Unit → motive Lean.ConstantKind.axiom) →
(Unit → motive Lean.ConstantKind.opaque) →
(Unit → motive Lean.ConstantKind.quot) →
... | null | false |
_private.Mathlib.Data.Nat.Totient.0.ZMod.card_units_eq_totient._simp_1_2 | Mathlib.Data.Nat.Totient | ∀ {α : Type u_1} [inst : AddCommMonoid α] (f : ℕ → α) (n : ℕ), ∑ i ∈ Finset.range n, f i = ∑ i, f ↑i | null | false |
NormedAddGroupHom.ext_iff | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
{f g : NormedAddGroupHom V₁ V₂}, f = g ↔ ∀ (x : V₁), f x = g x | null | true |
CovariantDerivative.derivMetricTensor_apply_eq_extend | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Metric | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {H : Type u_2} [inst_2 : TopologicalSpace H]
{I : ModelWithCorners ℝ E H} {M : Type u_3} [inst_3 : TopologicalSpace M] [inst_4 : ChartedSpace H M] {F : Type u_4}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace ℝ F] {V : M → Type u_5}
... | null | true |
USize.lt_or_le | Init.Data.UInt.Lemmas | ∀ (a b : USize), a < b ∨ b ≤ a | null | true |
CategoryTheory.Pretriangulated.id_hom₃ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ]
(A : CategoryTheory.Pretriangulated.Triangle C),
(CategoryTheory.CategoryStruct.id A).hom₃ = CategoryTheory.CategoryStruct.id A.obj₃ | null | true |
CategoryTheory.Adjunction.leftExtensionPostcompose₂ | Mathlib.CategoryTheory.Functor.KanExtension.AdjunctionPreserves | {C : Type u_1} →
{D : Type u_2} →
{H₁ : Type u_3} →
{H₂ : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} H₁] →
[inst_3 : CategoryTheory.Category.{v_4, u_4} ... | The adjunction exhibiting that `LeftExtension.postcompose₂ L F G₁` has a right adjoint
when `G₁` has. | true |
CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence_counitIso | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.MonoidalCategory D] [inst_3 : CategoryTheory.BraidedCategory D],
(CategoryTheory.Monoidal.commMonFunctorCategoryEquivalence C D).counitIso =
CategoryTheory.Monoidal.Co... | null | true |
RatFunc.toFractionRingAlgEquiv._proof_1 | Mathlib.FieldTheory.RatFunc.Basic | ∀ (K : Type u_1) [inst : CommRing K] [inst_1 : IsDomain K] (R : Type u_2) [inst_2 : CommSemiring R]
[inst_3 : Algebra R (Polynomial K)] (r : R),
(RatFunc.toFractionRingRingEquiv K).toFun ((algebraMap R (RatFunc K)) r) =
(algebraMap R (FractionRing (Polynomial K))) r | null | false |
Set.indicator_comp_of_zero | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} {N : Type u_4} [inst : Zero M] [inst_1 : Zero N] {s : Set α} {f : α → M} {g : M → N},
g 0 = 0 → s.indicator (g ∘ f) = g ∘ s.indicator f | null | true |
Tactic.ComputeAsymptotics.UnitMonomial.FirstNonzeroIsPos.eq_1 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Predicates | ∀ (m : Tactic.ComputeAsymptotics.UnitMonomial),
m.FirstNonzeroIsPos = (m.sign = Tactic.ComputeAsymptotics.UnitMonomial.Sign.pos) | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_diff_add_size_inter_eq_size_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{h h' : Lean.Expr} →
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound h = Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.bound h' →
(h = h' → P) → P | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt16.toUInt32_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ (a : UInt16) (b : UInt32), (a.toUInt32 = b % 65536) = (a = b.toUInt16) | null | false |
Submonoid.centralizer_eq_top_iff_subset | Mathlib.GroupTheory.Submonoid.Centralizer | ∀ {M : Type u_1} [inst : Monoid M] {s : Set M}, Submonoid.centralizer s = ⊤ ↔ s ⊆ ↑(Submonoid.center M) | null | true |
TrivSqZeroExt.nonAssocSemiring._proof_7 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] (x₁ x₂ x₃ : TrivSqZeroExt R M), (x₁ + x₂) * x₃ = x₁ * x₃ + x₂ * x₃ | null | false |
_private.Std.Time.Format.Basic.0.Std.Time.formatWith.match_45 | Std.Time.Format.Basic | (motive : (modifier : Std.Time.Modifier) → Std.Time.TypeFormat modifier → Sort u_1) →
(modifier : Std.Time.Modifier) →
(data : Std.Time.TypeFormat modifier) →
((format : Std.Time.Text) →
(data : Std.Time.TypeFormat (Std.Time.Modifier.G format)) → motive (Std.Time.Modifier.G format) data) →
... | null | false |
NumberField.hermiteTheorem.rankOfDiscrBdd | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ℕ → ℕ | An upper bound on the degree of a number field `K` with `|discr K| ≤ N`,
see `rank_le_rankOfDiscrBdd`. | true |
RingSubgroupsBasis.mk | Mathlib.Topology.Algebra.Nonarchimedean.Bases | ∀ {A : Type u_1} {ι : Type u_2} [inst : Ring A] {B : ι → AddSubgroup A},
(∀ (i j : ι), ∃ k, B k ≤ B i ⊓ B j) →
(∀ (i : ι), ∃ j, ↑(B j) * ↑(B j) ⊆ ↑(B i)) →
(∀ (x : A) (i : ι), ∃ j, ↑(B j) ⊆ (fun x_1 => x * x_1) ⁻¹' ↑(B i)) →
(∀ (x : A) (i : ι), ∃ j, ↑(B j) ⊆ (fun x_1 => x_1 * x) ⁻¹' ↑(B i)) → RingSu... | null | true |
inTangentCoordinates_eq_mfderiv_comp | Mathlib.Geometry.Manifold.MFDeriv.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : IsManifold I 1 M] {E' : Type ... | To write a linear map between tangent spaces in coordinates amounts to precomposing and
postcomposing it with derivatives of extended charts.
Concrete version of `inTangentCoordinates_eq`. | true |
nilradical_eq_bot_iff | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ {R : Type u_1} [inst : CommSemiring R], nilradical R = ⊥ ↔ IsReduced R | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Copy.0.SimpleGraph.killCopies_eq_left._simp_1_5 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
CategoryTheory.ULiftHom.objUp | Mathlib.CategoryTheory.Category.ULift | {C : Type u_1} → C → CategoryTheory.ULiftHom C | The obvious function `C → ULiftHom C`. | true |
minpoly.ofSubring | Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed | ∀ {K : Type u_3} {L : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (A : Subring K)
[IsIntegrallyClosed ↥A] [IsFractionRing (↥A) K] (x : ↥(integralClosure (↥A) L)),
Polynomial.map (algebraMap (↥A) K) (minpoly (↥A) x) = minpoly K ↑x | The minimal polynomial of `x : L` over `K` agrees with its minimal polynomial over the
integrally closed subring `A`. | true |
Std.Time.Database.TZdb.ctorIdx | Std.Time.Zoned.Database.TZdb | Std.Time.Database.TZdb → ℕ | null | false |
essSup_map_measure._auto_7 | Mathlib.MeasureTheory.Function.EssSup | Lean.Syntax | null | false |
Subgroup.exists_finsupp_of_mem_closure_range | Mathlib.Algebra.Group.Subgroup.Finsupp | ∀ {M : Type u_1} [inst : CommGroup M] {ι : Type u_2} (f : ι → M),
∀ x ∈ Subgroup.closure (Set.range f), ∃ a, x = a.prod fun x1 x2 => f x1 ^ x2 | null | true |
PreTilt.instCommRing._proof_10 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p],
autoParam (∀ (x : PreTilt O p), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
PiNat.mem_cylinder_iff._simp_1 | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, (y ∈ PiNat.cylinder x n) = ∀ i < n, y i = x i | null | false |
PowerBasis.ofAdjoinEqTop | Mathlib.RingTheory.Adjoin.PowerBasis | {K : Type u_1} →
{S : Type u_2} →
[inst : Field K] →
[inst_1 : CommRing S] → [inst_2 : Algebra K S] → {x : S} → IsIntegral K x → K[x] = ⊤ → PowerBasis K S | If `x` generates `S` over `K` and is integral over `K`, then it defines a power basis.
See `PowerBasis.ofAdjoinEqTop'` for a version over a more general base ring.
| true |
ZeroAtInftyContinuousMap.instSeminormedAddCommGroup._proof_4 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : SeminormedAddCommGroup β],
ZeroAtInftyContinuousMap.toBCF 0 = ZeroAtInftyContinuousMap.toBCF 0 | null | false |
SimpleGraph.isVertexCover_image_iso | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W} (f : G ≃g H) {c : Set V},
H.IsVertexCover (⇑f '' c) ↔ G.IsVertexCover c | null | true |
CategoryTheory.Limits.HasFiniteWidePullbacks.out | Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Limits.HasFiniteWidePullbacks C]
(J : Type) [Finite J], CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Limits.WidePullbackShape J) C | `C` has all wide pullbacks for any Finite `J` | true |
CategoryTheory.MonoidalCategory.DayConvolutionInternalHom.ctorIdx | Mathlib.CategoryTheory.Monoidal.DayConvolution.Closed | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
{inst_4 : CategoryTheory.MonoidalClosed V} →
... | null | false |
CategoryTheory.Limits.BinaryBiproductData.casesOn | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P Q : C} →
{motive : CategoryTheory.Limits.BinaryBiproductData P Q → Sort u} →
(t : CategoryTheory.Limits.BinaryBiproductData P Q) →
((bicone : CategoryTheory.L... | null | false |
Turing.FinTM2.step.eq_1 | Mathlib.Computability.TuringMachine.Computable | ∀ (tm : Turing.FinTM2), tm.step = Turing.TM2.step tm.m | null | true |
Lean.Elab.Term.Do.Code.matchExpr.sizeOf_spec | Lean.Elab.Do.Legacy | ∀ (ref : Lean.Syntax) («meta» : Bool) (discr : Lean.Syntax)
(alts : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)) (elseBranch : Lean.Elab.Term.Do.Code),
sizeOf (Lean.Elab.Term.Do.Code.matchExpr ref «meta» discr alts elseBranch) =
1 + sizeOf ref + sizeOf «meta» + sizeOf discr + sizeOf alts + sizeOf e... | null | true |
NormedCommGroup.mk | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_4} →
[toNorm : Norm E] →
[toCommGroup : CommGroup E] →
[toMetricSpace : MetricSpace E] →
autoParam (∀ (x y : E), dist x y = ‖x⁻¹ * y‖) NormedCommGroup.dist_eq._autoParam → NormedCommGroup E | null | true |
_private.Batteries.Data.Fin.Coding.0.Fin.encodeSigma.eq_def | Batteries.Data.Fin.Coding | ∀ {n : ℕ} (f : Fin n → ℕ) (x : (i : Fin n) × Fin (f i)),
Fin.encodeSigma f x =
match n, f, x with
| a.succ, f, ⟨⟨0, ⋯⟩, j⟩ => ⟨↑j, ⋯⟩
| n.succ, f, ⟨⟨i.succ, hi⟩, j⟩ =>
match Fin.encodeSigma (fun x => f x.succ) ⟨⟨i, ⋯⟩, j⟩ with
| ⟨k, hk⟩ => ⟨f 0 + k, ⋯⟩ | null | true |
_private.Mathlib.Analysis.Analytic.Within.0.hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt._simp_1_5 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {f g : α → β} {s : Set α} {a : α},
(f =ᶠ[nhdsWithin a s] g) = ∀ᶠ (x : α) in nhds a, x ∈ s → f x = g x | null | false |
BitVec.lt_asymm | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, x < y → ¬y < x | null | true |
FirstOrder.Language.DirectLimit.dom_partialEquivLimit | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N] {ι : Type u_1}
[inst_2 : Preorder ι] [inst_3 : Nonempty ι] [inst_4 : IsDirectedOrder ι] (S : ι →o L.PartialEquiv M N),
(FirstOrder.Language.DirectLimit.partialEquivLimit S).dom = ⨆ x, (S x).dom | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.