name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Lean.Doc.Data.ConvTactic.casesOn | Lean.Elab.DocString.Builtin | {motive : Lean.Doc.Data.ConvTactic → Sort u} →
(t : Lean.Doc.Data.ConvTactic) → ((name : Lean.Name) → motive { name := name }) → motive t |
Std.DTreeMap.Raw.Equiv.maxKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.maxKey! = t₂.maxKey! |
CochainComplex.shiftFunctorAdd'._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (n₁ n₂ n₁₂ : ℤ)
(h : n₁ + n₂ = n₁₂) (K : CochainComplex C ℤ) (x x_1 : ℤ),
CategoryTheory.CategoryStruct.comp ((fun i => K.shiftFunctorObjXIso n₁₂ i (i + n₂ + n₁) ⋯) x).hom
((((CochainComplex.shiftFunctor C n₁).comp (CochainComplex.shiftFunctor C n₂)).obj K).d x x_1) =
CategoryTheory.CategoryStruct.comp (((CochainComplex.shiftFunctor C n₁₂).obj K).d x x_1)
((fun i => K.shiftFunctorObjXIso n₁₂ i (i + n₂ + n₁) ⋯) x_1).hom |
ModN.basis._proof_7 | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ {G : Type u_1} [inst : AddCommGroup G] {n : ℕ} [NeZero n] {ι : Type u_2} (b : Module.Basis ι ℤ G)
(hker :
((LinearMap.lsmul ℤ G) ↑n).range ≤
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr).ker),
Function.Injective
⇑(AddMonoidHom.toZModLinearMap n
(((LinearMap.lsmul ℤ G) ↑n).range.liftQ
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr) hker).toAddMonoidHom) ∧
Function.Surjective
⇑(AddMonoidHom.toZModLinearMap n
(((LinearMap.lsmul ℤ G) ↑n).range.liftQ
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr) hker).toAddMonoidHom) |
deriv_neg_left_of_sign_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {x₀ : ℝ},
(∀ᶠ (x : ℝ) in nhdsWithin x₀ {x₀}ᶜ, SignType.sign (deriv f x) = SignType.sign (x - x₀)) →
∀ᶠ (b : ℝ) in nhdsWithin x₀ (Set.Iio x₀), deriv f b < 0 |
MeasureTheory.stoppedValue.congr_simp | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] (u u_1 : ι → Ω → β),
u = u_1 →
∀ (τ τ_1 : Ω → WithTop ι),
τ = τ_1 → ∀ (a a_1 : Ω), a = a_1 → MeasureTheory.stoppedValue u τ a = MeasureTheory.stoppedValue u_1 τ_1 a_1 |
_private.Aesop.Script.OptimizeSyntax.0.Aesop.optimizeFocusRenameI.match_1 | Aesop.Script.OptimizeSyntax | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((ns : Array (Lean.TSyntax `ident)) → motive (some ns)) → (Unit → motive none) → motive x |
SimpleGraph.Walk.takeUntil_takeUntil | Mathlib.Combinatorics.SimpleGraph.Walks.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v u : V} [inst : DecidableEq V] {w x : V} (p : G.Walk u v) (hw : w ∈ p.support)
(hx : x ∈ (p.takeUntil w hw).support), (p.takeUntil w hw).takeUntil x hx = p.takeUntil x ⋯ |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_notMem_support._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M], Module.rank R M = ↑(Module.finrank R M) |
CategoryTheory.Functor.leibnizPushout_obj_obj | 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₃)) [inst_3 : CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryTheory.Arrow C₁) (f₂ : CategoryTheory.Arrow C₂),
(F.leibnizPushout.obj f₁).obj f₂ =
CategoryTheory.Arrow.mk (CategoryTheory.Functor.PushoutObjObj.ofHasPushout F f₁.hom f₂.hom).ι |
Module.Injective.extension_property | Mathlib.Algebra.Module.Injective | ∀ (R : Type uR) [inst : Ring R] [Small.{uM, uR} R] (M : Type uM) [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inj : Module.Injective R M] (P : Type uP) [inst_4 : AddCommGroup P] [inst_5 : Module R P] (P' : Type uP')
[inst_6 : AddCommGroup P'] [inst_7 : Module R P'] (f : P →ₗ[R] P'),
Function.Injective ⇑f → ∀ (g : P →ₗ[R] M), ∃ h, h ∘ₗ f = g |
Nat.ModEq.of_natCast | Mathlib.Data.Nat.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoidWithOne M] [CharZero M] {a b n : ℕ}, ↑a ≡ ↑b [PMOD ↑n] → a ≡ b [MOD n] |
RingQuot.Rel.sub_left | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Ring R] {r : R → R → Prop} ⦃a b c : R⦄, RingQuot.Rel r a b → RingQuot.Rel r (a - c) (b - c) |
Multiset.coe_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : List α),
Multiset.countP p ↑l = List.countP (fun b => decide (p b)) l |
MeasurableEmbedding.schroederBernstein._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α} {A B : Set α}, A ⊆ B → (g '' (f '' A)ᶜ)ᶜ ⊆ (g '' (f '' B)ᶜ)ᶜ |
Ring.ordMonoidWithZeroHom._proof_5 | Mathlib.RingTheory.OrderOfVanishing | ∀ (R : Type u_1) [inst : CommRing R] (x y : R),
(if x * y ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring.ord R (x * y))
else 0) =
(if x ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring.ord R x)
else 0) *
if y ∈ nonZeroDivisors R then
(WithZero.map' (AddMonoidHom.toMultiplicative (Nat.castAddMonoidHom ℤ))) (Ring.ord R y)
else 0 |
DyckWord.rec | Mathlib.Combinatorics.Enumerative.DyckWord | {motive : DyckWord → Sort u} →
((toList : List DyckStep) →
(count_U_eq_count_D : List.count DyckStep.U toList = List.count DyckStep.D toList) →
(count_D_le_count_U :
∀ (i : ℕ), List.count DyckStep.D (List.take i toList) ≤ List.count DyckStep.U (List.take i toList)) →
motive
{ toList := toList, count_U_eq_count_D := count_U_eq_count_D, count_D_le_count_U := count_D_le_count_U }) →
(t : DyckWord) → motive t |
SetLike.ext_iff | Mathlib.Data.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p = q ↔ ∀ (x : B), x ∈ p ↔ x ∈ q |
Matroid.closure_subset_closure_iff_subset_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax |
ZFSet.empty_subset._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x : ZFSet.{u}), (∅ ⊆ x) = True |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_12 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo hi : Fin as.size), (↑lo + ↑hi) / 2 = ↑lo → ↑lo + 1 ≤ as.size |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equation_zero._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R},
P 2 = 0 → W'.Equation P = (P 1 ^ 2 = P 0 ^ 3) |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.Tendsto.atTop_mul_const_of_neg'._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIsoAux._proof_2 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C] (F : CategoryTheory.Functor C AddCommGrpCat)
[inst_3 : CategoryTheory.Limits.PreservesFiniteLimits F] (X : C),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one Multiplicative.toAdd.toIso.hom =
CategoryTheory.MonObj.one |
UpperSet.addCommSemigroup | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} →
[inst : AddCommGroup α] → [inst_1 : Preorder α] → [IsOrderedAddMonoid α] → AddCommSemigroup (UpperSet α) |
NonUnitalContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 : NonUnitalRing A] →
[inst_7 : StarRing A] →
[inst_8 : TopologicalSpace A] →
[inst_9 : Module R A] →
[inst_10 : IsScalarTower R A A] →
[inst_11 : SMulCommClass R A A] →
{motive : NonUnitalContinuousFunctionalCalculus R A p → Sort u} →
(t : NonUnitalContinuousFunctionalCalculus R A p) →
((predicate_zero : p 0) →
[compactSpace_quasispectrum : ∀ (a : A), CompactSpace ↑(quasispectrum R a)] →
(exists_cfc_of_predicate :
∀ (a : A),
p a →
∃ φ,
Continuous ⇑φ ∧
Function.Injective ⇑φ ∧
φ
{
toContinuousMap :=
ContinuousMap.restrict (quasispectrum R a)
(ContinuousMap.id R),
map_zero' := ⋯ } =
a ∧
(∀ (f : ContinuousMapZero (↑(quasispectrum R a)) R),
quasispectrum R (φ f) = Set.range ⇑f) ∧
∀ (f : ContinuousMapZero (↑(quasispectrum R a)) R), p (φ f)) →
motive ⋯) →
motive t |
Std.DHashMap.Internal.Raw₀.getD_inter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β k},
(m₁.inter m₂).getD k fallback = if m₂.contains k = true then m₁.getD k fallback else fallback |
CategoryTheory.Limits.coneOfIsSplitMono_π_app | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y) [inst_1 : CategoryTheory.IsSplitMono f]
(X_1 : CategoryTheory.Limits.WalkingParallelPair),
(CategoryTheory.Limits.coneOfIsSplitMono f).π.app X_1 =
CategoryTheory.Limits.WalkingParallelPair.casesOn (motive := fun t =>
X_1 = t →
(((CategoryTheory.Functor.const CategoryTheory.Limits.WalkingParallelPair).obj X).obj X_1 ⟶
(CategoryTheory.Limits.parallelPair (CategoryTheory.CategoryStruct.id Y)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.retraction f) f)).obj
X_1))
X_1 (fun h => ⋯ ▸ f) (fun h => ⋯ ▸ CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y)) ⋯ |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (Φ : CategoryTheory.SmallObject.SuccStruct C)
(J : Type u_3) [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] (x x_1 : J) (f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.Functor.const J).obj Φ.X₀).map f)
(CategoryTheory.CategoryStruct.comp (Φ.iterationFunctorObjBotIso J).inv
((Φ.iterationFunctor J).map (CategoryTheory.homOfLE ⋯))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (Φ.iterationFunctorObjBotIso J).inv
((Φ.iterationFunctor J).map (CategoryTheory.homOfLE ⋯)))
((Φ.iterationFunctor J).map f) |
CategoryTheory.Limits.IsColimit.ofCoconeUncurry._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → CategoryTheory.Limits.IsColimit (D.obj j))
(s : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.uncurry.obj F)) {j j' : J} (f : j ⟶ j'),
CategoryTheory.CategoryStruct.comp (D.coconePoints.map f)
((Q j').desc
((CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.NatIso.ofComponents
(fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Prod.sectR j' K).comp (CategoryTheory.Functor.uncurry.obj F)).obj x))
⋯).inv).obj
(CategoryTheory.Limits.Cocone.whisker (CategoryTheory.Prod.sectR j' K) s))) =
CategoryTheory.CategoryStruct.comp
((Q j).desc
((CategoryTheory.Limits.Cocone.precompose
(CategoryTheory.NatIso.ofComponents
(fun x =>
CategoryTheory.Iso.refl
(((CategoryTheory.Prod.sectR j K).comp (CategoryTheory.Functor.uncurry.obj F)).obj x))
⋯).inv).obj
(CategoryTheory.Limits.Cocone.whisker (CategoryTheory.Prod.sectR j K) s)))
(((CategoryTheory.Functor.const J).obj s.pt).map f) |
_private.Mathlib.Data.Seq.Computation.0.Computation.BisimO.match_1.splitter._sparseCasesOn_5 | Mathlib.Data.Seq.Computation | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : β) → motive (Sum.inr val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
CategoryTheory.Functor.mapProjectiveResolution._proof_4 | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} D]
[inst_4 : CategoryTheory.Limits.HasZeroObject D] [inst_5 : CategoryTheory.Preadditive D]
[inst_6 : CategoryTheory.CategoryWithHomology D] (F : CategoryTheory.Functor C D) [inst_7 : F.Additive]
[F.PreservesHomology] {Z : C} (P : CategoryTheory.ProjectiveResolution Z),
QuasiIso
(CategoryTheory.CategoryStruct.comp ((F.mapHomologicalComplex (ComplexShape.down ℕ)).map P.π)
((HomologicalComplex.singleMapHomologicalComplex F (ComplexShape.down ℕ) 0).hom.app Z)) |
Plausible.Random.randBool | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {g : Type} → [RandomGen g] → Plausible.RandGT g m Bool |
Finsupp.mapRange.addEquiv_toEquiv | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (e : M ≃+ N),
↑(Finsupp.mapRange.addEquiv e) = Finsupp.mapRange.equiv ↑e ⋯ |
Projectivization.Subspace.mem_submodule_iff | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(s : Projectivization.Subspace K V) {v : V} (hv : v ≠ 0),
v ∈ Projectivization.Subspace.submodule s ↔ Projectivization.mk K v hv ∈ s |
_private.Batteries.Data.Array.Scan.0.Array.take_scanl._proof_1_3 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {f : β → α → β} (init : β) (as : Array α),
-1 * ↑as.size + 1 ≤ 0 →
i + 1 = (Array.scanl f init as).size - 1 →
i = as.size - 1 →
∀ (w : ℕ),
w + 1 ≤ ((Array.scanl f init as).extract 0 (i + 1)).size → w < (Array.scanl f init (as.extract 0 i)).size |
CategoryTheory.Functor.lanCompColimIso._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
[CategoryTheory.Limits.HasColimitsOfShape D H] (G : CategoryTheory.Functor C H),
CategoryTheory.Limits.HasColimit (L.lan.obj G) |
Finset.singletonAddHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : Add α] → α →ₙ+ Finset α |
Lean.IR.CollectUsedDecls.State.order._default | Lean.Compiler.IR.EmitUtil | Array Lean.Name |
CategoryTheory.Functor.OplaxMonoidal.δ_comp_whiskerLeft_δ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {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 D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj X)
(CategoryTheory.MonoidalCategoryStruct.tensorObj (F.obj Y) (F.obj Z)) ⟶
Z_1),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.OplaxMonoidal.δ F X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (F.obj X) (CategoryTheory.Functor.OplaxMonoidal.δ F Y Z))
h) =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Functor.OplaxMonoidal.δ F (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.Functor.OplaxMonoidal.δ F X Y) (F.obj Z))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (F.obj X) (F.obj Y) (F.obj Z)).hom h))) |
CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsCoseparator G ↔ (CategoryTheory.preadditiveYoneda.obj G).Faithful |
PiNat.self_mem_cylinder | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ), x ∈ PiNat.cylinder x n |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_inter!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
NonarchAddGroupSeminorm.coe_lt_coe | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : NonarchAddGroupSeminorm E}, ⇑p < ⇑q ↔ p < q |
Submodule.map | Mathlib.Algebra.Module.Submodule.Map | {R : Type u_1} →
{R₂ : Type u_3} →
{M : Type u_5} →
{M₂ : Type u_7} →
[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₂} → [RingHomSurjective σ₁₂] → (M →ₛₗ[σ₁₂] M₂) → Submodule R M → Submodule R₂ M₂ |
concaveOn_univ_piecewise_Iic_of_monotoneOn_Iic_antitoneOn_Ici | Mathlib.Analysis.Convex.Piecewise | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : Module 𝕜 E] [PosSMulMono 𝕜 E] [inst_7 : AddCommGroup β]
[inst_8 : PartialOrder β] [IsOrderedAddMonoid β] [inst_10 : Module 𝕜 β] [PosSMulMono 𝕜 β] {e : E} {f g : E → β},
ConcaveOn 𝕜 (Set.Iic e) f →
ConcaveOn 𝕜 (Set.Ici e) g →
MonotoneOn f (Set.Iic e) → AntitoneOn g (Set.Ici e) → f e = g e → ConcaveOn 𝕜 Set.univ ((Set.Iic e).piecewise f g) |
CategoryTheory.Discrete.sumEquiv.match_1 | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_1} →
{K : Type u_2} →
(motive : J ⊕ K → Sort u_3) →
(t : J ⊕ K) → ((j : J) → motive (Sum.inl j)) → ((k : K) → motive (Sum.inr k)) → motive t |
_private.Mathlib.Data.Set.Accumulate.0.Set.iUnion_accumulate._simp_1_1 | Mathlib.Data.Set.Accumulate | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
TopologicalSpace.ext_isClosed | Mathlib.Topology.Basic | ∀ {X : Type u_2} {t₁ t₂ : TopologicalSpace X}, (∀ (s : Set X), IsClosed s ↔ IsClosed s) → t₁ = t₂ |
CategoryTheory.Subfunctor.Subpresheaf.equalizer.ι | Mathlib.CategoryTheory.Subfunctor.Equalizer | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F₁ F₂ : CategoryTheory.Functor C (Type w)} →
{A : CategoryTheory.Subfunctor F₁} →
(f g : A.toFunctor ⟶ F₂) → (CategoryTheory.Subfunctor.equalizer f g).toFunctor ⟶ A.toFunctor |
unitary.joined | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | ∀ {A : Type u_1} [inst : CStarAlgebra A] (u v : ↥(unitary A)), ‖↑v - ↑u‖ < 2 → Joined u v |
nonneg_of_mul_nonneg_right | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [PosMulStrictMono R], 0 ≤ a * b → 0 < a → 0 ≤ b |
initFn._@.Mathlib.Tactic.Attr.Register.1131139975._hygCtx._hyg.5 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.SimpExtension |
CategoryTheory.Functor.LaxMonoidal.comp._proof_1 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCategory E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [inst_6 : F.LaxMonoidal] [inst_7 : G.LaxMonoidal]
{X Y : C} (x : X ⟶ Y) (x_1 : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((F.comp G).map x) ((F.comp G).obj x_1))
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ G (F.obj Y) (F.obj x_1))
(G.map (CategoryTheory.Functor.LaxMonoidal.μ F Y x_1))) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.μ G (F.obj X) (F.obj x_1))
(G.map (CategoryTheory.Functor.LaxMonoidal.μ F X x_1)))
((F.comp G).map (CategoryTheory.MonoidalCategoryStruct.whiskerRight x x_1)) |
instAssociativeInt8HAdd | Init.Data.SInt.Lemmas | Std.Associative fun x1 x2 => x1 + x2 |
CategoryTheory._aux_Mathlib_CategoryTheory_Category_Basic___macroRules_CategoryTheory_rfl_cat_1 | Mathlib.CategoryTheory.Category.Basic | Lean.Macro |
Finsupp.coe_smul._simp_1 | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M),
b • ⇑v = ⇑(b • v) |
SSet.Subcomplex.Pairing.II | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N |
Mathlib.Tactic.Order.AtomicFact.isTop.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (idx : ℕ), sizeOf (Mathlib.Tactic.Order.AtomicFact.isTop idx) = 1 + sizeOf idx |
Std.TreeMap.Raw.instForMProdOfMonad | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} → {m : Type w → Type w₂} → [Monad m] → ForM m (Std.TreeMap.Raw α β cmp) (α × β) |
Std.TreeMap.le_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {k : α}, (cmp k t.minKey!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true |
IsChain.succ | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsChain r s → IsChain r (SuccChain r s) |
IsLocalDiffeomorphAt.localInverse_contMDiffOn | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_4}
[inst_5 : TopologicalSpace H] {G : Type u_5} [inst_6 : TopologicalSpace G] {I : ModelWithCorners 𝕜 E H}
{J : ModelWithCorners 𝕜 F G} {M : Type u_6} [inst_7 : TopologicalSpace M] [inst_8 : ChartedSpace H M] {N : Type u_7}
[inst_9 : TopologicalSpace N] [inst_10 : ChartedSpace G N] {n : WithTop ℕ∞} {f : M → N} {x : M}
(hf : IsLocalDiffeomorphAt I J n f x), ContMDiffOn J I n (↑hf.localInverse.toPartialEquiv) hf.localInverse.source |
fderivWithin_continuousAlternatingMapCompContinuousLinearMap | Mathlib.Analysis.Calculus.FDeriv.ContinuousAlternatingMap | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G]
[inst_7 : NormedAddCommGroup H] [inst_8 : NormedSpace 𝕜 H] {f : E → G [⋀^ι]→L[𝕜] H} {g : E → F →L[𝕜] G} {s : Set E}
{x : E} [inst_9 : Fintype ι] [inst_10 : DecidableEq ι],
DifferentiableWithinAt 𝕜 f s x →
DifferentiableWithinAt 𝕜 g s x →
UniqueDiffWithinAt 𝕜 s x →
fderivWithin 𝕜 (fun x => (f x).compContinuousLinearMap (g x)) s x =
(ContinuousAlternatingMap.compContinuousLinearMapCLM (g x)).comp (fderivWithin 𝕜 f s x) +
((f x).fderivCompContinuousLinearMap (g x)).comp (fderivWithin 𝕜 g s x) |
Filter.tendsto_principal_principal | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β},
Filter.Tendsto f (Filter.principal s) (Filter.principal t) ↔ ∀ a ∈ s, f a ∈ t |
PointedCone.coe_closure | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : IsOrderedRing 𝕜] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module 𝕜 E]
[inst_7 : ContinuousConstSMul 𝕜 E] (K : PointedCone 𝕜 E), ↑K.closure = closure ↑K |
Std.TreeSet.casesOn | Std.Data.TreeSet.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{motive : Std.TreeSet α cmp → Sort u_1} →
(t : Std.TreeSet α cmp) → ((inner : Std.TreeMap α Unit cmp) → motive { inner := inner }) → motive t |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticAdmit_1 | Init.Tactics | Lean.Macro |
Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Max α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α], Std.Associative max |
NonUnitalStarAlgebra.adjoin_toNonUnitalSubalgebra | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] (s : Set A),
(NonUnitalStarAlgebra.adjoin R s).toNonUnitalSubalgebra = NonUnitalAlgebra.adjoin R (s ∪ star s) |
CategoryTheory.endofunctorMonoidalCategory_whiskerLeft_app | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {F H K : CategoryTheory.Functor C C} {β : H ⟶ K} (X : C),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft F β).app X = β.app (F.obj X) |
Set.Ico_diff_Iio | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a b \ Set.Iio c = Set.Ico (max a c) b |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long._simp_1_1 | 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} {i j : ι} [NeZero 2]
[IsDomain R] [Module.IsTorsionFree R M], P.IsOrthogonal i j = (P.pairing i j = 0) |
FractionalIdeal.coeIdeal | Mathlib.RingTheory.FractionalIdeal.Basic | {R : Type u_1} →
[inst : CommRing R] →
{S : Submonoid R} → {P : Type u_2} → [inst_1 : CommRing P] → [inst_2 : Algebra R P] → Ideal R → FractionalIdeal S P |
hasProd_prod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α]
{L : SummationFilter β} [ContinuousMul α] {f : γ → β → α} {a : γ → α} {s : Finset γ},
(∀ i ∈ s, HasProd (f i) (a i) L) → HasProd (fun b => ∏ i ∈ s, f i b) (∏ i ∈ s, a i) L |
ProbabilityTheory.Kernel.sectR._proof_1 | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_2} {β : Type u_1} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (a : α),
Measurable fun a_1 => (a, a_1) |
Nat.Coprime.mul_gcd | Init.Data.Nat.Coprime | ∀ {m n : ℕ}, m.Coprime n → ∀ (k : ℕ), (m * n).gcd k = m.gcd k * n.gcd k |
CategoryTheory.MorphismProperty.RespectsLeft.rec | Mathlib.CategoryTheory.MorphismProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.RespectsLeft Q → Sort u_1} →
((precomp : ∀ {X Y Z : C} (i : X ⟶ Y), Q i → ∀ (f : Y ⟶ Z), P f → P (CategoryTheory.CategoryStruct.comp i f)) →
motive ⋯) →
(t : P.RespectsLeft Q) → motive t |
Lean.Meta.Grind.CanonArgKey.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ (f : Lean.Expr) (i : ℕ) (arg f_1 : Lean.Expr) (i_1 : ℕ) (arg_1 : Lean.Expr),
({ f := f, i := i, arg := arg } = { f := f_1, i := i_1, arg := arg_1 }) = (f = f_1 ∧ i = i_1 ∧ arg = arg_1) |
Matrix.isUnit_conjTranspose._simp_1 | Mathlib.Data.Matrix.Invertible | ∀ {n : Type u_2} {α : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring α] [inst_3 : StarRing α]
(A : Matrix n n α), IsUnit A.conjTranspose = IsUnit A |
Std.DTreeMap.Internal.Impl.minKey!_erase_eq_of_not_compare_minKey!_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α] (h : t.WF) {k : α},
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.isEmpty = false →
¬compare k t.minKey! = Ordering.eq → (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey! = t.minKey! |
UInt8.toUInt64_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a ^^^ b).toUInt64 = a.toUInt64 ^^^ b.toUInt64 |
_private.Init.Grind.Ordered.Int.0.Lean.Grind.instOrderedRingInt._proof_1 | Init.Grind.Ordered.Int | ¬0 < 1 → False |
LinearIndepOn.notMem_span_iff | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{s : Set ι} {a : ι} {f : ι → V},
LinearIndepOn K f s → (f a ∉ Submodule.span K (f '' s) ↔ LinearIndepOn K f (insert a s) ∧ a ∉ s) |
AddCon.coe_inf._simp_1 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] {c d : AddCon M}, ⇑c ⊓ ⇑d = ⇑(c ⊓ d) |
CategoryTheory.Abelian.SpectralObject.SpectralSequence.pageD._proof_7 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r : ℤ) (pq pq' : κ) (hr : r₀ ≤ r),
(c r).Rel pq pq' → data.i₀ r pq ⋯ = data.i₂ pq' |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Raw.Internal.foldRevM.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(init : δ) (b : Std.DHashMap.Raw α β),
Std.DHashMap.Raw.Internal.foldRevM f init b =
Array.foldrM (fun l acc => Std.DHashMap.Internal.AssocList.foldrM (fun a b d => f d a b) acc l) init b.buckets |
CategoryTheory.Triangulated.AbelianSubcategory.isLimitKernelFork._proof_1 | Mathlib.CategoryTheory.Triangulated.TStructure.AbelianSubcategory | ∀ {C : Type u_4} {A : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Limits.HasZeroObject C] [inst_2 : CategoryTheory.Preadditive C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive]
[inst_5 : CategoryTheory.Pretriangulated C] [inst_6 : CategoryTheory.Category.{u_1, u_2} A]
{ι : CategoryTheory.Functor A C}
(hι : ∀ ⦃X Y : A⦄ ⦃n : ℤ⦄ (f : ι.obj X ⟶ (CategoryTheory.shiftFunctor C n).obj (ι.obj Y)), n < 0 → f = 0) {X₁ X₂ : A}
{f₁ : X₁ ⟶ X₂} {X₃ : C} {f₂ : ι.obj X₂ ⟶ X₃} {f₃ : X₃ ⟶ (CategoryTheory.shiftFunctor C 1).obj (ι.obj X₁)}
(hT :
CategoryTheory.Pretriangulated.Triangle.mk (ι.map f₁) f₂ f₃ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
{K Q : A} {α : (CategoryTheory.shiftFunctor C 1).obj (ι.obj K) ⟶ X₃} {β : X₃ ⟶ ι.obj Q}
{γ : ι.obj Q ⟶ (CategoryTheory.shiftFunctor C 1).obj ((CategoryTheory.shiftFunctor C 1).obj (ι.obj K))}
(hT' : CategoryTheory.Pretriangulated.Triangle.mk α β γ ∈ CategoryTheory.Pretriangulated.distinguishedTriangles)
[inst_7 : ι.Full] [inst_8 : CategoryTheory.Preadditive A] [inst_9 : ι.Faithful] {W' : A} (x₁ : W' ⟶ X₁)
(hx₁ : CategoryTheory.CategoryStruct.comp x₁ f₁ = 0) (m : W' ⟶ K),
CategoryTheory.CategoryStruct.comp m (CategoryTheory.Triangulated.AbelianSubcategory.ιK f₃ α) = x₁ → m = ⋯.choose |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Traversal.0.SimpleGraph.Walk.lastDart_eq_getLast_darts._proof_1_4 | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}, ¬p.Nil → p.darts.length - 1 < p.darts.length |
Lean.Meta.Grind.GoalState.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{nextDeclIdx : ℕ} →
{canon : Lean.Meta.Grind.Canon.State} →
{enodeMap : Lean.Meta.Grind.ENodeMap} →
{exprs : Lean.PArray Lean.Expr} →
{parents : Lean.Meta.Grind.ParentMap} →
{congrTable : Lean.Meta.Grind.CongrTable enodeMap} →
{appMap : Lean.PHashMap Lean.HeadIndex (List Lean.Expr)} →
{indicesFound : Lean.PHashSet Lean.HeadIndex} →
{newFacts : Array Lean.Meta.Grind.NewFact} →
{inconsistent : Bool} →
{nextIdx : ℕ} →
{newRawFacts : Std.Queue Lean.Meta.Grind.NewRawFact} →
{facts : Lean.PArray Lean.Expr} →
{extThms : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Array Lean.Meta.Ext.ExtTheorem)} →
{ematch : Lean.Meta.Grind.EMatch.State} →
{inj : Lean.Meta.Grind.Injective.State} →
{split : Lean.Meta.Grind.Split.State} →
{clean : Lean.Meta.Grind.Clean.State} →
{sstates : Array Lean.Meta.Grind.SolverExtensionState} →
{nextDeclIdx' : ℕ} →
{canon' : Lean.Meta.Grind.Canon.State} →
{enodeMap' : Lean.Meta.Grind.ENodeMap} →
{exprs' : Lean.PArray Lean.Expr} →
{parents' : Lean.Meta.Grind.ParentMap} →
{congrTable' : Lean.Meta.Grind.CongrTable enodeMap'} →
{appMap' : Lean.PHashMap Lean.HeadIndex (List Lean.Expr)} →
{indicesFound' : Lean.PHashSet Lean.HeadIndex} →
{newFacts' : Array Lean.Meta.Grind.NewFact} →
{inconsistent' : Bool} →
{nextIdx' : ℕ} →
{newRawFacts' : Std.Queue Lean.Meta.Grind.NewRawFact} →
{facts' : Lean.PArray Lean.Expr} →
{extThms' :
Lean.PHashMap Lean.Meta.Sym.ExprPtr
(Array Lean.Meta.Ext.ExtTheorem)} →
{ematch' : Lean.Meta.Grind.EMatch.State} →
{inj' : Lean.Meta.Grind.Injective.State} →
{split' : Lean.Meta.Grind.Split.State} →
{clean' : Lean.Meta.Grind.Clean.State} →
{sstates' :
Array
Lean.Meta.Grind.SolverExtensionState} →
{ nextDeclIdx := nextDeclIdx,
canon := canon,
enodeMap := enodeMap,
exprs := exprs, parents := parents,
congrTable := congrTable,
appMap := appMap,
indicesFound := indicesFound,
newFacts := newFacts,
inconsistent := inconsistent,
nextIdx := nextIdx,
newRawFacts := newRawFacts,
facts := facts, extThms := extThms,
ematch := ematch, inj := inj,
split := split, clean := clean,
sstates := sstates } =
{ nextDeclIdx := nextDeclIdx',
canon := canon',
enodeMap := enodeMap',
exprs := exprs',
parents := parents',
congrTable := congrTable',
appMap := appMap',
indicesFound := indicesFound',
newFacts := newFacts',
inconsistent := inconsistent',
nextIdx := nextIdx',
newRawFacts := newRawFacts',
facts := facts',
extThms := extThms',
ematch := ematch', inj := inj',
split := split', clean := clean',
sstates := sstates' } →
(nextDeclIdx = nextDeclIdx' →
canon = canon' →
enodeMap = enodeMap' →
exprs = exprs' →
parents = parents' →
congrTable ≍ congrTable' →
appMap = appMap' →
indicesFound =
indicesFound' →
newFacts = newFacts' →
inconsistent =
inconsistent' →
⋯) →
P |
continuousMultilinearCurryFin0._proof_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G : Type u_2) (G' : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G']
(x x_1 : ContinuousMultilinearMap 𝕜 (fun i => G) G'), (x + x_1).curry0 = (x + x_1).curry0 |
WithZero.instRepr | Mathlib.Algebra.Group.WithOne.Defs | {α : Type u} → [Repr α] → Repr (WithZero α) |
CategoryTheory.MorphismProperty.Comma.mapRightIso_inverse_map_right | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
(L : CategoryTheory.Functor A T) {P : CategoryTheory.MorphismProperty T} {Q : CategoryTheory.MorphismProperty A}
{W : CategoryTheory.MorphismProperty B} [inst_3 : Q.IsMultiplicative] [inst_4 : W.IsMultiplicative]
{R₁ R₂ : CategoryTheory.Functor B T} [inst_5 : P.RespectsIso] [inst_6 : Q.RespectsIso] [inst_7 : W.RespectsIso]
(e : R₁ ≅ R₂) {X Y : CategoryTheory.MorphismProperty.Comma L R₂ P Q W} (f : X ⟶ Y),
((CategoryTheory.MorphismProperty.Comma.mapRightIso L e).inverse.map f).right =
(CategoryTheory.MorphismProperty.Comma.Hom.hom f).right |
Lean.PersistentArrayNode.brecOn.eq | Lean.Data.PersistentArray | ∀ {α : Type u} {motive_1 : Lean.PersistentArrayNode α → Sort u_1}
{motive_2 : Array (Lean.PersistentArrayNode α) → Sort u_1} {motive_3 : List (Lean.PersistentArrayNode α) → Sort u_1}
(t : Lean.PersistentArrayNode α) (F_1 : (t : Lean.PersistentArrayNode α) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.PersistentArrayNode α)) → Lean.PersistentArrayNode.below_1 t → motive_2 t)
(F_3 : (t : List (Lean.PersistentArrayNode α)) → Lean.PersistentArrayNode.below_2 t → motive_3 t),
t.brecOn F_1 F_2 F_3 = F_1 t (Lean.PersistentArrayNode.brecOn.go t F_1 F_2 F_3).2 |
ContinuousLinearMap.bilinearRestrictScalars_eq_restrictScalars_restrictScalarsL_comp | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {E : Type u_4} {F : Type u_6} {G : Type u_8} {𝕜' : Type u_11} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedAddCommGroup E]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E]
[inst_7 : SeminormedAddCommGroup F] [inst_8 : NormedSpace 𝕜 F] [inst_9 : NormedSpace 𝕜' F]
[inst_10 : IsScalarTower 𝕜 𝕜' F] [inst_11 : SeminormedAddCommGroup G] [inst_12 : NormedSpace 𝕜 G]
[inst_13 : NormedSpace 𝕜' G] [inst_14 : IsScalarTower 𝕜 𝕜' G] (B : E →L[𝕜'] F →L[𝕜'] G),
ContinuousLinearMap.bilinearRestrictScalars 𝕜 B =
ContinuousLinearMap.restrictScalars 𝕜 ((ContinuousLinearMap.restrictScalarsL 𝕜' F G 𝕜 𝕜').comp B) |
Module.Basis.ofIsLocalizedModule_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} (Rₛ : Type u_2) [inst : CommSemiring R] (S : Submonoid R) [inst_1 : CommSemiring Rₛ]
[inst_2 : Algebra R Rₛ] [inst_3 : IsLocalization S Rₛ] {M : Type u_3} {Mₛ : Type u_4} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : AddCommMonoid Mₛ] [inst_7 : Module R Mₛ] [inst_8 : Module Rₛ Mₛ]
[inst_9 : IsScalarTower R Rₛ Mₛ] (f : M →ₗ[R] Mₛ) [inst_10 : IsLocalizedModule S f] {ι : Type u_5}
(b : Module.Basis ι R M) (i : ι), (Module.Basis.ofIsLocalizedModule Rₛ S f b) i = f (b i) |
Nat.dist_tri_right' | Mathlib.Data.Nat.Dist | ∀ (n m : ℕ), n ≤ m + n.dist m |
ClusterPt.mono | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {f g : Filter X}, ClusterPt x f → f ≤ g → ClusterPt x g |
Lean.PersistentHashMap.mapMAux | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type u} →
{m : Type u → Type w} →
[Monad m] → (β → m σ) → Lean.PersistentHashMap.Node α β → m (Lean.PersistentHashMap.Node α σ) |
Std.TreeMap.getKey_alter_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [Inhabited α] {k : α}
{f : Option β → Option β} {hc : k ∈ t.alter k f}, (t.alter k f).getKey k hc = k |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.