name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
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.pushout.inr f g)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.inv f) (CategoryTheory.CategoryStruct.comp g h) |
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) |
Lean.Widget.instRpcEncodableInteractiveGoal.enc._@.Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Lean.Widget.InteractiveGoal → StateM Lean.Server.RpcObjectStore Lean.Json |
_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 x |
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 |
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 : X ≃ₜ Y) (k : 𝕜) (a : C(Y, A)),
(ContinuousMap.compStarAlgHom' 𝕜 A ↑f) (k • a) = k • (ContinuousMap.compStarAlgHom' 𝕜 A ↑f) a |
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' |
Std.HashSet.Raw.contains_empty | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {a : α}, ∅.contains a = false |
_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) |
Lean.Parser.Term.ensureTypeOf | Lean.Parser.Term | Lean.Parser.Parser |
_private.Mathlib.Geometry.Manifold.Algebra.Monoid.0.contMDiffWithinAt_finset_prod._simp_1_1 | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {ι : Type u_1} {α : Type u_7} {M : α → Type u_8} [inst : (a : α) → CommMonoid (M a)] (a : α) (s : Finset ι)
(g : ι → (a : α) → M a), ∏ c ∈ s, g c a = (∏ c ∈ s, g c) a |
Int.tdiv_nonpos_of_nonneg_of_nonpos | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → b ≤ 0 → a.tdiv b ≤ 0 |
ContinuousNeg.rec | Mathlib.Topology.Algebra.Group.Defs | {G : Type u} →
[inst : TopologicalSpace G] →
[inst_1 : Neg G] →
{motive : ContinuousNeg G → Sort u_1} →
((continuous_neg : Continuous fun a => -a) → motive ⋯) → (t : ContinuousNeg G) → motive t |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeInductiveDecl.mk.noConfusion | Lean.Elab.MutualInductive | {P : Sort u} →
{decl : Lean.Declaration} →
{indFvars : Array Lean.Expr} →
{numParams : ℤ} →
{rs : Array Lean.Elab.Command.PreElabHeaderResult} →
{decl' : Lean.Declaration} →
{indFvars' : Array Lean.Expr} →
{numParams' : ℤ} →
{rs' : Array Lean.Elab.Command.PreElabHeaderResult} →
{ decl := decl, indFvars := indFvars, numParams := numParams, rs := rs } =
{ decl := decl', indFvars := indFvars', numParams := numParams', rs := rs' } →
(decl = decl' → indFvars = indFvars' → numParams = numParams' → rs = rs' → P) → P |
AlgebraicGeometry.Scheme.pretopology.congr_simp | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ (P P_1 : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) (e_P : P = P_1) [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative], AlgebraicGeometry.Scheme.pretopology P = AlgebraicGeometry.Scheme.pretopology P_1 |
CFC.rpow_mul_rpow_neg | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] {a : A} (x : ℝ),
IsUnit a → autoParam (0 ≤ a) CFC.rpow_mul_rpow_neg._auto_1 → a ^ x * a ^ (-x) = 1 |
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Ordered.append.match_1_9 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} (x y : α) (a : Batteries.RBNode α) (x_1 : α) (b : Batteries.RBNode α)
(motive :
Batteries.RBNode.Ordered cmp (Batteries.RBNode.node Batteries.RBColor.red a x_1 b) ∧
Batteries.RBNode.All (fun x_2 => Batteries.RBNode.cmpLT cmp x x_2)
(Batteries.RBNode.node Batteries.RBColor.red a x_1 b) ∧
Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y)
(Batteries.RBNode.node Batteries.RBColor.red a x_1 b) →
Prop)
(x_2 :
Batteries.RBNode.Ordered cmp (Batteries.RBNode.node Batteries.RBColor.red a x_1 b) ∧
Batteries.RBNode.All (fun x_2 => Batteries.RBNode.cmpLT cmp x x_2)
(Batteries.RBNode.node Batteries.RBColor.red a x_1 b) ∧
Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y)
(Batteries.RBNode.node Batteries.RBColor.red a x_1 b)),
(∀ (b'z : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x x_1) a)
(c'z : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x_1 x) b) (hb' : Batteries.RBNode.Ordered cmp a)
(hc' : Batteries.RBNode.Ordered cmp b) (xz : Batteries.RBNode.cmpLT cmp x x_1)
(xb' : Batteries.RBNode.All (fun x_3 => Batteries.RBNode.cmpLT cmp x x_3) a)
(right : Batteries.RBNode.All (fun x_3 => Batteries.RBNode.cmpLT cmp x x_3) b)
(zy : Batteries.RBNode.cmpLT cmp x_1 y) (left : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y) a)
(c'y : Batteries.RBNode.All (fun x => Batteries.RBNode.cmpLT cmp x y) b), motive ⋯) →
motive x_2 |
HasProd.congr_cofinite₀ | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {K : Type u_4} [inst : CommGroupWithZero K] [inst_1 : TopologicalSpace K] [ContinuousMul K]
{f g : α → K} {c : K},
HasProd f c →
∀ {s : Finset α}, (∀ a ∈ s, f a ≠ 0) → (∀ a ∉ s, f a = g a) → HasProd g (c * ((∏ i ∈ s, g i) / ∏ i ∈ s, f i)) |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_iff_pair_subset.match_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u_1} {s : Set α} (motive : (∃ x y, x ≠ y ∧ {x, y} ⊆ s) → Prop) (H : ∃ x y, x ≠ y ∧ {x, y} ⊆ s),
(∀ (w w_1 : α) (hxy : w ≠ w_1) (h : {w, w_1} ⊆ s), motive ⋯) → motive H |
_private.Mathlib.Topology.Homotopy.LocallyContractible.0.instStronglyLocallyContractibleSpaceProd.match_9 | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (x : X) (y : Y) (Ux : Set X)
(Uy : Set Y)
(motive :
(match (x, y) with
| (x, y) =>
match (Ux, Uy) with
| (Ux, Uy) => (Ux ∈ nhds x ∧ ContractibleSpace ↑Ux) ∧ Uy ∈ nhds y ∧ ContractibleSpace ↑Uy) →
Prop)
(h :
match (x, y) with
| (x, y) =>
match (Ux, Uy) with
| (Ux, Uy) => (Ux ∈ nhds x ∧ ContractibleSpace ↑Ux) ∧ Uy ∈ nhds y ∧ ContractibleSpace ↑Uy),
(∀ (hUx : Ux ∈ nhds x ∧ ContractibleSpace ↑Ux) (hUy : Uy ∈ nhds y ∧ ContractibleSpace ↑Uy), motive ⋯) → motive h |
Finite.Set.finite_range | Mathlib.Data.Set.Finite.Range | ∀ {α : Type u} {ι : Sort w} (f : ι → α) [Finite ι], Finite ↑(Set.range f) |
Submodule.smithNormalFormOfLE._proof_8 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_3} {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsDomain R] [inst_4 : IsPrincipalIdealRing R] [inst_5 : Finite ι] (b : Module.Basis ι R M)
(N O : Submodule R M) (N_le_O : N ≤ O),
∃ o,
∃ (hno : Classical.choose ⋯ ≤ o),
∃ bO bN a, ∀ (i : Fin (Classical.choose ⋯)), ↑(bN i) = a i • ↑(bO (Fin.castLE hno i)) |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.isLimitFiniteSubproductsCone | Mathlib.CategoryTheory.Limits.Constructions.Filtered | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{α : Type w} →
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] →
(f : α → C) →
[CategoryTheory.Limits.HasLimitsOfShape (Finset (CategoryTheory.Discrete α))ᵒᵖ C] →
[inst_3 : CategoryTheory.Limits.HasProduct f] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.ProductsFromFiniteCofiltered.finiteSubproductsCone f) |
BoxIntegral.unitPartition.mem_prepartition_iff | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] [inst_1 : Fintype ι] {B I : BoxIntegral.Box ι},
I ∈ BoxIntegral.unitPartition.prepartition n B ↔
∃ ν ∈ BoxIntegral.unitPartition.admissibleIndex n B, BoxIntegral.unitPartition.box n ν = I |
inner_conj_symm | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x y : E), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y |
Submonoid.isLocalizationMap_of_group | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {G : Type u_2} [inst : CommMonoid M] [inst_1 : CommGroup G] {S : Submonoid M} {f : M → G},
Function.Injective f → (∀ (g : G), ∃ x, ∃ y ∈ S, g = f x / f y) → S.IsLocalizationMap f |
Multiset.map_univ_coe | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α), Multiset.map (fun x => x.fst) Finset.univ.val = m |
Quotient.hrecOn | Init.Core | {α : Sort u} →
{s : Setoid α} →
{motive : Quotient s → Sort v} →
(q : Quotient s) → (f : (a : α) → motive ⟦a⟧) → (∀ (a b : α), a ≈ b → f a ≍ f b) → motive q |
Mathlib.Tactic.BicategoryLike.Mor₁.tgt._unsafe_rec | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Obj |
SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso_hom_app | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | ∀ {X Y : SSet.Truncated 2}
(x : X.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge.tensor._proof_1 }))
(y : Y.obj (Opposite.op { obj := SimplexCategory.mk 0, property := SSet.Truncated.Edge.tensor._proof_1 })),
(SSet.Truncated.HomotopyCategory.BinaryProduct.functorCompInverseIso X Y).hom.app
(SSet.Truncated.HomotopyCategory.mk (x, y)) =
CategoryTheory.CategoryStruct.id
(((SSet.Truncated.HomotopyCategory.BinaryProduct.functor X Y).comp
(SSet.Truncated.HomotopyCategory.BinaryProduct.inverse X Y)).obj
(SSet.Truncated.HomotopyCategory.mk (x, y))) |
Lean.Compiler.LCNF.MonadCodeBind.rec | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{motive : Lean.Compiler.LCNF.MonadCodeBind m → Sort u} →
((codeBind :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCNF.Code pu)) →
motive { codeBind := codeBind }) →
(t : Lean.Compiler.LCNF.MonadCodeBind m) → motive t |
Nat.nth_apply_eq_orderIsoOfNat | Mathlib.Data.Nat.Nth | ∀ {p : ℕ → Prop} (hf : (setOf p).Infinite) (n : ℕ), Nat.nth p n = ↑((Nat.Subtype.orderIsoOfNat (setOf p)) n) |
_private.Mathlib.Data.Set.Function.0.Set.bijOn_singleton._simp_1_2 | Mathlib.Data.Set.Function | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
Array.mkSlice_roi_eq_mkSlice_roo | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Roo.Sliceable.mkSlice xs lo<...xs.size |
SimplicialObject.Split.Hom.mk.injEq | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {S₁ S₂ : SimplicialObject.Split C} (F : S₁.X ⟶ S₂.X)
(f : (n : ℕ) → S₁.s.N n ⟶ S₂.s.N n)
(comm :
autoParam
(∀ (n : ℕ),
CategoryTheory.CategoryStruct.comp (S₁.s.ι n) (F.app (Opposite.op (SimplexCategory.mk n))) =
CategoryTheory.CategoryStruct.comp (f n) (S₂.s.ι n))
SimplicialObject.Split.Hom.comm._autoParam)
(F_1 : S₁.X ⟶ S₂.X) (f_1 : (n : ℕ) → S₁.s.N n ⟶ S₂.s.N n)
(comm_1 :
autoParam
(∀ (n : ℕ),
CategoryTheory.CategoryStruct.comp (S₁.s.ι n) (F_1.app (Opposite.op (SimplexCategory.mk n))) =
CategoryTheory.CategoryStruct.comp (f_1 n) (S₂.s.ι n))
SimplicialObject.Split.Hom.comm._autoParam),
({ F := F, f := f, comm := comm } = { F := F_1, f := f_1, comm := comm_1 }) = (F = F_1 ∧ f = f_1) |
ProjectiveSpectrum | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] → [inst_2 : AddSubmonoidClass σ A] → (𝒜 : ℕ → σ) → [GradedRing 𝒜] → Type u_1 |
Mathlib.Tactic.Ring.evalSub.match_1 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{b : Q(«$α»)} →
(rα : Q(CommRing «$α»)) →
(motive : Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sα) q(-«$b») → Sort u_1) →
(__discr : Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sα) q(-«$b»)) →
((_c : Q(«$α»)) →
(vc : Mathlib.Tactic.Ring.ExSum sα _c) →
(pc : Q(-«$b» = «$_c»)) → motive { expr := _c, val := vc, proof := pc }) →
motive __discr |
mdifferentiableAt_add_left | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : Add G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [ContMDiffAdd I 1 G] {a b : G},
(MDiffAt fun x => a + x) b |
Ordnode.merge_nil_right | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} (t : Ordnode α), Ordnode.nil.merge t = t |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKeyD_insert_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
Fin.instMax_mathlib._proof_1 | Mathlib.Order.Fin.Basic | ∀ {n : ℕ} (x y : Fin n), max ↑x ↑y < n |
AlgHom.FinitePresentation.of_finiteType | Mathlib.RingTheory.FinitePresentation | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [IsNoetherianRing A] {f : A →ₐ[R] B},
f.FiniteType ↔ f.FinitePresentation |
MeasureTheory.measure_preimage_add_right | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : AddGroup G] [MeasurableAdd G] (μ : MeasureTheory.Measure G)
[μ.IsAddRightInvariant] (g : G) (A : Set G), μ ((fun h => h + g) ⁻¹' A) = μ A |
LinearMap.IsPerfPair.restrictScalars_of_field | Mathlib.LinearAlgebra.PerfectPairing.Restrict | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : AddCommGroup M] [inst_4 : AddCommGroup N] [inst_5 : Module L M] [inst_6 : Module L N] [inst_7 : Module K M]
[inst_8 : Module K N] [inst_9 : IsScalarTower K L M] (p : M →ₗ[L] N →ₗ[L] L) [inst_10 : p.IsPerfPair] {M' : Type u_5}
{N' : Type u_6} [inst_11 : AddCommGroup M'] [inst_12 : AddCommGroup N'] [inst_13 : Module K M']
[inst_14 : Module K N'] [inst_15 : IsScalarTower K L N] (i : M' →ₗ[K] M) (j : N' →ₗ[K] N),
Function.Injective ⇑i →
Function.Injective ⇑j →
p.IsPerfectCompl (Submodule.span L ↑i.range) (Submodule.span L ↑j.range) →
∀ (hp : ∀ (m : M') (n : N'), (p (i m)) (j n) ∈ (algebraMap K L).range),
(i.restrictScalarsRange₂ j (Algebra.linearMap K L) ⋯ p hp).IsPerfPair |
Std.ExtTreeMap.maxKey.congr_simp | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] (t t_1 : Std.ExtTreeMap α β cmp)
(e_t : t = t_1) (h : t ≠ ∅), t.maxKey h = t_1.maxKey ⋯ |
_private.Lean.Meta.Basic.0.Lean.Meta.withNewLocalInstancesImpAux | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → Array Lean.Expr → ℕ → n α → n α |
Lean.Meta.Sym.ExprPtr.mk.inj | Lean.Meta.Sym.ExprPtr | ∀ {expr expr_1 : Lean.Expr}, { expr := expr } = { expr := expr_1 } → expr = expr_1 |
RestrictedProduct.instZSMul._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → SubNegMonoid (R i)] [∀ (i : ι), AddSubgroupClass (S i) (R i)] (n : ℤ)
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕), ∀ᶠ (x_1 : ι) in 𝓕, n • x x_1 ∈ ↑(B x_1) |
ComplexShape.down' | Mathlib.Algebra.Homology.ComplexShape | {α : Type u_2} → [inst : Add α] → [IsRightCancelAdd α] → α → ComplexShape α |
CategoryTheory.Limits.pushoutCoconeOfLeftIso_ι_app_none | 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], (CategoryTheory.Limits.pushoutCoconeOfLeftIso f g).ι.app none = g |
LinearMap.lTensor_ker_subtype_tensorKerEquiv_symm | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N] [inst_10 : Module R P]
(f : N →ₗ[R] P) [inst_11 : Module.Flat R M] (x : ↥((TensorProduct.AlgebraTensorModule.lTensor S M) f).ker),
(LinearMap.lTensor M f.ker.subtype) ((LinearMap.tensorKerEquiv S M f).symm x) = ↑x |
MulSemiringActionHomClass.toMulSemiringActionHom._proof_6 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_4} [inst : Monoid M] {N : Type u_5} [inst_1 : Monoid N] {φ : M →* N} {R : Type u_2} [inst_2 : Semiring R]
[inst_3 : MulSemiringAction M R] {S : Type u_1} [inst_4 : Semiring S] [inst_5 : MulSemiringAction N S] {F : Type u_3}
[inst_6 : FunLike F R S] [inst_7 : MulSemiringActionSemiHomClass F (⇑φ) R S] (f : F), (↑↑↑f).toFun 1 = 1 |
String.Pos.Raw.byteIdx_unoffsetBy | Init.Data.String.PosRaw | ∀ {p offset : String.Pos.Raw}, (p.unoffsetBy offset).byteIdx = p.byteIdx - offset.byteIdx |
Std.Sat.AIG.RefVec.fold.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Fold | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f]
(_x : (aig : Std.Sat.AIG α) ×' (_ : aig.Ref) ×' (_ : ℕ) ×' aig.RefVec len) (idx : ℕ) (h1 : idx < _x.1.decls.size)
(h2 : idx < (Std.Sat.AIG.RefVec.fold.go _x.1 _x.2.1 _x.2.2.1 len _x.2.2.2 f).aig.decls.size),
(Std.Sat.AIG.RefVec.fold.go _x.1 _x.2.1 _x.2.2.1 len _x.2.2.2 f).aig.decls[idx] = _x.1.decls[idx] |
Lean.Parser.Command.eoi._regBuiltin.Lean.Parser.Command.eoi.formatter_3 | Lean.Parser.Command | IO Unit |
Ordinal.iSup_eq_lsub_or_succ_iSup_eq_lsub | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u_4} (f : ι → Ordinal.{max u_5 u_4}), iSup f = Ordinal.lsub f ∨ Order.succ (iSup f) = Ordinal.lsub f |
one_div_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (1 / a < b ↔ 1 / b < a) |
Finset.ite_prod_one | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s : Finset ι) (f : ι → M),
(if p then ∏ x ∈ s, f x else 1) = ∏ x ∈ s, if p then f x else 1 |
DifferentiableWithinAt.insert' | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {x : E} {s : Set E} [T1Space E] {y : E},
DifferentiableWithinAt 𝕜 f s x → DifferentiableWithinAt 𝕜 f (insert y s) x |
SemidirectProduct.lift | Mathlib.GroupTheory.SemidirectProduct | {N : Type u_1} →
{G : Type u_2} →
{H : Type u_3} →
[inst : Group N] →
[inst_1 : Group G] →
[inst_2 : Group H] →
{φ : G →* MulAut N} →
(fn : N →* H) →
(fg : G →* H) →
(∀ (g : G),
fn.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (fg g))).comp fn) →
N ⋊[φ] G →* H |
List.getLast_replicate_succ | Mathlib.Data.List.Basic | ∀ {α : Type u} (m : ℕ) (a : α), (List.replicate (m + 1) a).getLast ⋯ = a |
FiberBundleCore.localTriv_symm_apply | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι) (p : B × F),
↑(Z.localTriv i).symm p = ⟨p.1, Z.coordChange i (Z.indexAt p.1) p.1 p.2⟩ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_insert_self._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) |
Finset.sum_range_tsub | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [inst_2 : Sub M] [OrderedSub M] [AddLeftMono M]
[AddLeftReflectLE M] [ExistsAddOfLE M] {f : ℕ → M},
Monotone f → ∀ (n : ℕ), ∑ i ∈ Finset.range n, (f (i + 1) - f i) = f n - f 0 |
Set.Finite.exists_finset | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∃ s', ∀ (a : α), a ∈ s' ↔ a ∈ s |
CategoryTheory.isPreconnected_op | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [CategoryTheory.IsPreconnected J],
CategoryTheory.IsPreconnected Jᵒᵖ |
CategoryTheory.Monoidal.ComonFunctorCategoryEquivalence.functorObj._proof_1 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory D]
(A : CategoryTheory.Functor C D) [inst_3 : CategoryTheory.ComonObj A] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (A.map f) CategoryTheory.ComonObj.counit = CategoryTheory.ComonObj.counit |
Module.Presentation.cokernel_relation | Mathlib.Algebra.Module.Presentation.Cokernel | ∀ {A : Type u} [inst : Ring A] {M₁ : Type v₁} {M₂ : Type v₂} [inst_1 : AddCommGroup M₁] [inst_2 : Module A M₁]
[inst_3 : AddCommGroup M₂] [inst_4 : Module A M₂] (pres₂ : Module.Presentation A M₂) {f : M₁ →ₗ[A] M₂} {ι : Type w₁}
{g₁ : ι → M₁} (data : pres₂.CokernelData f g₁) (hg₁ : Submodule.span A (Set.range g₁) = ⊤) (x : pres₂.R ⊕ ι),
(pres₂.cokernel data hg₁).relation x =
match x with
| Sum.inl r => pres₂.relation r
| Sum.inr i => data.lift i |
SubAddAction.SMulMemClass.subtype._proof_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u_3} {M : Type u_1} [inst : AddMonoid R] [inst_1 : AddAction R M] {A : Type u_2} [inst_2 : SetLike A M]
[hA : VAddMemClass A R M] (S' : A) (x : R) (x_1 : ↥S'), ↑(x +ᵥ x_1) = ↑(x +ᵥ x_1) |
Real.smoothTransition.one_of_one_le | Mathlib.Analysis.SpecialFunctions.SmoothTransition | ∀ {x : ℝ}, 1 ≤ x → x.smoothTransition = 1 |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.toPrenex.match_1.eq_2 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (x : ℕ) → motive x FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 :
(x l : ℕ) →
(R : L.Relations l) → (ts : Fin l → L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.rel R ts))
(h_4 : (x : ℕ) → (f₁ f₂ : L.BoundedFormula α x) → motive x (f₁.imp f₂))
(h_5 : (x : ℕ) → (f : L.BoundedFormula α (x + 1)) → motive x f.all),
(match x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ with
| x, FirstOrder.Language.BoundedFormula.falsum => h_1 x
| x, FirstOrder.Language.BoundedFormula.equal t₁ t₂ => h_2 x t₁ t₂
| x, FirstOrder.Language.BoundedFormula.rel R ts => h_3 x l R ts
| x, f₁.imp f₂ => h_4 x f₁ f₂
| x, f.all => h_5 x f) =
h_2 x t₁ t₂ |
isStablyFiniteRing_iff | Mathlib.Data.Matrix.Mul | ∀ (R : Type u_10) [inst : MulOne R] [inst_1 : AddCommMonoid R],
IsStablyFiniteRing R ↔ ∀ (n : ℕ), IsDedekindFiniteMonoid (Matrix (Fin n) (Fin n) R) |
TopCommRingCat.forgetToTopCatCommRing | Mathlib.Topology.Category.TopCommRingCat | (R : TopCommRingCat) → CommRing ↑((CategoryTheory.forget₂ TopCommRingCat TopCat).obj R) |
_private.Std.Time.Time.PlainTime.0.Std.Time.instDecidableEqPlainTime.decEq.match_1 | Std.Time.Time.PlainTime | (motive : Std.Time.PlainTime → Std.Time.PlainTime → Sort u_1) →
(x x_1 : Std.Time.PlainTime) →
((a : Std.Time.Hour.Ordinal) →
(a_1 : Std.Time.Minute.Ordinal) →
(a_2 : Std.Time.Second.Ordinal true) →
(a_3 : Std.Time.Nanosecond.Ordinal) →
(b : Std.Time.Hour.Ordinal) →
(b_1 : Std.Time.Minute.Ordinal) →
(b_2 : Std.Time.Second.Ordinal true) →
(b_3 : Std.Time.Nanosecond.Ordinal) →
motive { hour := a, minute := a_1, second := a_2, nanosecond := a_3 }
{ hour := b, minute := b_1, second := b_2, nanosecond := b_3 }) →
motive x x_1 |
instBialgebraCarrierUnopCommAlgCatOfMonObjOpposite._proof_10 | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u_1} [inst : CommRing R] (A : (CommAlgCat R)ᵒᵖ),
AlgHomClass (↑(Opposite.unop A) ≃ₐ[R] TensorProduct R R ↑(Opposite.unop A)) R (↑(Opposite.unop A))
(TensorProduct R R ↑(Opposite.unop A)) |
_private.Lean.Meta.Tactic.Grind.CollectParams.0.Lean.Meta.Grind.collectParams.match_1 | Lean.Meta.Tactic.Grind.CollectParams | (motive : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam → Sort u_1) →
(__discr : Bool × Array Lean.Meta.Grind.TParam × Array Lean.Meta.Grind.TParam) →
((fst : Bool) → (params anchors : Array Lean.Meta.Grind.TParam) → motive (fst, params, anchors)) → motive __discr |
AddAction.zmultiplesQuotientStabilizerEquiv._proof_4 | Mathlib.Data.ZMod.QuotientGroup | ∀ {α : Type u_2} {β : Type u_1} [inst : AddGroup α] (a : α) [inst_1 : AddAction α β] (b : β),
AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b) ≤
AddSubgroup.comap ((zmultiplesHom ↥(AddSubgroup.zmultiples a)) ⟨a, ⋯⟩)
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) |
UInt32.toNat_toBitVec | Init.Data.UInt.Lemmas | ∀ (x : UInt32), x.toBitVec.toNat = x.toNat |
Int32.toInt_toInt64 | Init.Data.SInt.Lemmas | ∀ (x : Int32), x.toInt64.toInt = x.toInt |
CategoryTheory.ObjectProperty.full_ιOfLE | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P P' : CategoryTheory.ObjectProperty C} (h : P ≤ P'),
(CategoryTheory.ObjectProperty.ιOfLE h).Full |
String.Slice.Pattern.Model.SlicesFrom | Init.Data.String.Lemmas.Pattern.Split | {s : String.Slice} → s.Pos → Type |
NonemptyFinLinOrd.dualEquiv._proof_3 | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ (X : NonemptyFinLinOrd),
CategoryTheory.CategoryStruct.comp
(NonemptyFinLinOrd.dual.map
((CategoryTheory.NatIso.ofComponents (fun X => NonemptyFinLinOrd.Iso.mk (OrderIso.dualDual ↑X.toLinOrd))
@NonemptyFinLinOrd.dualEquiv._proof_1).hom.app
X))
((CategoryTheory.NatIso.ofComponents (fun X => NonemptyFinLinOrd.Iso.mk (OrderIso.dualDual ↑X.toLinOrd))
@NonemptyFinLinOrd.dualEquiv._proof_2).hom.app
(NonemptyFinLinOrd.dual.obj X)) =
CategoryTheory.CategoryStruct.id (NonemptyFinLinOrd.dual.obj X) |
Std.HashMap.getElem!_filter' | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] [inst : Inhabited β]
{f : α → β → Bool} {k : α}, (Std.HashMap.filter f m)[k]! = (Option.filter (f k) m[k]?).get! |
Lean.Server.RequestCancellation.ctorIdx | Lean.Server.RequestCancellation | Lean.Server.RequestCancellation → ℕ |
IO.Error.instToString | Init.System.IOError | ToString IO.Error |
CategoryTheory.Bicategory.Adjunction.isAbsoluteLeftKan._proof_1 | Mathlib.CategoryTheory.Bicategory.Kan.Adjunction | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {u : b ⟶ a}
(adj : CategoryTheory.Bicategory.Adjunction f u) {x : B} (h : a ⟶ x)
(s :
CategoryTheory.Bicategory.LeftExtension f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) h)),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Bicategory.LeftExtension.mk u adj.unit).whisker h).unit
(CategoryTheory.Bicategory.whiskerLeft f
(CategoryTheory.bicategoricalComp (CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp u h))
(CategoryTheory.bicategoricalComp (CategoryTheory.Bicategory.whiskerLeft u s.unit)
(CategoryTheory.bicategoricalComp (CategoryTheory.Bicategory.whiskerRight adj.counit s.extension)
(CategoryTheory.CategoryStruct.id s.extension))))) =
CategoryTheory.bicategoricalComp
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) h))
(CategoryTheory.bicategoricalComp
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight adj.unit
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) h))
(CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategoryStruct.comp f u) s.unit))
(CategoryTheory.bicategoricalComp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight adj.counit s.extension))
(CategoryTheory.CategoryStruct.id (CategoryTheory.CategoryStruct.comp f s.extension)))) |
DerivedCategory.singleFunctorsPostcompQIso | Mathlib.Algebra.Homology.DerivedCategory.Basic | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : HasDerivedCategory C] →
DerivedCategory.singleFunctors C ≅ (CochainComplex.singleFunctors C).postcomp DerivedCategory.Q |
MonoidWithZeroHom.snd.eq_1 | Mathlib.Algebra.GroupWithZero.ProdHom | ∀ (G₀ : Type u_1) (H₀ : Type u_2) [inst : GroupWithZero G₀] [inst_1 : GroupWithZero H₀],
MonoidWithZeroHom.snd G₀ H₀ = WithZero.lift' ((Units.coeHom H₀).comp (MonoidHom.snd G₀ˣ H₀ˣ)) |
Std.DHashMap.Equiv.casesOn | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{x : BEq α} →
{x_1 : Hashable α} →
{m₁ m₂ : Std.DHashMap α β} →
{motive : m₁.Equiv m₂ → Sort u_1} →
(t : m₁.Equiv m₂) → ((inner : m₁.inner.Equiv m₂.inner) → motive ⋯) → motive t |
Units.instMul | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → Mul αˣ |
CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeTop | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], ⊤.IsStableUnderBaseChange |
AlgebraNorm.ctorIdx | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | {R : Type u_1} →
{inst : SeminormedCommRing R} → {S : Type u_2} → {inst_1 : Ring S} → {inst_2 : Algebra R S} → AlgebraNorm R S → ℕ |
CategoryTheory.MorphismProperty.LeftFraction₃.mk.inj | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {W : CategoryTheory.MorphismProperty C} {X Y Y' : C}
{f f' f'' : X ⟶ Y'} {s : Y ⟶ Y'} {hs : W s} {Y'_1 : C} {f_1 f'_1 f''_1 : X ⟶ Y'_1} {s_1 : Y ⟶ Y'_1} {hs_1 : W s_1},
{ Y' := Y', f := f, f' := f', f'' := f'', s := s, hs := hs } =
{ Y' := Y'_1, f := f_1, f' := f'_1, f'' := f''_1, s := s_1, hs := hs_1 } →
Y' = Y'_1 ∧ f ≍ f_1 ∧ f' ≍ f'_1 ∧ f'' ≍ f''_1 ∧ s ≍ s_1 |
Set.iUnion_subset_iff._simp_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α} {t : Set α}, (⋃ i, s i ⊆ t) = ∀ (i : ι), s i ⊆ t |
Subalgebra.copy._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R A) (s : Set A) (hs : s = ↑S), 0 ∈ (S.copy s hs).carrier |
Lean.Kernel.Diagnostics.mk.noConfusion | Lean.Environment | {P : Sort u} →
{unfoldCounter : Lean.PHashMap Lean.Name ℕ} →
{enabled : Bool} →
{unfoldCounter' : Lean.PHashMap Lean.Name ℕ} →
{enabled' : Bool} →
{ unfoldCounter := unfoldCounter, enabled := enabled } =
{ unfoldCounter := unfoldCounter', enabled := enabled' } →
(unfoldCounter = unfoldCounter' → enabled = enabled' → P) → P |
Lean.Server.GoToKind.ctorIdx | Lean.Server.GoTo | Lean.Server.GoToKind → ℕ |
Matrix.IsAdjMatrix.toGraph_compl_eq | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : DecidableEq α] [inst_1 : DecidableEq V] {A : Matrix V V α}
[inst_2 : MulZeroOneClass α] [inst_3 : Nontrivial α] (h : A.IsAdjMatrix), ⋯.toGraph = h.toGraphᶜ |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_9 | 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₂),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair
(⋯.fIsKernel.lift (CategoryTheory.Limits.KernelFork.ofι (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).f ⋯))
0).map
CategoryTheory.Limits.WalkingParallelPairHom.right)
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.parallelPair
(⋯.fIsKernel.lift (CategoryTheory.Limits.KernelFork.ofι (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).f ⋯))
0).obj
CategoryTheory.Limits.WalkingParallelPair.one)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.parallelPair
(⋯.fIsKernel.lift (CategoryTheory.Limits.KernelFork.ofι (X.shortComplex f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).f ⋯))
0).obj
CategoryTheory.Limits.WalkingParallelPair.zero)).hom
((CategoryTheory.Limits.parallelPair (X.δToCycles f₁ f₂ f₃ n₀ n₁ ⋯) 0).map
CategoryTheory.Limits.WalkingParallelPairHom.right) |
RootPairing.RootPositiveForm.form_apply_root_ne_zero | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing S]
[inst_1 : LinearOrder S] [inst_2 : CommRing R] [inst_3 : Algebra S R] [inst_4 : AddCommGroup M] [inst_5 : Module R M]
[inst_6 : AddCommGroup N] [inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsValuedIn S]
(B : RootPairing.RootPositiveForm S P) [FaithfulSMul S R] (i : ι), (B.form (P.root i)) (P.root i) ≠ 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.