name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.DocString.Add.0.Lean.parseVersoDocString._sparseCasesOn_1 | Lean.DocString.Add | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) →
(kind : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive_1 (Lean.Syntax.node info kind args)) →
(Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Lean.instHashableImport.hash | Lean.Setup | Lean.Import → UInt64 | null | true |
SimpleGraph.fintypeSubtypePathLength._proof_3 | Mathlib.Combinatorics.SimpleGraph.Walk.Counting | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : DecidableEq V] [inst_1 : G.LocallyFinite] (u v : V) (n : ℕ)
(x : { p // p.IsPath ∧ p.length = n }), x ∈ SimpleGraph.fintypeSubtypePathLength._aux_1 G u v n | null | false |
MeasureTheory.measure_univ_of_isMulLeftInvariant | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] [inst_3 : Group G]
[IsTopologicalGroup G] [WeaklyLocallyCompactSpace G] [NoncompactSpace G] (μ : MeasureTheory.Measure G)
[μ.IsOpenPosMeasure] [μ.IsMulLeftInvariant], μ Set.univ = ⊤ | In a noncompact locally compact group, a left-invariant measure which is positive
on open sets has infinite mass. | true |
ContinuousMultilinearMap.seminormedAddCommGroup._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι]
(x x_1 : ContinuousMultilinearMap ... | null | false |
Mathlib.Tactic.BicategoryLike.MkEvalComp.ctorIdx | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} → Mathlib.Tactic.BicategoryLike.MkEvalComp m → ℕ | null | false |
_private.Mathlib.NumberTheory.PythagoreanTriples.0.circleEquivGen._simp_4 | Mathlib.NumberTheory.PythagoreanTriples | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Std.DHashMap.Internal.AssocList.Const.toList_alter | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {a : α} {f : Option β → Option β}
{l : Std.DHashMap.Internal.AssocList α fun x => β},
(Std.DHashMap.Internal.AssocList.Const.alter a f l).toList.Perm (Std.Internal.List.Const.alterKey a f l.toList) | null | true |
Std.DHashMap.Raw.instRepr | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [Repr α] → [(a : α) → Repr (β a)] → Repr (Std.DHashMap.Raw α β) | null | true |
Std.TreeMap.maxKey!_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.maxKey! ∈ t | null | true |
Lean.Core.modifyCache | Lean.CoreM | (Lean.Core.Cache → Lean.Core.Cache) → Lean.CoreM Unit | null | true |
controlled_closure_of_complete | Mathlib.Analysis.Normed.Group.ControlledClosure | ∀ {G : Type u_1} [inst : NormedAddCommGroup G] [CompleteSpace G] {H : Type u_2} [inst_2 : NormedAddCommGroup H]
{f : NormedAddGroupHom G H} {K : AddSubgroup H} {C ε : ℝ},
0 < C → 0 < ε → f.SurjectiveOnWith K C → f.SurjectiveOnWith K.topologicalClosure (C + ε) | Given `f : NormedAddGroupHom G H` for some complete `G` and a subgroup `K` of `H`, if every
element `x` of `K` has a preimage under `f` whose norm is at most `C*‖x‖` then the same holds for
elements of the (topological) closure of `K` with constant `C+ε` instead of `C`, for any
positive `ε`.
| true |
instSMulDistribClassAlgEquiv | Mathlib.RingTheory.Invariant.Galois | ∀ (A : Type u_1) (K : Type u_2) (L : Type u_3) (B : Type u_4) [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : Field K] [inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : IsFractionRing A K]
[inst_7 : Algebra A B] [inst_8 : Algebra K L] [inst_9 : Algebra A L] [inst_10 : IsScalarTower A K ... | null | true |
UpperSet.instCommMonoid.eq_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α],
UpperSet.instCommMonoid =
{ toOne := UpperSet.instOne, toMul := UpperSet.commSemigroup.toMul, mul_assoc := ⋯, one_mul := ⋯, mul_one := ⋯,
npow := npowRecAuto, npow_zero := ⋯, npow_succ := ⋯, mul_comm := ⋯ } | null | true |
BoundedContinuousFunction.isBounded_range | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
(f : BoundedContinuousFunction α β), Bornology.IsBounded (Set.range ⇑f) | null | true |
Matrix.superFactorial_dvd_vandermonde_det | Mathlib.LinearAlgebra.Vandermonde | ∀ {n : ℕ} (v : Fin (n + 1) → ℤ), ↑n.superFactorial ∣ (Matrix.vandermonde v).det | null | true |
Filter.Germ.instRightCancelSemigroup | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → [RightCancelSemigroup M] → RightCancelSemigroup (l.Germ M) | null | true |
_private.Mathlib.NumberTheory.Fermat.0.Nat.prod_fermatNumber._proof_1_3 | Mathlib.NumberTheory.Fermat | ∀ (n : ℕ), 2 ^ (2 ^ n * 2) - 1 = 1 + 2 ^ (2 ^ n * 2) - 2 | null | false |
IsMinOn.bddBelow | Mathlib.Order.Filter.Extr | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {f : α → β} {s : Set α} {a : α}, IsMinOn f s a → BddBelow (f '' s) | null | true |
Lean.Parser.ParserCategory.mk | Lean.Parser.Basic | Lean.Name →
Lean.Parser.SyntaxNodeKindSet →
Lean.Parser.PrattParsingTables → Lean.Parser.LeadingIdentBehavior → Lean.Parser.ParserCategory | null | true |
Affine.Simplex.restrict_points_coe | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (s : Affine.Simplex k P n) (S : AffineSubspace k P)
(hS : affineSpan k (Set.range s.points) ≤ S) (i : Fin (n + 1)), ↑((s.restrict S hS).points i) = s.points i | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory._aux_Mathlib_CategoryTheory_Bicategory_Free___unexpand_CategoryTheory_FreeBicategory_Hom₂_right_unitor_inv_1 | Mathlib.CategoryTheory.Bicategory.Free | Lean.PrettyPrinter.Unexpander | null | false |
IsRelPrime.mul_add_left_left_iff | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y z : R}, IsRelPrime (y * z + x) y ↔ IsRelPrime x y | null | true |
Module.Relations.Solution.postcomp_var | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (solution : relations.Solution M) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(f : M →ₗ[A] N) (g : relations.G), (solution.postcomp f).var g = f (solution.var g) | null | true |
PiTensorProduct.lift._proof_7 | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : ι → Type u_3} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {E : Type u_4} [inst_3 : AddCommMonoid E] [inst_4 : Module R E]
(φ : MultilinearMap R s E) (x y : PiTensorProduct R fun i => s i),
(↑(PiTensorProduct.liftAux φ)).... | null | false |
Real.wrapped._@.Mathlib.Basic.Real.Basic.6358291._hygCtx._hyg.2 | Mathlib.Basic.Real.Basic | Subtype (Eq Real.definition✝) | null | false |
Lean.LeanOptionValue.ofString | Lean.Util.LeanOptions | String → Lean.LeanOptionValue | null | true |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.BoundedVariationOn.of_finset._proof_1_7 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} (s : Finset α), s.Nonempty → 0 < s.card → ∀ (i : Fin s.card), min (↑i) (s.card - 1) < s.card | null | false |
CategoryTheory.Comonad.Coalgebra.eilenbergMoore._proof_2 | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {G : CategoryTheory.Comonad C} {X Y : G.Coalgebra}
(f : X ⟶ Y), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f | null | false |
OrderType.type_ulift | Mathlib.Order.Types.Defs | ∀ {α : Type u} [inst : LinearOrder α], OrderType.type (ULift.{v, u} α) = OrderType.lift.{v, u} (OrderType.type α) | null | true |
MeasureTheory.measureReal_mono | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
s₁ ⊆ s₂ → autoParam (μ s₂ ≠ ⊤) MeasureTheory.measureReal_mono._auto_1 → μ.real s₁ ≤ μ.real s₂ | null | true |
upperBounds_Ioo | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeInf γ] [DenselyOrdered γ] {a b : γ}, b < a → upperBounds (Set.Ioo b a) = Set.Ici a | null | true |
CategoryTheory.Pretriangulated.shiftFunctorCompIsoId_op_inv_app._auto_1 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | Lean.Syntax | null | false |
Std.HashMap.Raw.contains_insert_self | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β}, (m.insert k v).contains k = true | null | true |
List.iSup_mem_map_of_exists_sSup_empty_le | Mathlib.Order.ConditionallyCompleteLattice.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : ConditionallyCompleteLinearOrder α] {l : List ι} (f : ι → α),
(∃ x ∈ l, sSup ∅ ≤ f x) → ⨆ x ∈ l, f x ∈ List.map f l | null | true |
UpperHalfPlane.metricSpaceAux._proof_3 | Mathlib.Analysis.Complex.UpperHalfPlane.Metric | uniformity UpperHalfPlane = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | dist p.1 p.2 < ε} | null | false |
DecidableLT._to_dual_cast_4 | Mathlib.Tactic.ToDual | (α : Type u) → [inst : LT α] → (DecidableRel fun a a_1 => a_1 < a) → DecidableLT α | null | false |
AddMonoid.Coprod.clift_apply_inl | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} {P : Type u_5} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass P] (f : FreeAddMonoid (M ⊕ N) →+ P) (hM₁ : f (FreeAddMonoid.of (Sum.inl 0)) = 0)
(hN₁ : f (FreeAddMonoid.of (Sum.inr 0)) = 0)
(hM :
∀ (x y : M),
f (FreeAddMonoid.of (Sum.inl (x + y))) ... | null | true |
UpperSet.instCompleteLinearOrder._proof_3 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LinearOrder α] (a b c : UpperSet α), a ≤ b → a ≤ c → a ≤ Lattice.inf b c | null | false |
PMF.toMeasure_bindOnSupport_apply | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} {β : Type u_2} {p : PMF α} (f : (a : α) → a ∈ p.support → PMF β) (s : Set β)
[inst : MeasurableSpace β],
MeasurableSet s → (p.bindOnSupport f).toMeasure s = ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h).toMeasure s | The measure of a set under `p.bindOnSupport f` is the sum over `a : α`
of the probability of `a` under `p` times the measure of the set under `f a _`.
The additional if statement is needed since `f` is only a partial function. | true |
_private.Mathlib.Analysis.Calculus.LHopital.0.HasDerivAt.lhopital_zero_nhdsNE._simp_1_2 | Mathlib.Analysis.Calculus.LHopital | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y = (Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) | null | false |
Polynomial.IsUnitTrinomial.irreducible_aux2 | Mathlib.Algebra.Polynomial.UnitTrinomial | ∀ {p q : Polynomial ℤ} {k m m' n : ℕ},
k < m →
m < n →
k < m' →
m' < n →
∀ (u v w : ℤˣ),
p = Polynomial.trinomial k m n ↑u ↑v ↑w →
q = Polynomial.trinomial k m' n ↑u ↑v ↑w → p * p.mirror = q * q.mirror → q = p ∨ q = p.mirror | null | true |
Filter.sup_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g : Filter β), (f₁ ⊔ f₂) ×ˢ g = f₁ ×ˢ g ⊔ f₂ ×ˢ g | null | true |
Ring.DirectLimit.of._proof_2 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_2) [inst_1 : (i : ι) → CommRing (G i)]
(f : (i j : ι) → i ≤ j → G i → G j) (i : ι),
(Ideal.Quotient.mk
(Ideal.span
{a |
(∃ i j, ∃ (H : i ≤ j), ∃ x, FreeCommRing.of ⟨j, f i j H x⟩ - FreeCommRing.of ⟨i, x⟩ = a) ∨
(∃ i, Fr... | null | false |
LieAlgebra.isNilpotent_range_ad_iff._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L],
LieRing.IsNilpotent ↥(LieAlgebra.ad R L).range = LieRing.IsNilpotent L | null | false |
ProbabilityTheory.Kernel.Invariant.eq_1 | Mathlib.Probability.Kernel.Invariance | ∀ {α : Type u_1} {mα : MeasurableSpace α} (κ : ProbabilityTheory.Kernel α α) (μ : MeasureTheory.Measure α),
κ.Invariant μ = (μ.bind ⇑κ = μ) | null | true |
_private.Lean.Meta.Tactic.Try.Collect.0.Lean.Meta.Try.Collector.saveFunInd.match_1 | Lean.Meta.Tactic.Try.Collect | (motive : Option Lean.Meta.FunIndInfo → Sort u_1) →
(__do_lift : Option Lean.Meta.FunIndInfo) →
((funIndInfo : Lean.Meta.FunIndInfo) → motive (some funIndInfo)) →
((x : Option Lean.Meta.FunIndInfo) → motive x) → motive __do_lift | null | false |
Lean.Elab.Term.SyntheticMVarDecl.noConfusion | Lean.Elab.Term.TermElabM | {P : Sort u} →
{t t' : Lean.Elab.Term.SyntheticMVarDecl} → t = t' → Lean.Elab.Term.SyntheticMVarDecl.noConfusionType P t t' | null | false |
CategoryTheory.MonoidalSingleObj.endMonoidalStarFunctorEquivalence | Mathlib.CategoryTheory.Bicategory.SingleObj | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
CategoryTheory.EndMonoidal (CategoryTheory.MonoidalSingleObj.star C) ≌ C | The equivalence between the endomorphisms of the single object
when we promote a monoidal category to a single object bicategory,
and the original monoidal category.
| true |
Stream'.Seq.lt_length_iff | Mathlib.Data.Seq.Basic | ∀ {α : Type u} {s : Stream'.Seq α} {n : ℕ} {h : s.Terminates}, n < s.length h ↔ ∃ a, a ∈ s.get? n | The statement of `length_le_iff` assumes that the sequence terminates. For a
statement of the where the sequence is not known to terminate see `length_le_iff'`. | true |
Lean.IR.LocalContext.isParam | Lean.Compiler.IR.Basic | Lean.IR.LocalContext → Lean.IR.Index → Bool | null | true |
Inclusion.ExprInclusion.rec | Mathlib.Tactic.Inclusion.Core.Types | {motive : Inclusion.ExprInclusion → Sort u} →
((inclusion proof : Lean.Expr) → motive { inclusion := inclusion, proof := proof }) →
(t : Inclusion.ExprInclusion) → motive t | null | false |
FinEnum.card_punit | Mathlib.Data.FinEnum | FinEnum.card PUnit.{u_1 + 1} = 1 | null | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.integrable_gaussianPDFReal._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
PiNat.mem_cylinder_iff_dist_le | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} {x y : (n : ℕ) → E n} {n : ℕ}, y ∈ PiNat.cylinder x n ↔ dist y x ≤ (1 / 2) ^ n | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.tuple._regBuiltin.Lean.Parser.Term.tuple.parenthesizer_13 | Lean.Parser.Term | IO Unit | null | false |
TangentBundle.chartAt | Mathlib.Geometry.Manifold.VectorBundle.Tangent | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_4} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_6}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [inst_6 : IsManifold I 1 M] (p : Tangen... | null | true |
Fin2.fz.noConfusion | Mathlib.Data.Fin.Fin2 | {P : Sort u} → {n n' : ℕ} → n + 1 = n' + 1 → Fin2.fz ≍ Fin2.fz → (n = n' → P) → P | null | false |
_private.Mathlib.RingTheory.Unramified.LocalStructure.0.Algebra.IsUnramifiedAt.exists_hasStandardEtaleSurjectionOn_of_exists_adjoin_singleton_eq_top_aux₂._simp_1_2 | Mathlib.RingTheory.Unramified.LocalStructure | ∀ {R : Type uR} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (b : B), 1 ⊗ₜ[R] b = (algebraMap B (TensorProduct R A B)) b | null | false |
dotProduct_self_star_nonneg._simp_1 | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : PartialOrder R] [inst_2 : NonUnitalRing R]
[inst_3 : StarRing R] [StarOrderedRing R] (v : n → R), (0 ≤ v ⬝ᵥ star v) = True | null | false |
Matroid.RankFinite.exists_finite_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} [self : M.RankFinite], ∃ B, M.IsBase B ∧ B.Finite | There is a finite base | true |
GradedLieModule | Mathlib.Algebra.Lie.Graded | {ι : Type u_1} →
{κ : Type u_2} →
{R : Type u_5} →
{L : Type u_6} →
{M : Type u_7} →
[inst : DecidableEq ι] →
[inst_1 : AddCommMonoid ι] →
[inst_2 : CommRing R] →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
... | A class that ensures a Lie algebra has a bracket that preserves a decomposition. | true |
CategoryTheory.Limits.Cocone.toCostructuredArrowCocone._proof_2 | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
{K : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cocone K) (F : CategoryTheory.Functor C D) {X : D}
(f : F.obj c.p... | null | false |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.recOn | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{X Y : C} →
... | null | false |
_private.Mathlib.Order.BooleanAlgebra.Set.0.Set.ssubset_iff_sdiff_singleton._proof_1_1 | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α}, s ⊂ t ↔ ∃ a ∈ t, s ⊆ t \ {a} | null | false |
CategoryTheory.Limits.MultispanIndex.sndSigmaMapOfIsColimit.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) {c : CategoryTheory.Limits.Cofan I.left}
(d : CategoryTheory.Limits.Cofan I.right) (hc : CategoryTheory.Limits.IsColimit c),
I.sndSigmaMapOfIsColimit d hc =
Catego... | null | true |
_private.Mathlib.Dynamics.TopologicalEntropy.Semiconj.0.Dynamics.IsDynCoverOf.preimage._simp_1_4 | Mathlib.Dynamics.TopologicalEntropy.Semiconj | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {p : α → Prop} {q : β → Prop},
(∃ b, (∃ a, p a ∧ f a = b) ∧ q b) = ∃ a, p a ∧ q (f a) | null | false |
Lean.Compiler.LCNF.SimpleGroundArg.ctorElim | Lean.Compiler.LCNF.SimpleGroundExpr | {motive : Lean.Compiler.LCNF.SimpleGroundArg → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Compiler.LCNF.SimpleGroundArg) →
ctorIdx = t.ctorIdx → Lean.Compiler.LCNF.SimpleGroundArg.ctorElimType ctorIdx → motive t | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.Poly.isUnsatEq.match_1.eq_2 | Init.Data.Int.Linear | ∀ (motive : Int.Internal.Linear.Poly → Sort u_1) (x : Int.Internal.Linear.Poly)
(h_1 : (k : ℤ) → motive (Int.Internal.Linear.Poly.num k)) (h_2 : (x : Int.Internal.Linear.Poly) → motive x),
(∀ (k : ℤ), x = Int.Internal.Linear.Poly.num k → False) →
(match x with
| Int.Internal.Linear.Poly.num k => h_1 k
... | null | true |
SimpleGraph.Subgraph.coe._proof_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G' : G.Subgraph), Std.Symm (Function.onFun G'.Adj Subtype.val) | null | false |
_private.Mathlib.FieldTheory.KummerExtension.0.isSplittingField_X_pow_sub_C_of_root_adjoin_eq_top.match_1_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
(motive : (primitiveRoots (Module.finrank K L) K).Nonempty → Prop)
(hK : (primitiveRoots (Module.finrank K L) K).Nonempty),
(∀ (w : K) (hζ : w ∈ primitiveRoots (Module.finrank K L) K), motive ⋯) → motive hK | null | false |
RestrictedProduct.homeoBot._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)},
Function.LeftInverse (fun f i => f i) fun f => ⟨fun i => f i, ⋯⟩ | null | false |
IsScalarTower.invertibleAlgebraCoeNat._proof_1 | Mathlib.RingTheory.AlgebraTower | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (n : ℕ)
(this : Invertible ((algebraMap ℕ R) n)), (↑↑(algebraMap R A)).1 ⅟((algebraMap ℕ R) n) * ↑n = 1 | null | false |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.sum_div_pow_sq_le_div_sq._simp_1_9 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
CategoryTheory.Limits.isColimitCoconeOfHasColimitCurryCompColim._proof_2 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_5} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_5} J]
[inst_1 : CategoryTheory.Category.{u_4, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
(G : CategoryTheory.Functor (J × K) C) [inst_3 : CategoryTheory.Limits.HasColimitsOfShape K C]
[inst_4 : CategoryTheory.Limit... | null | false |
IsMulFreimanHom.inv | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : DivisionCommMonoid β] {A : Set α} {B : Set β}
{f : α → β} {n : ℕ}, IsMulFreimanHom n A B f → IsMulFreimanHom n A B⁻¹ f⁻¹ | null | true |
_private.Mathlib.Algebra.Polynomial.Expand.0.Polynomial.contract_mul_expand._simp_1_2 | Mathlib.Algebra.Polynomial.Expand | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
_private.Mathlib.SetTheory.Ordinal.Arithmetic.0.Ordinal.lt_omega0._simp_1_2 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {c : Cardinal.{u_1}} {o : Ordinal.{u_1}}, (o < c.ord) = (o.card < c) | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.recOn | Init.Data.Format.Basic | {motive : Std.Format.SpaceResult✝ → Sort u} →
(t : Std.Format.SpaceResult✝) →
((foundLine foundFlattenedHardLine : Bool) →
(space : ℕ) →
motive { foundLine := foundLine, foundFlattenedHardLine := foundFlattenedHardLine, space := space }) →
motive t | null | false |
CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans_map_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C C} (α : F ⟶ G)
{X Y : CategoryTheory.Endofunctor.Coalgebra F} (f : X ⟶ Y),
((CategoryTheory.Endofunctor.Coalgebra.functorOfNatTrans α).map f).f = f.f | null | true |
CategoryTheory.Limits.PreservesColimit.rec | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | null | false |
CommRingCat.Colimits.Prequotient._sizeOf_inst | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
(F : CategoryTheory.Functor J CommRingCat) → [SizeOf J] → SizeOf (CommRingCat.Colimits.Prequotient F) | null | false |
Lean.Elab.Tactic.SimpKind.casesOn | Lean.Elab.Tactic.Simp | {motive : Lean.Elab.Tactic.SimpKind → Sort u} →
(t : Lean.Elab.Tactic.SimpKind) →
motive Lean.Elab.Tactic.SimpKind.simp →
motive Lean.Elab.Tactic.SimpKind.simpAll → motive Lean.Elab.Tactic.SimpKind.dsimp → motive t | null | false |
_private.Mathlib.Topology.MetricSpace.Thickening.0.Metric.eventually_notMem_thickening_of_infEDist_pos._simp_1_2 | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) | null | false |
Function.Embedding.refl_trans | Mathlib.Logic.Embedding.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α ↪ β), (Function.Embedding.refl α).trans f = f | null | true |
PresheafOfModules.surjective_of_epi | Mathlib.Algebra.Category.ModuleCat.Presheaf.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (f : M₁ ⟶ M₂) [CategoryTheory.Epi f] (X : Cᵒᵖ),
Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (f.app X)) | null | true |
iInf_lt_top._simp_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, (⨅ i, s i < ⊤) = ∃ i, s i < ⊤ | null | false |
CategoryTheory.Limits.pushout_inl_inv_inr_of_right_isIso_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
[inst_1 : CategoryTheory.IsIso f] {Z_1 : C} (h : Z ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inl f g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.inv (CategoryTheory.Limits.push... | null | true |
SSet.oneTruncation₂._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {X Y Z : SSet.Truncated 2} (f : X ⟶ Y) (g : Y ⟶ Z),
SSet.OneTruncation₂.map (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (SSet.OneTruncation₂.map f) (SSet.OneTruncation₂.map g) | null | false |
_private.Mathlib.Order.Bounded.0.Set.unbounded_ge_of_forall_exists_gt.match_1_1 | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : Preorder α] (a : α) (motive : (∃ b ∈ s, b < a) → Prop) (x : ∃ b ∈ s, b < a),
(∀ (b : α) (hb : b ∈ s) (hb' : b < a), motive ⋯) → motive x | null | false |
Lean.Widget.instRpcEncodableInteractiveGoal.enc._@.Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveGoal → StateM Lean.Server.RpcObjectStore Lean.Json | null | false |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.infer.getParamInfo.match_5 | Lean.Compiler.LCNF.InferBorrow | (motive : Option (Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) → Sort u_1) →
(x : Option (Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure))) →
((ps : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure)) → motive (some ps)) →
(Unit → motive none) → motive ... | null | false |
MulHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [Mul M] → [Mul N] → [FunLike F M N] → Prop | `MulHomClass F M N` states that `F` is a type of multiplication-preserving homomorphisms.
You should declare an instance of this typeclass when you extend `MulHom`.
| true |
Homeomorph.compStarAlgEquiv'._proof_10 | Mathlib.Topology.ContinuousMap.Star | ∀ {X : Type u_3} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (𝕜 : Type u_4)
[inst_2 : CommSemiring 𝕜] (A : Type u_2) [inst_3 : TopologicalSpace A] [inst_4 : Semiring A]
[inst_5 : IsTopologicalSemiring A] [inst_6 : StarRing A] [inst_7 : ContinuousStar A] [inst_8 : Algebra 𝕜 A]
(f : ... | null | false |
instReprBinaryTree.repr._sunfold | Mathlib.Data.Tree.Basic | {α : Type u_1} → [Repr α] → BinaryTree α → ℕ → Std.Format | null | false |
TopologicalSpace.OpenNhdsOf.mk.sizeOf_spec | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {x : α} [inst_1 : SizeOf α] (toOpens : TopologicalSpace.Opens α)
(mem' : x ∈ toOpens.carrier), sizeOf { toOpens := toOpens, mem' := mem' } = 1 + sizeOf toOpens + sizeOf mem' | null | true |
Std.HashSet.Raw.contains_empty | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α}, ∅.contains a = false | null | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.add_bmod_eq_add_bmod_left._simp_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {n : ℕ} {y : ℤ} (i : ℤ), ((i + x).bmod n = (i + y).bmod n) = (x.bmod n = y.bmod n) | null | false |
Lean.Parser.Term.ensureTypeOf | Lean.Parser.Term | Lean.Parser.Parser | null | true |
EuclideanGeometry.angle_eq_of_oangle_eq | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ p₄ p₅ p₆ : P},
EuclideanGeometry.oangle p₁ p₂ p₃ = EuclideanGeometry.oangle ... | If two oriented angles are equal, and the four endpoint pairs are nondegenerate, then the
corresponding unoriented angles are equal. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.