name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Reflective.casesOn | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{R : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Reflective R → Sort u} →
(t : CategoryTheory.Reflective R) →
([toFull : R.Full] →
[toFaithful : R.Faithful] →
(L : CategoryTheory.Functor C D) →
(adj : L ⊣ R) → motive { toFull := toFull, toFaithful := toFaithful, L := L, adj := adj }) →
motive t |
AddMonCat.of | Mathlib.Algebra.Category.MonCat.Basic | (M : Type u) → [AddMonoid M] → AddMonCat |
Module.subsingleton_of_rank_zero | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [StrongRankCondition R] [inst_2 : AddCommMonoid M] [inst_3 : Module R M]
[Module.Free R M], Module.rank R M = 0 → Subsingleton M |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.crown._proof_1_2 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {k₁ k₂ : C} {ι : Type u_3} (j : Option ι → C)
(f : (i : Option ι) → j i ⟶ k₁) (g : (i : Option ι) → j i ⟶ k₂) (s₁ : C) (α₁ : k₁ ⟶ s₁) (β₁ : k₂ ⟶ s₁),
(∀ (i : ι), CategoryTheory.CategoryStruct.comp (f (some i)) α₁ = CategoryTheory.CategoryStruct.comp (g (some i)) β₁) →
∀ (t : C) (α : s₁ ⟶ t) (val : ι),
CategoryTheory.CategoryStruct.comp (f (some val)) (CategoryTheory.CategoryStruct.comp α₁ α) =
CategoryTheory.CategoryStruct.comp (g (some val)) (CategoryTheory.CategoryStruct.comp β₁ α) |
_private.Mathlib.Algebra.Lie.Weights.Killing.0.LieAlgebra.IsKilling.corootSpace_eq_bot_iff._simp_1_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M), (N = ⊥) = (↑N = ⊥) |
_private.Mathlib.Algebra.Lie.Semisimple.Basic.0.LieAlgebra.IsSemisimple.isSimple_of_isAtom._simp_1_12 | Mathlib.Algebra.Lie.Semisimple.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊥) = (x = 0) |
isZGroup_of_coprime | Mathlib.GroupTheory.SpecificGroups.ZGroup | ∀ {G : Type u_1} {G' : Type u_2} {G'' : Type u_3} [inst : Group G] [inst_1 : Group G'] [inst_2 : Group G'']
{f : G →* G'} {f' : G' →* G''} [Finite G] [IsZGroup G] [IsZGroup G''],
f'.ker ≤ f.range → (Nat.card G).Coprime (Nat.card G'') → IsZGroup G' |
Lean.instToExprListOfToLevel | Lean.ToExpr | {α : Type u} → [Lean.ToLevel] → [Lean.ToExpr α] → Lean.ToExpr (List α) |
CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor_obj_left_right_as | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor T D) (Y : D) (X : T)
(Y_1 : CategoryTheory.CostructuredArrow (CategoryTheory.CostructuredArrow.proj F Y) X),
((CategoryTheory.CostructuredArrow.ofCostructuredArrowProjEquivalence.functor F Y X).obj Y_1).left.right.as =
PUnit.unit |
Order.krullDim_eq_zero | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α] [Subsingleton α], Order.krullDim α = 0 |
AlgebraicGeometry.Scheme.AffineCover.noConfusionType | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | Sort u_1 →
{P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S : AlgebraicGeometry.Scheme} →
AlgebraicGeometry.Scheme.AffineCover P S →
{P' : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} →
{S' : AlgebraicGeometry.Scheme} → AlgebraicGeometry.Scheme.AffineCover P' S' → Sort u_1 |
MvPowerSeries.coeff_index_single_self_X | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (s : σ), (MvPowerSeries.coeff fun₀ | s => 1) (MvPowerSeries.X s) = 1 |
_private.Lean.Server.FileWorker.SemanticHighlighting.0.Lean.Server.FileWorker.splitStr | Lean.Server.FileWorker.SemanticHighlighting | Lean.FileMap → Lean.Syntax → Array Lean.Syntax |
Computation.think.eq_1 | Mathlib.Data.Seq.Computation | ∀ {α : Type u} (c : Computation α), c.think = ⟨Stream'.cons none ↑c, ⋯⟩ |
HeytingHom.mk | Mathlib.Order.Heyting.Hom | {α : Type u_6} →
{β : Type u_7} →
[inst : HeytingAlgebra α] →
[inst_1 : HeytingAlgebra β] →
(toLatticeHom : LatticeHom α β) →
toLatticeHom.toFun ⊥ = ⊥ →
(∀ (a b : α), toLatticeHom.toFun (a ⇨ b) = toLatticeHom.toFun a ⇨ toLatticeHom.toFun b) → HeytingHom α β |
Matrix.eq_zero_of_vecMul_eq_zero | Mathlib.LinearAlgebra.Matrix.Nondegenerate | ∀ {m : Type u_1} {A : Type u_4} [inst : Fintype m] [inst_1 : CommRing A] [IsDomain A] [inst_3 : DecidableEq m]
{M : Matrix m m A}, M.det ≠ 0 → ∀ {v : m → A}, Matrix.vecMul v M = 0 → v = 0 |
CategoryTheory.Functor.WellOrderInductionData.Extension.mk.injEq | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type v)}
{d : F.WellOrderInductionData} [inst_2 : OrderBot J] {val₀ : F.obj (Opposite.op ⊥)} {j : J}
(val : F.obj (Opposite.op j)) (map_zero : F.map (CategoryTheory.homOfLE ⋯).op val = val₀)
(map_succ :
∀ (i : J) (hi : i < j),
F.map (CategoryTheory.homOfLE ⋯).op val = d.succ i ⋯ (F.map (CategoryTheory.homOfLE ⋯).op val))
(map_limit :
∀ (i : J) (hi : Order.IsSuccLimit i) (hij : i ≤ j),
F.map (CategoryTheory.homOfLE hij).op val =
d.lift i hi
⟨fun x =>
match x with
| Opposite.op ⟨k, hk⟩ => F.map (CategoryTheory.homOfLE ⋯).op val,
⋯⟩)
(val_1 : F.obj (Opposite.op j)) (map_zero_1 : F.map (CategoryTheory.homOfLE ⋯).op val_1 = val₀)
(map_succ_1 :
∀ (i : J) (hi : i < j),
F.map (CategoryTheory.homOfLE ⋯).op val_1 = d.succ i ⋯ (F.map (CategoryTheory.homOfLE ⋯).op val_1))
(map_limit_1 :
∀ (i : J) (hi : Order.IsSuccLimit i) (hij : i ≤ j),
F.map (CategoryTheory.homOfLE hij).op val_1 =
d.lift i hi
⟨fun x =>
match x with
| Opposite.op ⟨k, hk⟩ => F.map (CategoryTheory.homOfLE ⋯).op val_1,
⋯⟩),
({ val := val, map_zero := map_zero, map_succ := map_succ, map_limit := map_limit } =
{ val := val_1, map_zero := map_zero_1, map_succ := map_succ_1, map_limit := map_limit_1 }) =
(val = val_1) |
Std.TreeMap.Raw.Equiv.insertManyIfNewUnit_list | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {t₁ t₂ : Std.TreeMap.Raw α Unit cmp},
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (l : List α), (t₁.insertManyIfNewUnit l).Equiv (t₂.insertManyIfNewUnit l) |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs.0.IsLinearSet.closure._simp_1_4 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Defs | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c |
Std.Net.SocketAddressV6.mk | Std.Net.Addr | Std.Net.IPv6Addr → UInt16 → Std.Net.SocketAddressV6 |
_private.Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit.0.CochainComplex.mappingConeHomOfDegreewiseSplitIso._proof_4 | Mathlib.Algebra.Homology.HomotopyCategory.DegreewiseSplit | ∀ (p : ℤ), p + 1 + 1 + -1 = p + 1 |
Nat.gcd_sub_mul_right_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, k * m ≤ n → m.gcd (n - k * m) = m.gcd n |
SimpleGraph.pathGraph3ComplEmbeddingOf._proof_1 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u_1} {G : SimpleGraph α} (h : ¬G.IsCompleteMultipartite), ∃ w₁ w₂, G.IsPathGraph3Compl ⋯.choose w₁ w₂ |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.List.0.Std.Iterators.Types.ListIterator.instIterator.match_3.splitter | Std.Data.Iterators.Lemmas.Producers.Monadic.List | {m : Type u_1 → Type u_2} →
{α : Type u_1} →
(motive : Std.IterM m α → Sort u_3) →
(it : Std.IterM m α) →
(Unit → motive { internalState := { list := [] } }) →
((x : α) → (xs : List α) → motive { internalState := { list := x :: xs } }) → motive it |
Int64.toInt_sub | Init.Data.SInt.Lemmas | ∀ (a b : Int64), (a - b).toInt = (a.toInt - b.toInt).bmod (2 ^ 64) |
CategoryTheory.is_coprod_iff_isPushout | Mathlib.CategoryTheory.Adhesive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X E Y YE : C} (c : CategoryTheory.Limits.BinaryCofan X E)
(hc : CategoryTheory.Limits.IsColimit c) {f : X ⟶ Y} {iY : Y ⟶ YE} {fE : c.pt ⟶ YE},
CategoryTheory.CommSq f c.inl iY fE →
(Nonempty
(CategoryTheory.Limits.IsColimit
(CategoryTheory.Limits.BinaryCofan.mk (CategoryTheory.CategoryStruct.comp c.inr fE) iY)) ↔
CategoryTheory.IsPushout f c.inl iY fE) |
Algebra.TensorProduct.algHomOfLinearMapTensorProduct._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} [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] [IsScalarTower R S A], SMulCommClass R S A |
_private.Mathlib.LinearAlgebra.Goursat.0.Submodule.goursat._simp_1_6 | Mathlib.LinearAlgebra.Goursat | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {x : M₂}, (x ∈ f.range) = ∃ y, f y = x |
Matroid.contract_inter_ground_eq | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} (M : Matroid α) (C : Set α), M.contract (C ∩ M.E) = M.contract C |
Commute.isNilpotent_mul_left_iff | Mathlib.RingTheory.Nilpotent.Basic | ∀ {R : Type u_1} {x y : R} [inst : Semiring R],
Commute x y → x ∈ nonZeroDivisorsLeft R → (IsNilpotent (x * y) ↔ IsNilpotent y) |
_private.Mathlib.Data.Set.Image.0.Set.preimage_eq_empty_iff._simp_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s |
AddCircle.gcd_mul_addOrderOf_div_eq | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] (p : 𝕜) [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] [hp : Fact (0 < p)] {n : ℕ}
(m : ℕ), 0 < n → m.gcd n * addOrderOf ↑(↑m / ↑n * p) = n |
Std.Internal.Parsec.ParseResult.success.noConfusion | Std.Internal.Parsec.Basic | {α ι : Type} →
{P : Sort u} →
{pos : ι} →
{res : α} →
{pos' : ι} →
{res' : α} →
Std.Internal.Parsec.ParseResult.success pos res = Std.Internal.Parsec.ParseResult.success pos' res' →
(pos ≍ pos' → res ≍ res' → P) → P |
Finset.mem_addAntidiagonal._simp_1 | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α] {s t : Set α}
{hs : s.IsPWO} {ht : t.IsPWO} {a : α} {x : α × α},
(x ∈ Finset.addAntidiagonal hs ht a) = (x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 + x.2 = a) |
Std.DHashMap.Raw.toList_insert_perm | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k : α} {v : β k},
(m.insert k v).toList.Perm (⟨k, v⟩ :: List.filter (fun x => decide ¬(k == x.fst) = true) m.toList) |
CategoryTheory.Functor.CoconeTypes.IsColimit.equiv.congr_simp | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {F : CategoryTheory.Functor J (Type w₀)} {c : F.CoconeTypes}
(hc : c.IsColimit), hc.equiv = hc.equiv |
Lean.Parser.TokenCacheEntry.startPos._default | Lean.Parser.Types | String.Pos.Raw |
_private.Mathlib.Util.AtomM.Recurse.0.Mathlib.Tactic.AtomM.Recurse.instBEqConfig.beq.match_1 | Mathlib.Util.AtomM.Recurse | (motive : Mathlib.Tactic.AtomM.Recurse.Config → Mathlib.Tactic.AtomM.Recurse.Config → Sort u_1) →
(x x_1 : Mathlib.Tactic.AtomM.Recurse.Config) →
((a : Lean.Meta.TransparencyMode) →
(a_1 a_2 : Bool) →
(b : Lean.Meta.TransparencyMode) →
(b_1 b_2 : Bool) →
motive { red := a, zetaDelta := a_1, contextual := a_2 }
{ red := b, zetaDelta := b_1, contextual := b_2 }) →
((x x_2 : Mathlib.Tactic.AtomM.Recurse.Config) → motive x x_2) → motive x x_1 |
ContMDiffWithinAt.clm_postcomp | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : 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] {F₁ : Type u_8} [inst_6 : NormedAddCommGroup F₁]
[inst_7 : NormedSpace 𝕜 F₁] {F₂ : Type u_9} [inst_8 : NormedAddCommGroup F₂] [inst_9 : NormedSpace 𝕜 F₂]
{F₃ : Type u_10} [inst_10 : NormedAddCommGroup F₃] [inst_11 : NormedSpace 𝕜 F₃] {n : WithTop ℕ∞} {f : M → F₂ →L[𝕜] F₃}
{s : Set M} {x : M},
ContMDiffWithinAt I (modelWithCornersSelf 𝕜 (F₂ →L[𝕜] F₃)) n f s x →
ContMDiffWithinAt I (modelWithCornersSelf 𝕜 ((F₁ →L[𝕜] F₂) →L[𝕜] F₁ →L[𝕜] F₃)) n
(fun y => ContinuousLinearMap.postcomp F₁ (f y)) s x |
OrderMonoidHom.fst._proof_1 | Mathlib.Algebra.Order.Monoid.Lex | ∀ (α : Type u_1) (β : Type u_2) [inst : Monoid α] [inst_1 : PartialOrder α] [inst_2 : Monoid β] [inst_3 : Preorder β],
Monotone ⇑(MonoidHom.fst α β) |
OrderMonoidWithZeroHom._sizeOf_inst | Mathlib.Algebra.Order.Hom.MonoidWithZero | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : MulZeroOneClass α} → {inst_3 : MulZeroOneClass β} → [SizeOf α] → [SizeOf β] → SizeOf (α →*₀o β) |
SSet.N.mk_surjective | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} (x : X.N), ∃ n y, x = SSet.N.mk ↑y ⋯ |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Cell.Const.get?.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_2} →
{β : Type u_1} →
(motive : Option ((_ : α) × β) → Sort u_3) →
(x : Option ((_ : α) × β)) → (Unit → motive none) → ((p : (_ : α) × β) → motive (some p)) → motive x |
MeasureTheory.ae_mem_iff_measure_eq | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ] {s : Set α},
MeasureTheory.NullMeasurableSet s μ → ((∀ᵐ (a : α) ∂μ, a ∈ s) ↔ μ s = μ Set.univ) |
_private.Mathlib.NumberTheory.LSeries.Nonvanishing.0.DirichletCharacter.zetaMul_prime_pow_nonneg._simp_1_2 | Mathlib.NumberTheory.LSeries.Nonvanishing | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} {n : ℕ} [IsReduced M₀] [Nontrivial M₀],
(a ^ n = 0) = (a = 0 ∧ n ≠ 0) |
Filter.mem_sup | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f g : Filter α} {s : Set α}, s ∈ f ⊔ g ↔ s ∈ f ∧ s ∈ g |
CategoryTheory.ShortComplex.leftHomologyFunctorOpNatIso._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasKernels C] [inst_3 : CategoryTheory.Limits.HasCokernels C]
[inst_4 : CategoryTheory.Limits.HasKernels Cᵒᵖ] [inst_5 : CategoryTheory.Limits.HasCokernels Cᵒᵖ]
{X Y : (CategoryTheory.ShortComplex C)ᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.ShortComplex.leftHomologyFunctor C).op.map f)
((fun S => (Opposite.unop S).rightHomologyOpIso.symm) Y).hom =
CategoryTheory.CategoryStruct.comp ((fun S => (Opposite.unop S).rightHomologyOpIso.symm) X).hom
(((CategoryTheory.ShortComplex.opFunctor C).comp (CategoryTheory.ShortComplex.rightHomologyFunctor Cᵒᵖ)).map f) |
AffineMap.instFunLike | Mathlib.LinearAlgebra.AffineSpace.AffineMap | (k : Type u_1) →
{V1 : Type u_2} →
(P1 : Type u_3) →
{V2 : Type u_4} →
(P2 : Type u_5) →
[inst : Ring k] →
[inst_1 : AddCommGroup V1] →
[inst_2 : Module k V1] →
[inst_3 : AddTorsor V1 P1] →
[inst_4 : AddCommGroup V2] →
[inst_5 : Module k V2] → [inst_6 : AddTorsor V2 P2] → FunLike (P1 →ᵃ[k] P2) P1 P2 |
Lean.Parser.Term.panic._regBuiltin.Lean.Parser.Term.panic.declRange_5 | Lean.Parser.Term | IO Unit |
continuousAt_nsmul | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] [ContinuousAdd M] (x : M) (n : ℕ),
ContinuousAt (fun x => n • x) x |
List.idxOf_cons_ne | Mathlib.Data.List.Basic | ∀ {α : Type u} [inst : BEq α] [LawfulBEq α] {a b : α} (l : List α),
b ≠ a → List.idxOf a (b :: l) = (List.idxOf a l).succ |
_private.Mathlib.RingTheory.Nullstellensatz.0.MvPolynomial.eq_vanishingIdeal_singleton_of_isMaximal._simp_1_1 | Mathlib.RingTheory.Nullstellensatz | ∀ {α : Type u} [inst : Semiring α] {I J : Ideal α}, (I = J) = ∀ (x : α), x ∈ I ↔ x ∈ J |
WeierstrassCurve.variableChange_a₂ | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R),
(C • W).a₂ = ↑C.u⁻¹ ^ 2 * (W.a₂ - C.s * W.a₁ + 3 * C.r - C.s ^ 2) |
Lean.JsonRpc.MessageMetaData.response.elim | Lean.Data.JsonRpc | {motive : Lean.JsonRpc.MessageMetaData → Sort u} →
(t : Lean.JsonRpc.MessageMetaData) →
t.ctorIdx = 2 → ((id : Lean.JsonRpc.RequestID) → motive (Lean.JsonRpc.MessageMetaData.response id)) → motive t |
CategoryTheory.Limits.imageSubobject_arrow_comp | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasImage f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImageSubobject f)
(CategoryTheory.Limits.imageSubobject f).arrow =
f |
RootPairing.EmbeddedG2.longRoot | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | {ι : 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] → (P : RootPairing ι R M N) → [P.EmbeddedG2] → M |
Ordinal.exists_lsub_cof | Mathlib.SetTheory.Cardinal.Cofinality | ∀ (o : Ordinal.{u}), ∃ ι f, Ordinal.lsub f = o ∧ Cardinal.mk ι = o.cof |
Int.ediv_of_neg_of_pos | Mathlib.Data.Int.Init | ∀ {a b : ℤ}, a < 0 → 0 < b → a.ediv b = -((-a - 1) / b + 1) |
Complex.norm_natCast_cpow_of_pos | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {n : ℕ}, 0 < n → ∀ (s : ℂ), ‖↑n ^ s‖ = ↑n ^ s.re |
_private.Mathlib.Algebra.Homology.DerivedCategory.TStructure.0.DerivedCategory.isGE_Q_obj_iff._simp_1_2 | Mathlib.Algebra.Homology.DerivedCategory.TStructure | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : CochainComplex C ℤ) (n : ℤ), K.IsGE n = ∀ i < n, HomologicalComplex.ExactAt K i |
PresheafOfModules.homMk._proof_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (φ : M₁.presheaf ⟶ M₂.presheaf) (X : Cᵒᵖ) (x y : ↑(M₁.1 X)),
(CategoryTheory.ConcreteCategory.hom (φ.app X)) (x + y) =
(CategoryTheory.ConcreteCategory.hom (φ.app X)) x + (CategoryTheory.ConcreteCategory.hom (φ.app X)) y |
WType.brecOn | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{motive : WType β → Sort u} → (t : WType β) → ((t : WType β) → WType.below t → motive t) → motive t |
Char.any | Batteries.Data.Char.Basic | (Char → Bool) → Bool |
IsScalarTower.of_compHom | Mathlib.Algebra.Algebra.Tower | ∀ (R : Type u) (A : Type w) (M : Type v₁) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : MulAction A M], IsScalarTower R A M |
OrthonormalBasis.repr_injective | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι], Function.Injective OrthonormalBasis.repr |
ShiftRight.recOn | Init.Prelude | {α : Type u} →
{motive : ShiftRight α → Sort u_1} →
(t : ShiftRight α) → ((shiftRight : α → α → α) → motive { shiftRight := shiftRight }) → motive t |
_private.Mathlib.Data.Finsupp.Order.0.Finsupp.support_sup._simp_1_2 | Mathlib.Data.Finsupp.Order | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (a = 0) = (a ≤ 0) |
CategoryTheory.ModObj.rec | Mathlib.CategoryTheory.Monoidal.Mod_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] →
{M : C} →
[inst_4 : CategoryTheory.MonObj M] →
{X : D} →
{motive : CategoryTheory.ModObj M X → Sort u} →
((smul : CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionObj M X ⟶ X) →
(one_smul' :
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft
CategoryTheory.MonObj.one X)
smul =
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso X).hom) →
(mul_smul' :
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomLeft
CategoryTheory.MonObj.mul X)
smul =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionAssocIso M M X).hom
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHomRight M smul)
smul)) →
motive { smul := smul, one_smul' := one_smul', mul_smul' := mul_smul' }) →
(t : CategoryTheory.ModObj M X) → motive t |
RingHom.closure_preimage_le | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) (s : Set S),
Subring.closure (⇑f ⁻¹' s) ≤ Subring.comap f (Subring.closure s) |
Finset.add_subset_add_left | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Add α] {s t₁ t₂ : Finset α}, t₁ ⊆ t₂ → s + t₁ ⊆ s + t₂ |
Turing.TM1.stmts | Mathlib.Computability.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} → {σ : Type u_3} → (Λ → Turing.TM1.Stmt Γ Λ σ) → Finset Λ → Finset (Option (Turing.TM1.Stmt Γ Λ σ)) |
DiscreteUniformity.mk._flat_ctor | Mathlib.Topology.UniformSpace.DiscreteUniformity | ∀ {X : Type u_1} [u : UniformSpace X], u = ⊥ → DiscreteUniformity X |
FinPartOrd.dualEquiv_unitIso | Mathlib.Order.Category.FinPartOrd | FinPartOrd.dualEquiv.unitIso =
CategoryTheory.NatIso.ofComponents (fun X => FinPartOrd.Iso.mk (OrderIso.dualDual ↑X.toPartOrd))
@FinPartOrd.dualEquiv._proof_1 |
DifferentiableOn.inverse | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {R : Type u_5} [inst_3 : NormedRing R] [HasSummableGeomSeries R]
[inst_5 : NormedAlgebra 𝕜 R] {h : E → R} {S : Set E},
DifferentiableOn 𝕜 h S → (∀ x ∈ S, IsUnit (h x)) → DifferentiableOn 𝕜 (fun x => Ring.inverse (h x)) S |
SymAlg.instNonAssocRingOfInvertibleOfNat._proof_14 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : Invertible 2] (a : αˢʸᵐ), a * 1 = a |
BddOrd.mk.injEq | Mathlib.Order.Category.BddOrd | ∀ (toPartOrd : PartOrd) [isBoundedOrder : BoundedOrder ↑toPartOrd] (toPartOrd_1 : PartOrd)
(isBoundedOrder_1 : BoundedOrder ↑toPartOrd_1),
({ toPartOrd := toPartOrd, isBoundedOrder := isBoundedOrder } =
{ toPartOrd := toPartOrd_1, isBoundedOrder := isBoundedOrder_1 }) =
(toPartOrd = toPartOrd_1 ∧ isBoundedOrder ≍ isBoundedOrder_1) |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.exists_linearIndepOn_extension.match_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u_2} {V : Type u_1} {v : ι → V} {t : Set ι} (x : V) (motive : x ∈ v '' t → Prop) (x_1 : x ∈ v '' t),
(∀ (x_2 : ι) (hx : x_2 ∈ t) (hvx : v x_2 = x), motive ⋯) → motive x_1 |
BddLat.Iso.mk._proof_4 | Mathlib.Order.Category.BddLat | ∀ {α β : BddLat} (e : ↑α.toLat ≃o ↑β.toLat) (a b : ↑α.1), e (a ⊓ b) = e a ⊓ e b |
OneHom.comp_apply | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : One M] [inst_1 : One N] [inst_2 : One P] (g : OneHom N P)
(f : OneHom M N) (x : M), (g.comp f) x = g (f x) |
Ideal.powQuotPowSuccLinearEquivMapMkPowSuccPow._proof_3 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (n : ℕ), (I ^ (n + 1)).IsTwoSided |
SimpleGraph.Copy.ext | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_4} {β : Type u_5} {A : SimpleGraph α} {B : SimpleGraph β} {f g : A.Copy B}, (∀ (a : α), f a = g a) → f = g |
BitVec.getElem?_zero_ofNat_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, (0#(w + 1))[0]? = some false |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instIteratorLoop.loop.wf._unary._proof_2 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] (LargeEnough : α → Prop),
(∀ (a b : α), Std.PRange.UpwardEnumerable.LE a b → LargeEnough a → LargeEnough b) →
∀ (next : α), LargeEnough next → ∀ (next' : α), Std.PRange.succ? next = some next' → LargeEnough next' |
Filter.pureAddHom._proof_1 | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_1} [inst : Add α] (x x_1 : α), pure (x + x_1) = pure x + pure x_1 |
FreeMonoid.lift.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {M : Type u_4} [inst : Monoid M],
FreeMonoid.lift =
{
toFun := fun f =>
{ toFun := fun l => FreeMonoid.prodAux (List.map f (FreeMonoid.toList l)), map_one' := ⋯, map_mul' := ⋯ },
invFun := fun f x => f (FreeMonoid.of x), left_inv := ⋯, right_inv := ⋯ } |
VectorPrebundle.totalSpaceTopology | Mathlib.Topology.VectorBundle.Basic | {R : Type u_1} →
{B : Type u_2} →
{F : Type u_3} →
{E : B → Type u_4} →
[inst : NontriviallyNormedField R] →
[inst_1 : (x : B) → AddCommMonoid (E x)] →
[inst_2 : (x : B) → Module R (E x)] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace R F] →
[inst_5 : TopologicalSpace B] →
[inst_6 : (x : B) → TopologicalSpace (E x)] →
VectorPrebundle R F E → TopologicalSpace (Bundle.TotalSpace F E) |
PowerSeries.HasSubst | Mathlib.RingTheory.PowerSeries.Substitution | {τ : Type u_3} → {S : Type u_4} → [CommRing S] → MvPowerSeries τ S → Prop |
WittVector.nsmul_coeff | Mathlib.RingTheory.WittVector.Defs | ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (m : ℕ) (x : WittVector p R) (n : ℕ),
(m • x).coeff n = WittVector.peval (WittVector.wittNSMul p m n) ![x.coeff] |
MeasureTheory.instMetrizableSpaceProbabilityMeasure | Mathlib.MeasureTheory.Measure.LevyProkhorovMetric | ∀ (X : Type u_2) [inst : TopologicalSpace X] [TopologicalSpace.PseudoMetrizableSpace X]
[TopologicalSpace.SeparableSpace X] [inst_3 : MeasurableSpace X] [inst_4 : BorelSpace X],
TopologicalSpace.MetrizableSpace (MeasureTheory.ProbabilityMeasure X) |
Subgroup.IsSubnormal.recOn | Mathlib.GroupTheory.IsSubnormal | ∀ {G : Type u_1} [inst : Group G] {motive : (a : Subgroup G) → a.IsSubnormal → Prop} {a : Subgroup G}
(t : a.IsSubnormal),
motive ⊤ ⋯ →
(∀ (H K : Subgroup G) (h_le : H ≤ K) (hSubn : K.IsSubnormal) (hN : (H.subgroupOf K).Normal),
motive K hSubn → motive H ⋯) →
motive a t |
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionHom._default | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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} →
{inst_2 : CategoryTheory.MonoidalCategoryStruct C} →
(actionObj : C → D → D) →
({c c' : C} → (c ⟶ c') → (d : D) → actionObj c d ⟶ actionObj c' d) →
((c : C) → {d d' : D} → (d ⟶ d') → (actionObj c d ⟶ actionObj c d')) →
{c c' : C} → {d d' : D} → (c ⟶ c') → (d ⟶ d') → (actionObj c d ⟶ actionObj c' d') |
Lean.Lsp.instFileSourceSignatureHelpParams | Lean.Server.FileSource | Lean.Lsp.FileSource Lean.Lsp.SignatureHelpParams |
_private.Mathlib.Computability.TuringDegree.0.instPreorderPFunNat | Mathlib.Computability.TuringDegree | Preorder (ℕ →. ℕ) |
Lean.IR.Checker.markIndex | Lean.Compiler.IR.Checker | Lean.IR.Index → Lean.IR.Checker.M Unit |
Option.filter_some | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {a : α}, Option.filter p (some a) = if p a = true then some a else none |
MvPowerSeries.instInv | Mathlib.RingTheory.MvPowerSeries.Inverse | {σ : Type u_1} → {k : Type u_3} → [Field k] → Inv (MvPowerSeries σ k) |
Lean.Elab.Tactic.closeMainGoal | Lean.Elab.Tactic.Basic | Lean.Name → Lean.Expr → optParam Bool true → Lean.Elab.Tactic.TacticM Unit |
Lean.Elab.GoalsAtResult | Lean.Server.InfoUtils | Type |
_private.Mathlib.Algebra.Group.Pointwise.Set.ListOfFn.0.Set.mem_list_prod._simp_1_2 | Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | ∀ {α : Type u} {P : List α → Prop}, (∃ l, P l) = ∃ n f, P (List.ofFn f) |
FirstOrder.Language.BoundedFormula.all_iff_not_ex_not | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {n : ℕ} (φ : L.BoundedFormula α (n + 1)),
T.Iff φ.all φ.not.ex.not |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.