name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.TreeSet.get?_eq_some_iff | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k k' : α},
t.get? k = some k' ↔ ∃ (h : k ∈ t), t.get k h = k' |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.sum_trapezoidal_integral_adjacent_intervals._simp_1_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u} [inst : NonUnitalNonAssocRing α] (a b c : α), a * c - b * c = (a - b) * c |
FirstOrder.Language.LHom.realize_onBoundedFormula | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'}
[inst_1 : L'.Structure M] (φ : L →ᴸ L') [φ.IsExpansionOn M] {n : ℕ} (ψ : L.BoundedFormula α n) {v : α → M}
{xs : Fin n → M}, (φ.onBoundedFormula ψ).Realize v xs ↔ ψ.Realize v xs |
Submodule.singleton_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (a : A)
(M : Submodule R A), Set.up {a} • M = Submodule.map (LinearMap.mulLeft R a) M |
intervalIntegral.intervalIntegrable_log'._simp_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {a b : ℝ}, IntervalIntegrable Real.log MeasureTheory.volume a b = True |
Lean.Server.FileWorker.SemanticTokensState.recOn | Lean.Server.FileWorker.SemanticHighlighting | {motive : Lean.Server.FileWorker.SemanticTokensState → Sort u} →
(t : Lean.Server.FileWorker.SemanticTokensState) → motive { } → motive t |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_11 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [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₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = n₂)
(this :
⋯.gIsCokernel.desc (CategoryTheory.Limits.CokernelCofork.ofπ (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).g ⋯) =
X.δFromOpcycles f₁ f₂ f₃ n₁ n₂ hn₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.Cones.postcompose
(CategoryTheory.Limits.parallelPair.ext
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.parallelPair
(⋯.gIsCokernel.desc
(CategoryTheory.Limits.CokernelCofork.ofπ (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).g
⋯))
0).obj
CategoryTheory.Limits.WalkingParallelPair.zero))
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.parallelPair
(⋯.gIsCokernel.desc
(CategoryTheory.Limits.CokernelCofork.ofπ (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).g
⋯))
0).obj
CategoryTheory.Limits.WalkingParallelPair.one))
⋯ ⋯).hom).obj
(CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.Limits.kernel.ι (X.δFromOpcycles f₁ f₂ f₃ n₁ n₂ ⋯))
⋯)).pt).hom
(CategoryTheory.Limits.Fork.ofι (CategoryTheory.Limits.kernel.ι (X.δFromOpcycles f₁ f₂ f₃ n₁ n₂ ⋯)) ⋯).ι =
CategoryTheory.Limits.Fork.ι
((CategoryTheory.Limits.Cones.postcompose
(CategoryTheory.Limits.parallelPair.ext
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.parallelPair
(⋯.gIsCokernel.desc
(CategoryTheory.Limits.CokernelCofork.ofπ (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).g ⋯))
0).obj
CategoryTheory.Limits.WalkingParallelPair.zero))
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.parallelPair
(⋯.gIsCokernel.desc
(CategoryTheory.Limits.CokernelCofork.ofπ (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).g ⋯))
0).obj
CategoryTheory.Limits.WalkingParallelPair.one))
⋯ ⋯).hom).obj
(CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.Limits.kernel.ι (X.δFromOpcycles f₁ f₂ f₃ n₁ n₂ ⋯)) ⋯)) |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne.match_1.congr_eq_1._sparseCasesOn_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastRotateRight._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateRight | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.ShiftTarget w),
∀ idx < w, ¬idx < w - target.distance % w → idx - (w - target.distance % w) < w |
Algebra.TensorProduct.basis_apply | Mathlib.RingTheory.TensorProduct.Free | ∀ {R : Type u_1} {A : Type u_2} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] (b : Module.Basis ι R M) (i : ι),
(Algebra.TensorProduct.basis A b) i = 1 ⊗ₜ[R] b i |
Finset.surjOn_of_injOn_of_card_le | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} (f : α → β),
Set.MapsTo f ↑s ↑t → Set.InjOn f ↑s → t.card ≤ s.card → Set.SurjOn f ↑s ↑t |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.not_cliqueFree_of_isTuranMaximal._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) |
Std.ExtDTreeMap.getKey!_erase_self | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α}, (t.erase k).getKey! k = default |
CategoryTheory.Bicategory.Adj.Hom₂.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
{τl : α.l ⟶ β.l} {τr : β.r ⟶ α.r}
{conjugateEquiv_τl :
autoParam ((CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) τl = τr)
CategoryTheory.Bicategory.Adj.Hom₂.conjugateEquiv_τl._autoParam}
{τl_1 : α.l ⟶ β.l} {τr_1 : β.r ⟶ α.r}
{conjugateEquiv_τl_1 :
autoParam ((CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) τl_1 = τr_1)
CategoryTheory.Bicategory.Adj.Hom₂.conjugateEquiv_τl._autoParam},
{ τl := τl, τr := τr, conjugateEquiv_τl := conjugateEquiv_τl } =
{ τl := τl_1, τr := τr_1, conjugateEquiv_τl := conjugateEquiv_τl_1 } →
τl = τl_1 ∧ τr = τr_1 |
CategoryTheory.OplaxFunctor._sizeOf_inst | Mathlib.CategoryTheory.Bicategory.Functor.Oplax | (B : Type u₁) →
{inst : CategoryTheory.Bicategory B} →
(C : Type u₂) →
{inst_1 : CategoryTheory.Bicategory C} → [SizeOf B] → [SizeOf C] → SizeOf (CategoryTheory.OplaxFunctor B C) |
List.foldl_nil | Init.Data.List.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β → α} {b : α}, List.foldl f b [] = b |
DomMulAct.smul_aeeqFun_const | Mathlib.MeasureTheory.Function.AEEqFun.DomAct | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_1 : TopologicalSpace β] [inst_2 : SMul M α] [inst_3 : MeasurableConstSMul M α]
[inst_4 : MeasureTheory.SMulInvariantMeasure M α μ] (c : Mᵈᵐᵃ) (b : β),
c • MeasureTheory.AEEqFun.const α b = MeasureTheory.AEEqFun.const α b |
ListSlice.toArray_toList | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : ListSlice α}, (Std.Slice.toList xs).toArray = Std.Slice.toArray xs |
CategoryTheory.Abelian.SpectralObject.E._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax |
_private.Mathlib.Algebra.Module.FinitePresentation.0.Module.finitePresentation_of_projective.match_1_1 | Mathlib.Algebra.Module.FinitePresentation | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(motive : (∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id) → Prop)
(x : ∃ n f g, Function.Surjective ⇑f ∧ Function.Injective ⇑g ∧ f ∘ₗ g = LinearMap.id),
(∀ (_n : ℕ) (_f : (Fin _n → R) →ₗ[R] M) (_g : M →ₗ[R] Fin _n → R) (surj : Function.Surjective ⇑_f)
(left : Function.Injective ⇑_g) (hfg : _f ∘ₗ _g = LinearMap.id), motive ⋯) →
motive x |
CategoryTheory.Bicategory.toNatTrans_conjugateEquiv | Mathlib.CategoryTheory.Bicategory.Adjunction.Cat | ∀ {C D : CategoryTheory.Cat} {L₁ L₂ : C ⟶ D} {R₁ R₂ : D ⟶ C} (adj₁ : CategoryTheory.Bicategory.Adjunction L₁ R₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction L₂ R₂) (f : L₂ ⟶ L₁),
((CategoryTheory.Bicategory.conjugateEquiv adj₁ adj₂) f).toNatTrans =
(CategoryTheory.conjugateEquiv (CategoryTheory.Adjunction.ofCat adj₁) (CategoryTheory.Adjunction.ofCat adj₂))
f.toNatTrans |
SheafOfModules.Presentation.mapRelations._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] {C' : Type u_3}
[inst_4 : CategoryTheory.Category.{u_5, u_3} C'] {J' : CategoryTheory.GrothendieckTopology C'}
{S : CategoryTheory.Sheaf J' RingCat} {M : SheafOfModules R} (P : M.Presentation)
(F : CategoryTheory.Functor (SheafOfModules R) (SheafOfModules S))
[CategoryTheory.Limits.PreservesColimitsOfSize.{u_1, u_1, max u_1 u_2, max u_1 u_3, max (max (u_1 + 1) u_2) u_4,
max (max (u_1 + 1) u_3) u_5}
F],
CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete P.generators.I) F |
Con.subgroup._proof_3 | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} [inst : Group G] (c : Con G), c 1 1 |
Std.Internal.List.getKey?_minKeyD | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
l.isEmpty = false →
∀ {fallback : α},
Std.Internal.List.getKey? (Std.Internal.List.minKeyD l fallback) l = some (Std.Internal.List.minKeyD l fallback) |
Subgroup.instMulActionLeftTransversal | Mathlib.GroupTheory.Complement | {G : Type u_1} →
[inst : Group G] →
{H : Subgroup G} →
{F : Type u_2} →
[inst_1 : Group F] → [inst_2 : MulAction F G] → [MulAction.QuotientAction F H] → MulAction F H.LeftTransversal |
Lean.Lsp.CancelParams.mk._flat_ctor | Lean.Data.Lsp.CancelParams | Lean.JsonRpc.RequestID → Lean.Lsp.CancelParams |
AddHom.srangeRestrict.eq_1 | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} [inst : Add M] {N : Type u_5} [inst_1 : Add N] (f : M →ₙ+ N),
f.srangeRestrict = f.codRestrict f.srange ⋯ |
Lean.Grind.AC.Context.noConfusionType | Init.Grind.AC | Sort u_1 → {α : Sort u} → Lean.Grind.AC.Context α → {α' : Sort u} → Lean.Grind.AC.Context α' → Sort u_1 |
Decidable.and_iff_not_not_or_not | Init.PropLemmas | ∀ {a b : Prop} [Decidable a] [Decidable b], a ∧ b ↔ ¬(¬a ∨ ¬b) |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.ctorIdx | Init.Data.String.Pattern.Basic | {ρ : Type} → {pat : ρ} → {s : String.Slice} → String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s → ℕ |
Set.piecewise | Mathlib.Logic.Function.Basic | {α : Type u} →
{β : α → Sort v} → (s : Set α) → ((i : α) → β i) → ((i : α) → β i) → [(j : α) → Decidable (j ∈ s)] → (i : α) → β i |
Lean.Elab.Term.Do.Code._sizeOf_5_eq | Lean.Elab.Do.Legacy | ∀ (x : List (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)), Lean.Elab.Term.Do.Code._sizeOf_5 x = sizeOf x |
ArithmeticFunction.instCommRing._proof_1 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_1} [inst : CommRing R] (a b : ArithmeticFunction R), a - b = a + -b |
Std.ExtHashMap.mem_map | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {f : α → β → γ} {k : α}, k ∈ Std.ExtHashMap.map f m ↔ k ∈ m |
ULift.algebra._proof_4 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x y : R),
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun (x + y) =
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun x +
(↑↑(ULift.ringEquiv.symm.toRingHom.comp (algebraMap R A))).toFun y |
CategoryTheory.Functor.ReflectsMonomorphisms | Mathlib.CategoryTheory.Functor.EpiMono | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop |
_private.Init.Data.Array.Attach.0.Array.attachWithImpl | Init.Data.Array.Attach | {α : Type u_1} → (xs : Array α) → (P : α → Prop) → (∀ x ∈ xs, P x) → Array { x // P x } |
Valuation.RankOne.mk | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} → [toRankLeOne : v.RankLeOne] → [toIsNontrivial : v.IsNontrivial] → v.RankOne |
Lean.Compiler.LCNF.Closure.State.mk.injEq | Lean.Compiler.LCNF.Closure | ∀ (visited : Lean.FVarIdHashSet) (params : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(decls : Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure)) (visited_1 : Lean.FVarIdHashSet)
(params_1 : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure))
(decls_1 : Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure)),
({ visited := visited, params := params, decls := decls } =
{ visited := visited_1, params := params_1, decls := decls_1 }) =
(visited = visited_1 ∧ params = params_1 ∧ decls = decls_1) |
ZeroAtInftyContinuousMap.instNonUnitalCommSemiring._proof_6 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : NonUnitalCommSemiring β] [inst_3 : IsTopologicalSemiring β] (f g : ZeroAtInftyContinuousMap α β),
⇑(f * g) = ⇑f * ⇑g |
IsCompactOpenCovered.empty | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} {ι : Type u_2} {X : ι → Type u_3} {f : (i : ι) → X i → S} [inst : (i : ι) → TopologicalSpace (X i)],
IsCompactOpenCovered f ∅ |
Real.cauchy_intCast | Mathlib.Data.Real.Basic | ∀ (z : ℤ), (↑z).cauchy = ↑z |
map_inv₀ | Mathlib.Algebra.GroupWithZero.Units.Lemmas | ∀ {G₀ : Type u_3} {G₀' : Type u_5} {F : Type u_6} [inst : GroupWithZero G₀] [inst_1 : GroupWithZero G₀']
[inst_2 : FunLike F G₀ G₀'] [MonoidWithZeroHomClass F G₀ G₀'] (f : F) (a : G₀), f a⁻¹ = (f a)⁻¹ |
IsLocalization.Away.mapₐ.congr_simp | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_5} [inst_1 : CommSemiring A] [inst_2 : Algebra R A] {B : Type u_6}
[inst_3 : CommSemiring B] [inst_4 : Algebra R B] (Aₚ : Type u_7) [inst_5 : CommSemiring Aₚ] [inst_6 : Algebra A Aₚ]
[inst_7 : Algebra R Aₚ] [inst_8 : IsScalarTower R A Aₚ] (Bₚ : Type u_8) [inst_9 : CommSemiring Bₚ]
[inst_10 : Algebra B Bₚ] [inst_11 : Algebra R Bₚ] [inst_12 : IsScalarTower R B Bₚ] (f f_1 : A →ₐ[R] B) (e_f : f = f_1)
(a a_1 : A) (e_a : a = a_1) [inst_13 : IsLocalization.Away a Aₚ] [inst_14 : IsLocalization.Away (f a) Bₚ],
IsLocalization.Away.mapₐ Aₚ Bₚ f a = IsLocalization.Away.mapₐ Aₚ Bₚ f_1 a_1 |
Int16.sub_right_inj._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16} (c : Int16), (c - a = c - b) = (a = b) |
RootPairing.rootSpan_eq_top_iff | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Field R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
[P.IsAnisotropic], P.rootSpan R = ⊤ ↔ P.corootSpan R = ⊤ |
Lean.Meta.FunInd.Collector.saveFunInd | Lean.Meta.Tactic.FunIndCollect | Lean.Expr → Lean.Meta.FunIndInfo → Array Lean.Expr → Lean.Meta.FunInd.Collector.M Unit |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_37 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] (w : α),
[].length + 1 ≤ (List.filter (fun x => decide (x = w)) []).length →
[].length < (List.filter (fun x => decide (x = w)) []).length |
CharP.subsemiring | Mathlib.Algebra.CharP.Subring | ∀ (R : Type u) [inst : Semiring R] (p : ℕ) [CharP R p] (S : Subsemiring R), CharP (↥S) p |
_private.Mathlib.RingTheory.ChainOfDivisors.0.pow_image_of_prime_by_factor_orderIso_dvd._simp_1_1 | Mathlib.RingTheory.ChainOfDivisors | ∀ {M : Type u_1} [inst : Monoid M], 1 = ⊥ |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_316 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
Std.HashMap.getElem!_alter_self | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
[inst : Inhabited β] {f : Option β → Option β}, (m.alter k f)[k]! = (f m[k]?).get! |
CategoryTheory.Functor.PushoutObjObj.ι_iso_of_iso_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{f₁ f₁' : CategoryTheory.Arrow C₁} →
{f₂ : CategoryTheory.Arrow C₂} →
(sq₁₂ : F.PushoutObjObj f₁.hom f₂.hom) →
(sq₁₂' : F.PushoutObjObj f₁'.hom f₂.hom) →
(f₁ ≅ f₁') → (CategoryTheory.Arrow.mk sq₁₂.ι ≅ CategoryTheory.Arrow.mk sq₁₂'.ι) |
_private.Lean.Meta.MethodSpecs.0.Lean.MethodSpecsInfo.rec | Lean.Meta.MethodSpecs | {motive : Lean.MethodSpecsInfo✝ → Sort u} →
((clsName : Lean.Name) →
(privateSpecs : Bool) →
(fieldImpls : Array (Lean.Name × Lean.Name)) →
(thms : Array Lean.MethodSpecTheorem✝) →
motive { clsName := clsName, privateSpecs := privateSpecs, fieldImpls := fieldImpls, thms := thms }) →
(t : Lean.MethodSpecsInfo✝¹) → motive t |
Pi.nonUnitalNonAssocSemiring._proof_6 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonUnitalNonAssocSemiring (f i)] (a b : (i : I) → f i),
a + b = b + a |
CategoryTheory.Limits.Multiequalizer.lift_ι_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasMultiequalizer I] (W : C)
(k : (a : J.L) → W ⟶ I.left a)
(h :
∀ (b : J.R),
CategoryTheory.CategoryStruct.comp (k (J.fst b)) (I.fst b) =
CategoryTheory.CategoryStruct.comp (k (J.snd b)) (I.snd b))
(a : J.L) {Z : C} (h_1 : I.left a ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.lift I W k h)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Multiequalizer.ι I a) h_1) =
CategoryTheory.CategoryStruct.comp (k a) h_1 |
Array.ne_push_self._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {a : α} {xs : Array α}, (xs = xs.push a) = False |
Set.add_univ | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : AddGroup α] {s : Set α}, s.Nonempty → s + Set.univ = Set.univ |
ContinuousMap.compAddMonoidHom'._proof_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_2}
[inst_2 : TopologicalSpace γ] [inst_3 : AddZeroClass γ] (g : C(α, β)), ContinuousMap.comp 0 g = 0 |
Mathlib.Tactic.Bound._aux_Mathlib_Tactic_Bound_Attribute___macroRules_Mathlib_Tactic_Bound_attrBound_forward_1 | Mathlib.Tactic.Bound.Attribute | Lean.Macro |
Lean.Doc.Block.dl | Lean.DocString.Types | {i : Type u} → {b : Type v} → Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Lean.Doc.Block i b |
Set.mem_mulAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : Mul α] {s t : Set α} {a : α} {x : α × α},
x ∈ s.mulAntidiagonal t a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 * x.2 = a |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeNegAssignment.eq_4 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned.removeNegAssignment =
Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.y_eq_zero_of_notMem_ball._simp_1_4 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False |
Std.ExtTreeMap.ne_empty_of_erase_ne_empty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
t.erase k ≠ ∅ → t ≠ ∅ |
AddMonoid.Coprod.map._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_3} {N : Type u_4} {M' : Type u_1} {N' : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass M'] [inst_3 : AddZeroClass N'] (f : M →+ M') (g : N →+ N') (x y : N),
(AddMonoid.Coprod.mk.comp (FreeAddMonoid.map (Sum.map ⇑f ⇑g))) (FreeAddMonoid.of (Sum.inr (x + y))) =
(AddMonoid.Coprod.mk.comp (FreeAddMonoid.map (Sum.map ⇑f ⇑g)))
(FreeAddMonoid.of (Sum.inr x) + FreeAddMonoid.of (Sum.inr y)) |
or_iff_right_iff_imp._simp_1 | Init.SimpLemmas | ∀ {a b : Prop}, (a ∨ b ↔ b) = (a → b) |
Turing.BlankRel.refl | Mathlib.Computability.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), Turing.BlankRel l l |
_private.Lean.Compiler.ModPkgExt.0.Lean.initFn._@.Lean.Compiler.ModPkgExt.1097734621._hygCtx._hyg.2 | Lean.Compiler.ModPkgExt | IO (Lean.ModuleEnvExtension (Option Lean.PkgId)) |
CategoryTheory.Limits.DiagramOfCocones.mk.inj | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_1} {K : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} J}
{inst_1 : CategoryTheory.Category.{v_2, u_2} K} {C : Type u_3} {inst_2 : CategoryTheory.Category.{v_3, u_3} C}
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {obj : (j : J) → CategoryTheory.Limits.Cocone (F.obj j)}
{map : {j j' : J} → (f : j ⟶ j') → obj j ⟶ (CategoryTheory.Limits.Cocones.precompose (F.map f)).obj (obj j')}
{id :
autoParam (∀ (j : J), (map (CategoryTheory.CategoryStruct.id j)).hom = CategoryTheory.CategoryStruct.id (obj j).pt)
CategoryTheory.Limits.DiagramOfCocones.id._autoParam}
{comp :
autoParam
(∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
(map (CategoryTheory.CategoryStruct.comp f g)).hom = CategoryTheory.CategoryStruct.comp (map f).hom (map g).hom)
CategoryTheory.Limits.DiagramOfCocones.comp._autoParam}
{obj_1 : (j : J) → CategoryTheory.Limits.Cocone (F.obj j)}
{map_1 : {j j' : J} → (f : j ⟶ j') → obj_1 j ⟶ (CategoryTheory.Limits.Cocones.precompose (F.map f)).obj (obj_1 j')}
{id_1 :
autoParam
(∀ (j : J), (map_1 (CategoryTheory.CategoryStruct.id j)).hom = CategoryTheory.CategoryStruct.id (obj_1 j).pt)
CategoryTheory.Limits.DiagramOfCocones.id._autoParam}
{comp_1 :
autoParam
(∀ {j₁ j₂ j₃ : J} (f : j₁ ⟶ j₂) (g : j₂ ⟶ j₃),
(map_1 (CategoryTheory.CategoryStruct.comp f g)).hom =
CategoryTheory.CategoryStruct.comp (map_1 f).hom (map_1 g).hom)
CategoryTheory.Limits.DiagramOfCocones.comp._autoParam},
{ obj := obj, map := map, id := id, comp := comp } = { obj := obj_1, map := map_1, id := id_1, comp := comp_1 } →
obj = obj_1 ∧ map ≍ map_1 |
Functor.Comp.instPure | Mathlib.Control.Functor | {F : Type u → Type w} → {G : Type v → Type u} → [Applicative F] → [Applicative G] → Pure (Functor.Comp F G) |
Sylow.card_normalizer_modEq_card | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] [Finite G] {p n : ℕ} [hp : Fact (Nat.Prime p)] {H : Subgroup G},
Nat.card ↥H = p ^ n → Nat.card ↥H.normalizer ≡ Nat.card G [MOD p ^ (n + 1)] |
Lean.Meta.Grind.AC.EqCnstr.mk.inj | Lean.Meta.Tactic.Grind.AC.Types | ∀ {lhs rhs : Lean.Grind.AC.Seq} {h : Lean.Meta.Grind.AC.EqCnstrProof} {id : ℕ} {lhs_1 rhs_1 : Lean.Grind.AC.Seq}
{h_1 : Lean.Meta.Grind.AC.EqCnstrProof} {id_1 : ℕ},
{ lhs := lhs, rhs := rhs, h := h, id := id } = { lhs := lhs_1, rhs := rhs_1, h := h_1, id := id_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ h = h_1 ∧ id = id_1 |
Meromorphic.MeromorphicOn.countable_compl_analyticAt | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} [SecondCountableTopology 𝕜] [CompleteSpace E],
Meromorphic f → {z | AnalyticAt 𝕜 f z}ᶜ.Countable |
ConvexCone.IsGenerating.top_le_span | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] {C : ConvexCone R M}, C.IsGenerating → ⊤ ≤ Submodule.span R ↑C |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_23 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α},
a ∈ l → ∀ (hl : l ≠ []), a ∉ l.dropLast → l.length - (l.dropLast.length + 1) < [l.getLast ⋯].length |
_private.Lean.Meta.Match.AltTelescopes.0.Lean.Meta.Match.forallAltVarsTelescope.isNamedPatternProof | Lean.Meta.Match.AltTelescopes | Lean.Expr → Lean.Expr → Bool |
Lean.ReducibilityHints.ctorElim | Lean.Declaration | {motive : Lean.ReducibilityHints → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.ReducibilityHints) → ctorIdx = t.ctorIdx → Lean.ReducibilityHints.ctorElimType ctorIdx → motive t |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.«term𝒰(_,_,_)» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.ParserDescr |
CategoryTheory.Grothendieck.map_obj_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat} (α : F ⟶ G)
(X : CategoryTheory.Grothendieck F),
((CategoryTheory.Grothendieck.map α).obj X).fiber = (α.app X.base).toFunctor.obj X.fiber |
AddCon.addCommMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : AddCommMagma M] → (c : AddCon M) → AddCommMagma c.Quotient |
instSTWorldEST | Init.System.ST | {ε σ : Type} → STWorld σ (EST ε σ) |
CategoryTheory.Abelian.SpectralObject.iCycles_δ | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {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 : ι} (f : i ⟶ j) (g : j ⟶ k) (n₀ n₁ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.iCycles_δ._auto_1),
CategoryTheory.CategoryStruct.comp (X.iCycles f g n₀) (X.δ f g n₀ n₁ hn₁) = 0 |
Aesop.getGoalsToCopy | Aesop.Tree.AddRapp | Aesop.UnorderedArraySet Lean.MVarId → Aesop.GoalRef → Aesop.TreeM (Array Aesop.GoalRef) |
TensorProduct.sum_tmul_basis_left_eq_zero | Mathlib.LinearAlgebra.TensorProduct.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] (ℬ : Module.Basis ι R M) (b : ι →₀ N),
(b.sum fun i n => ℬ i ⊗ₜ[R] n) = 0 → b = 0 |
AdicCompletion.instNeg._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_2} [inst : CommRing R] (I : Ideal R) (M : Type u_1) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion I M) {m n : ℕ} (hmn : m ≤ n), (AdicCompletion.transitionMap I M hmn) ((-↑x) n) = (-↑x) m |
ISize.ofIntLE_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec System.Platform.numBits), ISize.ofIntLE n.toInt ⋯ ⋯ = ISize.ofBitVec n |
Lean.Meta.getAllSimpDecls._sparseCasesOn_2 | Mathlib.Lean.Meta.Simp | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.ProjectivePresentation.mk.sizeOf_spec | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} [inst_1 : SizeOf C] (p : C)
[projective : CategoryTheory.Projective p] (f : p ⟶ X) [epi : CategoryTheory.Epi f],
sizeOf { p := p, projective := projective, f := f, epi := epi } =
1 + sizeOf p + sizeOf projective + sizeOf f + sizeOf epi |
SheafOfModules.QuasicoherentData.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | Sort u_1 →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
[inst_2 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat] →
[inst_3 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] →
{M : SheafOfModules R} →
M.QuasicoherentData →
{C' : Type u₁} →
[inst' : CategoryTheory.Category.{v₁, u₁} C'] →
{J' : CategoryTheory.GrothendieckTopology C'} →
{R' : CategoryTheory.Sheaf J' RingCat} →
[inst'_1 :
∀ (X : C'),
(J'.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
[inst'_2 : ∀ (X : C'), CategoryTheory.HasWeakSheafify (J'.over X) AddCommGrpCat] →
[inst'_3 : ∀ (X : C'), (J'.over X).WEqualsLocallyBijective AddCommGrpCat] →
{M' : SheafOfModules R'} → M'.QuasicoherentData → Sort u_1 |
SimplexCategory.len_le_of_epi | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {x y : SimplexCategory} (f : x ⟶ y) [CategoryTheory.Epi f], y.len ≤ x.len |
AlgebraicGeometry.quasiSeparatedSpace_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsAffine X], QuasiSeparatedSpace ↥X |
CochainComplex.HomComplex.Cocycle.toSingleMk_add._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
{K : CochainComplex C ℤ} {p : ℤ} (f g : K.X p ⟶ X) (p' : ℤ),
CategoryTheory.CategoryStruct.comp (K.d p' p) f = 0 →
CategoryTheory.CategoryStruct.comp (K.d p' p) g = 0 → CategoryTheory.CategoryStruct.comp (K.d p' p) (f + g) = 0 |
Multiset.right_mem_Ioc | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∈ Multiset.Ioc a b ↔ a < b |
Units.val_mk | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a b : α) (h₁ : a * b = 1) (h₂ : b * a = 1),
↑{ val := a, inv := b, val_inv := h₁, inv_val := h₂ } = a |
Lean.Meta.LazyDiscrTree.PartialMatch.noConfusion | Lean.Meta.LazyDiscrTree | {P : Sort u} →
{t t' : Lean.Meta.LazyDiscrTree.PartialMatch} → t = t' → Lean.Meta.LazyDiscrTree.PartialMatch.noConfusionType P t t' |
ContinuousMap.HomotopyEquiv.mk.sizeOf_spec | Mathlib.Topology.Homotopy.Equiv | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : SizeOf X]
[inst_3 : SizeOf Y] (toFun : C(X, Y)) (invFun : C(Y, X))
(left_inv : (invFun.comp toFun).Homotopic (ContinuousMap.id X))
(right_inv : (toFun.comp invFun).Homotopic (ContinuousMap.id Y)),
sizeOf { toFun := toFun, invFun := invFun, left_inv := left_inv, right_inv := right_inv } =
1 + sizeOf toFun + sizeOf invFun + sizeOf left_inv + sizeOf right_inv |
LinearMap.ofIsCompl_eq | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {p q : Submodule R E} (h : IsCompl p q) {φ : ↥p →ₗ[R] F}
{ψ : ↥q →ₗ[R] F} {χ : E →ₗ[R] F}, (∀ (u : ↥p), φ u = χ ↑u) → (∀ (u : ↥q), ψ u = χ ↑u) → LinearMap.ofIsCompl h φ ψ = χ |
_private.Mathlib.Topology.Separation.Profinite.0.exists_clopen_partition_of_clopen_cover._proof_1_7 | Mathlib.Topology.Separation.Profinite | ∀ {X : Type u_1} [inst : TopologicalSpace X] {I : Type u_2} {D : Option I → Set X} (C' : I → Set X),
IsClopen (D none \ ⋃ i, C' i) → IsClopen ((fun i => Option.casesOn i (D none \ ⋃ i, C' i) C') none) |
CategoryTheory.Idempotents.KaroubiHomologicalComplexEquivalence.unitIso._proof_7 | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι},
CategoryTheory.CategoryStruct.comp
{ app := fun P => { f := { f := fun n => P.p.f n, comm' := ⋯ }, comm := ⋯ }, naturality := ⋯ }
{ app := fun P => { f := { f := fun n => P.p.f n, comm' := ⋯ }, comm := ⋯ }, naturality := ⋯ } =
CategoryTheory.CategoryStruct.id
(CategoryTheory.Functor.id (CategoryTheory.Idempotents.Karoubi (HomologicalComplex C c))) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.