name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Functor.ranCounit._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{u_2, u_3} H]
[inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasRightKanExtension F] {F₁ F₂ : CategoryTheory.Functor C H}
(φ : F₁ ⟶ F₂),
CategoryTheory.CategoryStruct.comp ((L.ran.comp ((CategoryTheory.Functor.whiskeringLeft C D H).obj L)).map φ)
(L.rightKanExtensionCounit F₂) =
CategoryTheory.CategoryStruct.comp (L.rightKanExtensionCounit F₁)
((CategoryTheory.Functor.id (CategoryTheory.Functor C H)).map φ) |
CategoryTheory.ShortComplex.SnakeInput.L₀'._proof_1 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₁.f S.L₁.g = CategoryTheory.CategoryStruct.comp 0 S.v₀₁.τ₃ |
AddSubgroup.instMeasurableVAdd | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : MeasurableSpace α] [inst_2 : AddGroup G]
[inst_3 : AddAction G α] [MeasurableVAdd G α] (s : AddSubgroup G), MeasurableVAdd (↥s) α |
Complex.ofReal_exp._simp_1 | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℝ), Complex.exp ↑x = ↑(Real.exp x) |
ContravariantClass.mk._flat_ctor | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {M : Type u_1} {N : Type u_2} {μ : M → N → N} {r : N → N → Prop}, Contravariant M N μ r → ContravariantClass M N μ r |
Lean.Elab.Tactic.evalWithAnnotateState._regBuiltin.Lean.Elab.Tactic.evalWithAnnotateState_1 | Lean.Elab.Tactic.BuiltinTactic | IO Unit |
SubmonoidClass.coe_multiset_prod | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {B : Type u_3} {S : B} {M : Type u_4} [inst : CommMonoid M] [inst_1 : SetLike B M] [inst_2 : SubmonoidClass B M]
(m : Multiset ↥S), ↑m.prod = (Multiset.map Subtype.val m).prod |
MeasureTheory.measure_biUnion_le | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {ι : Type u_2} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α]
{I : Set ι} (μ : F), I.Countable → ∀ (s : ι → Set α), μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i) |
instBooleanAlgebraSubtypeProdAndEqHMulFstSndOfNatHAdd._proof_15 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommSemiring R] (x x_1 : { a // a.1 * a.2 = 0 ∧ a.1 + a.2 = 1 }), x_1 ⊔ xᶜ = x_1 ⊔ xᶜ |
Bool.eq_true_of_true_le | Init.Data.Bool | ∀ {x : Bool}, true ≤ x → x = true |
Lean.Grind.AC.Seq.isVar | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq → Bool |
CochainComplex.HomComplex.Cochain.toSingleMk_v_eq_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ X) {n : ℤ}
(h : p + n = q) (p' q' : ℤ) (hpq' : p' + n = q'),
p' ≠ p → (CochainComplex.HomComplex.Cochain.toSingleMk f h).v p' q' hpq' = 0 |
List.extract_eq_drop_take | Init.Data.List.Basic | ∀ {α : Type u_1} {l : List α} {start stop : ℕ}, l.extract start stop = List.take (stop - start) (List.drop start l) |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Basic.0.Std.Tactic.BVDecide.BVExpr.toString.match_1.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ (motive : (w : ℕ) → Std.Tactic.BVDecide.BVExpr w → Sort u_1) (w idx : ℕ)
(h_1 : (w idx : ℕ) → motive w (Std.Tactic.BVDecide.BVExpr.var idx))
(h_2 : (w : ℕ) → (val : BitVec w) → motive w (Std.Tactic.BVDecide.BVExpr.const val))
(h_3 :
(len w start : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w) → motive len (Std.Tactic.BVDecide.BVExpr.extract start len expr))
(h_4 :
(w : ℕ) →
(lhs : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tactic.BVDecide.BVBinOp) → (rhs : Std.Tactic.BVDecide.BVExpr w) → motive w (lhs.bin op rhs))
(h_5 :
(w : ℕ) →
(op : Std.Tactic.BVDecide.BVUnOp) →
(operand : Std.Tactic.BVDecide.BVExpr w) → motive w (Std.Tactic.BVDecide.BVExpr.un op operand))
(h_6 :
(w l r : ℕ) →
(lhs : Std.Tactic.BVDecide.BVExpr l) →
(rhs : Std.Tactic.BVDecide.BVExpr r) → (h : w = l + r) → motive w (lhs.append rhs h))
(h_7 :
(w w_1 n : ℕ) →
(expr : Std.Tactic.BVDecide.BVExpr w_1) →
(h : w = w_1 * n) → motive w (Std.Tactic.BVDecide.BVExpr.replicate n expr h))
(h_8 :
(w n : ℕ) →
(lhs : Std.Tactic.BVDecide.BVExpr w) → (rhs : Std.Tactic.BVDecide.BVExpr n) → motive w (lhs.shiftLeft rhs))
(h_9 :
(w n : ℕ) →
(lhs : Std.Tactic.BVDecide.BVExpr w) → (rhs : Std.Tactic.BVDecide.BVExpr n) → motive w (lhs.shiftRight rhs))
(h_10 :
(w n : ℕ) →
(lhs : Std.Tactic.BVDecide.BVExpr w) → (rhs : Std.Tactic.BVDecide.BVExpr n) → motive w (lhs.arithShiftRight rhs)),
(match w, Std.Tactic.BVDecide.BVExpr.var idx with
| w, Std.Tactic.BVDecide.BVExpr.var idx => h_1 w idx
| w, Std.Tactic.BVDecide.BVExpr.const val => h_2 w val
| len, Std.Tactic.BVDecide.BVExpr.extract start .(len) expr => h_3 len w start expr
| w, lhs.bin op rhs => h_4 w lhs op rhs
| w, Std.Tactic.BVDecide.BVExpr.un op operand => h_5 w op operand
| w, lhs.append rhs h => h_6 w l r lhs rhs h
| w, Std.Tactic.BVDecide.BVExpr.replicate n expr h => h_7 w w_1 n expr h
| w, lhs.shiftLeft rhs => h_8 w n lhs rhs
| w, lhs.shiftRight rhs => h_9 w n lhs rhs
| w, lhs.arithShiftRight rhs => h_10 w n lhs rhs) =
h_1 w idx |
Manifold.wrapped._@.Mathlib.Geometry.Manifold.Riemannian.PathELength.2732887573._hygCtx._hyg.75 | Mathlib.Geometry.Manifold.Riemannian.PathELength | Subtype (Eq @Manifold.definition✝) |
FirstOrder.Language.Embedding.substructureEquivMap.match_3 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.Embedding M N) (s : L.Substructure M) (motive : ↥(FirstOrder.Language.Substructure.map f.toHom s) → Prop)
(x : ↥(FirstOrder.Language.Substructure.map f.toHom s)),
(∀ (val : N) (hn : val ∈ FirstOrder.Language.Substructure.map f.toHom s), motive ⟨val, hn⟩) → motive x |
Std.ExtHashMap.getKey_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α} {k k' : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → ∀ {h : k' ∈ m.insertManyIfNewUnit l}, (m.insertManyIfNewUnit l).getKey k' h = k |
Polynomial.Separable.of_mul_right | Mathlib.FieldTheory.Separable | ∀ {R : Type u} [inst : CommSemiring R] {f g : Polynomial R}, (f * g).Separable → g.Separable |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.step_filterMapM.match_1.splitter | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | {β β' : Type u_1} →
{n : Type u_1 → Type u_2} →
{f : β → n (Option β')} →
[inst : MonadAttach n] →
(out : β) →
(motive : Subtype (MonadAttach.CanReturn (f out)) → Sort u_3) →
(__do_lift : Subtype (MonadAttach.CanReturn (f out))) →
((hf : MonadAttach.CanReturn (f out) none) → motive ⟨none, hf⟩) →
((out' : β') → (hf : MonadAttach.CanReturn (f out) (some out')) → motive ⟨some out', hf⟩) →
motive __do_lift |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.laxBraidedToCommMon._proof_2 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C]
{X Y Z : CategoryTheory.LaxBraidedFunctor (CategoryTheory.Discrete PUnit.{u_1 + 1}) C} (f : X ⟶ Y) (g : Y ⟶ Z),
((CategoryTheory.Functor.mapCommMonFunctor (CategoryTheory.Discrete PUnit.{u_1 + 1}) C).map
(CategoryTheory.CategoryStruct.comp f g)).app
(CategoryTheory.CommMon.trivial (CategoryTheory.Discrete PUnit.{u_1 + 1})) =
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.mapCommMonFunctor (CategoryTheory.Discrete PUnit.{u_1 + 1}) C).map f).app
(CategoryTheory.CommMon.trivial (CategoryTheory.Discrete PUnit.{u_1 + 1})))
(((CategoryTheory.Functor.mapCommMonFunctor (CategoryTheory.Discrete PUnit.{u_1 + 1}) C).map g).app
(CategoryTheory.CommMon.trivial (CategoryTheory.Discrete PUnit.{u_1 + 1}))) |
Lean.CollectAxioms.State.axioms | Lean.Util.CollectAxioms | Lean.CollectAxioms.State → Array Lean.Name |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_of_mem_insertIfNew._simp_1_1 | 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) |
SemidirectProduct.card | Mathlib.GroupTheory.SemidirectProduct | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {φ : G →* MulAut N},
Nat.card (N ⋊[φ] G) = Nat.card N * Nat.card G |
_private.Mathlib.Analysis.Normed.Module.RCLike.Real.0.closure_ball._simp_1_1 | Mathlib.Analysis.Normed.Module.RCLike.Real | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True |
Invertible.algebraMapOfInvertibleAlgebraMap._proof_2 | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₗ[R] B),
f 1 = 1 → ∀ {r : R} (h : Invertible ((algebraMap R A) r)), (algebraMap R B) r * f ⅟((algebraMap R A) r) = 1 |
NNReal.coe_add._simp_1 | Mathlib.Data.NNReal.Defs | ∀ (r₁ r₂ : NNReal), ↑r₁ + ↑r₂ = ↑(r₁ + r₂) |
_private.Batteries.Data.Array.Scan.0.Array.scanrM.loop_toList._proof_1_2 | Batteries.Data.Array.Scan | ∀ {α : Type u_1} {as : Array α} {stop start : ℕ}, start - stop = 0 → stop < start → False |
HomotopyCategory.spectralObjectMappingCone._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.SpectralObject | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C]
(D₁ D₂ : CategoryTheory.ComposableArrows (CochainComplex C ℤ) 2) (φ : D₁ ⟶ D₂),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.ComposableArrows.functorArrows (CochainComplex C ℤ) 1 2 2
CategoryTheory.Triangulated.SpectralObject._proof_2
CategoryTheory.Triangulated.SpectralObject._proof_4).comp
((HomotopyCategory.composableArrowsFunctor C).comp (HomotopyCategory.quotient C (ComplexShape.up ℤ)))).map
φ)
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).mapTriangle.obj
(CochainComplex.mappingConeCompTriangle
(D₂.map' 0 1 HomotopyCategory.composableArrowsFunctor._proof_2
HomotopyCategory.spectralObjectMappingCone._proof_2)
(D₂.map' 1 2 HomotopyCategory.spectralObjectMappingCone._proof_2
HomotopyCategory.spectralObjectMappingCone._proof_3))).mor₃ =
CategoryTheory.CategoryStruct.comp
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).mapTriangle.obj
(CochainComplex.mappingConeCompTriangle
(D₁.map' 0 1 HomotopyCategory.composableArrowsFunctor._proof_2
HomotopyCategory.spectralObjectMappingCone._proof_2)
(D₁.map' 1 2 HomotopyCategory.spectralObjectMappingCone._proof_2
HomotopyCategory.spectralObjectMappingCone._proof_3))).mor₃
(((CategoryTheory.ComposableArrows.functorArrows (CochainComplex C ℤ) 0 1 2
CategoryTheory.Triangulated.SpectralObject._proof_6
CategoryTheory.Triangulated.SpectralObject._proof_2).comp
(((HomotopyCategory.composableArrowsFunctor C).comp (HomotopyCategory.quotient C (ComplexShape.up ℤ))).comp
(CategoryTheory.shiftFunctor (HomotopyCategory C (ComplexShape.up ℤ)) 1))).map
φ) |
MeasureTheory.VectorMeasure.instAddCommGroup._proof_3 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : TopologicalSpace M] [IsTopologicalAddGroup M],
ContinuousConstSMul ℤ M |
AlgebraicGeometry.Scheme.GlueData.instPreservesColimitWalkingMultispanProdJMultispanDiagramForget | Mathlib.AlgebraicGeometry.Gluing | ∀ (D : AlgebraicGeometry.Scheme.GlueData),
CategoryTheory.Limits.PreservesColimit D.diagram.multispan AlgebraicGeometry.Scheme.forget |
Lean.MonadNameGenerator.setNGen | Init.Meta.Defs | {m : Type → Type} → [self : Lean.MonadNameGenerator m] → Lean.NameGenerator → m Unit |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.partialMatch_add_one_add_one_iff._proof_1_9 | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat : ByteArray} {s : ByteArray} {stackPos : ℕ} {needlePos : ℕ}, stackPos + 1 ≤ s.size → ¬stackPos < s.size → False |
Std.Sat.AIG.Entrypoint.ref | Std.Sat.AIG.Basic | {α : Type} → [inst : DecidableEq α] → [inst_1 : Hashable α] → (self : Std.Sat.AIG.Entrypoint α) → self.aig.Ref |
Aesop.PhaseSpec.ctorIdx | Aesop.Builder.Basic | Aesop.PhaseSpec → ℕ |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.existsRatHint_of_ratHintsExhaustive._proof_1_27 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RatAddSound | ∀ {n : ℕ} (f : Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n) (i : ℕ), i + 1 ≤ f.clauses.size → i < f.clauses.size |
CategoryTheory.MonoidalCategory.DayConvolution.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.DayConvolution | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{V : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} V] →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 : CategoryTheory.MonoidalCategory V] →
{F G : CategoryTheory.Functor C V} →
(convolution : CategoryTheory.Functor C V) →
(unit :
CategoryTheory.MonoidalCategory.externalProduct F G ⟶
(CategoryTheory.MonoidalCategory.tensor C).comp convolution) →
(CategoryTheory.Functor.LeftExtension.mk convolution unit).IsPointwiseLeftKanExtension →
CategoryTheory.MonoidalCategory.DayConvolution F G |
IsCoinitial | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → Prop |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mkNaturalityRightUnitor | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality m] →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ → Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Lean.Expr |
Lean.Lsp.DependencyBuildMode.recOn | Lean.Data.Lsp.Extra | {motive : Lean.Lsp.DependencyBuildMode → Sort u} →
(t : Lean.Lsp.DependencyBuildMode) →
motive Lean.Lsp.DependencyBuildMode.always →
motive Lean.Lsp.DependencyBuildMode.once → motive Lean.Lsp.DependencyBuildMode.never → motive t |
_private.Mathlib.NumberTheory.LucasLehmer.0.Mathlib.Meta.Positivity.evalMersenne._sparseCasesOn_4 | Mathlib.NumberTheory.LucasLehmer | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{pα : Q(PartialOrder «$α»)} →
{e : Q(«$α»)} →
{motive : Mathlib.Meta.Positivity.Strictness zα pα e → Sort u} →
(t : Mathlib.Meta.Positivity.Strictness zα pα e) →
((pf : Q(0 < «$e»)) → motive (Mathlib.Meta.Positivity.Strictness.positive pf)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
TopCat.GlueData.MkCore.mk.sizeOf_spec | Mathlib.Topology.Gluing | ∀ {J : Type u} (U : J → TopCat) (V : (i : J) → J → TopologicalSpace.Opens ↑(U i))
(t :
(i j : J) →
(TopologicalSpace.Opens.toTopCat (U i)).obj (V i j) ⟶ (TopologicalSpace.Opens.toTopCat (U j)).obj (V j i))
(V_id : ∀ (i : J), V i i = ⊤) (t_id : ∀ (i : J), ⇑(CategoryTheory.ConcreteCategory.hom (t i i)) = id)
(t_inter :
∀ ⦃i j : J⦄ (k : J) (x : ↥(V i j)), ↑x ∈ V i k → ↑((CategoryTheory.ConcreteCategory.hom (t i j)) x) ∈ V j k)
(cocycle :
∀ (i j k : J) (x : ↥(V i j)) (h : ↑x ∈ V i k),
↑((CategoryTheory.ConcreteCategory.hom (t j k)) ⟨↑((CategoryTheory.ConcreteCategory.hom (t i j)) x), ⋯⟩) =
↑((CategoryTheory.ConcreteCategory.hom (t i k)) ⟨↑x, h⟩)),
sizeOf { J := J, U := U, V := V, t := t, V_id := V_id, t_id := t_id, t_inter := t_inter, cocycle := cocycle } =
1 + sizeOf J |
CategoryTheory.Functor.PreOneHypercoverDenseData.toPreOneHypercover_Y | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X) (x x_1 : data.I₀)
(j : data.I₁ x x_1), data.toPreOneHypercover.Y j = F.obj (data.Y j) |
GroupCone.mem_oneLE._simp_2 | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : CommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedMonoid H] {a : H},
(a ∈ GroupCone.oneLE H) = (1 ≤ a) |
PFun.restrict | Mathlib.Data.PFun | {α : Type u_1} → {β : Type u_2} → (f : α →. β) → {p : Set α} → p ⊆ f.Dom → α →. β |
symmDiff_eq_bot._simp_1 | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, (symmDiff a b = ⊥) = (a = b) |
Std.DTreeMap.Internal.Impl.balanceL.match_3.congr_eq_3 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β) (ls : ℕ) (lk : α)
(lv : β lk)
(motive :
(ll lr : Std.DTreeMap.Internal.Impl α β) →
(Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced →
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size →
Sort u_3)
(ll lr : Std.DTreeMap.Internal.Impl α β) (hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).Balanced)
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond (Std.DTreeMap.Internal.Impl.inner ls lk lv ll lr).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size)
(h_1 :
(lls : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(lrs : ℕ) →
(lrk : α) →
(lrv : β lrk) →
(lrl lrr : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr)).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv
(Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr)).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1)
(Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr) hlb hlr)
(h_2 :
(size : ℕ) →
(k_1 : α) →
(v_1 : β k_1) →
(l_1 r_1 : Std.DTreeMap.Internal.Impl α β) →
(hlb :
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1)
Std.DTreeMap.Internal.Impl.leaf).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1)
Std.DTreeMap.Internal.Impl.leaf).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive (Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1) Std.DTreeMap.Internal.Impl.leaf hlb hlr)
(h_3 :
(x : Std.DTreeMap.Internal.Impl α β) →
(hlb : (Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).Balanced) →
(hlr :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size) →
motive Std.DTreeMap.Internal.Impl.leaf x hlb hlr)
(x : Std.DTreeMap.Internal.Impl α β)
(hlb_1 : (Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).Balanced)
(hlr_1 :
Std.DTreeMap.Internal.Impl.BalanceLPrecond
(Std.DTreeMap.Internal.Impl.inner ls lk lv Std.DTreeMap.Internal.Impl.leaf x).size
(Std.DTreeMap.Internal.Impl.inner rs k v l r).size),
ll = Std.DTreeMap.Internal.Impl.leaf →
lr = x →
hlb ≍ hlb_1 →
hlr = hlr_1 →
(match ll, lr, hlb, hlr with
| Std.DTreeMap.Internal.Impl.inner lls k_1 v_1 l_1 r_1,
Std.DTreeMap.Internal.Impl.inner lrs lrk lrv lrl lrr, hlb, hlr =>
h_1 lls k_1 v_1 l_1 r_1 lrs lrk lrv lrl lrr hlb hlr
| Std.DTreeMap.Internal.Impl.inner size k_1 v_1 l_1 r_1, Std.DTreeMap.Internal.Impl.leaf, hlb, hlr =>
h_2 size k_1 v_1 l_1 r_1 hlb hlr
| Std.DTreeMap.Internal.Impl.leaf, x, hlb, hlr => h_3 x hlb hlr) ≍
h_3 x hlb_1 hlr_1 |
Lean.Syntax.getOptional? | Init.Prelude | Lean.Syntax → Option Lean.Syntax |
Std.Sat.AIG.ExtendTarget.w | Std.Sat.AIG.Basic | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {aig : Std.Sat.AIG α} → {newWidth : ℕ} → aig.ExtendTarget newWidth → ℕ |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_eq_get!_getKey?._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) |
Array.find? | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Option α |
Nat.Partrec.below.casesOn | Mathlib.Computability.Partrec | ∀ {motive : (a : ℕ →. ℕ) → Nat.Partrec a → Prop}
{motive_1 : {a : ℕ →. ℕ} → (t : Nat.Partrec a) → Nat.Partrec.below t → Prop} {a : ℕ →. ℕ} {t : Nat.Partrec a}
(t_1 : Nat.Partrec.below t),
motive_1 Nat.Partrec.zero ⋯ →
motive_1 Nat.Partrec.succ ⋯ →
motive_1 Nat.Partrec.left ⋯ →
motive_1 Nat.Partrec.right ⋯ →
(∀ {f g : ℕ →. ℕ} (a : Nat.Partrec f) (a_1 : Nat.Partrec g) (ih : Nat.Partrec.below a) (a_ih : motive f a)
(ih_1 : Nat.Partrec.below a_1) (a_ih_1 : motive g a_1), motive_1 ⋯ ⋯) →
(∀ {f g : ℕ →. ℕ} (a : Nat.Partrec f) (a_1 : Nat.Partrec g) (ih : Nat.Partrec.below a) (a_ih : motive f a)
(ih_1 : Nat.Partrec.below a_1) (a_ih_1 : motive g a_1), motive_1 ⋯ ⋯) →
(∀ {f g : ℕ →. ℕ} (a : Nat.Partrec f) (a_1 : Nat.Partrec g) (ih : Nat.Partrec.below a) (a_ih : motive f a)
(ih_1 : Nat.Partrec.below a_1) (a_ih_1 : motive g a_1), motive_1 ⋯ ⋯) →
(∀ {f : ℕ →. ℕ} (a : Nat.Partrec f) (ih : Nat.Partrec.below a) (a_ih : motive f a), motive_1 ⋯ ⋯) →
motive_1 t t_1 |
Multiset.prod_min_le | Mathlib.Algebra.Order.BigOperators.Group.Multiset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : LinearOrder α] [IsOrderedMonoid α] {s : Multiset ι}
{f g : ι → α}, (Multiset.map (fun i => min (f i) (g i)) s).prod ≤ min (Multiset.map f s).prod (Multiset.map g s).prod |
NeZero | Init.Data.NeZero | {R : Type u_1} → [Zero R] → R → Prop |
Vector.snd_lt_add_of_mem_zipIdx | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {x : α × ℕ} {k : ℕ} {xs : Vector α n}, x ∈ xs.zipIdx k → x.2 < k + n |
ArchimedeanClass.exists_int_ge_of_mk_nonneg | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {x : R},
0 ≤ ArchimedeanClass.mk x → ∃ n, x ≤ ↑n |
CliffordAlgebra.EvenHom.mk | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] →
(bilin : M →ₗ[R] M →ₗ[R] A) →
(∀ (m : M), (bilin m) m = (algebraMap R A) (Q m)) →
(∀ (m₁ m₂ m₃ : M), (bilin m₁) m₂ * (bilin m₂) m₃ = Q m₂ • (bilin m₁) m₃) →
CliffordAlgebra.EvenHom Q A |
Std.DTreeMap.Internal.Cell.get?.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.OrientedOrd α] [inst_2 : Std.LawfulEqOrd α] {k : α}
(c : Std.DTreeMap.Internal.Cell α β (compare k)),
c.get? =
match h : c.inner with
| none => none
| some p => some (cast ⋯ p.snd) |
DFinsupp.instCanonicallyOrderedAddOfAddLeftMono | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} (α : ι → Type u_2) [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)] [∀ (i : ι), OrderedSub (α i)]
[∀ (i : ι), AddLeftMono (α i)], CanonicallyOrderedAdd (Π₀ (i : ι), α i) |
ClosureOperator.noConfusion | Mathlib.Order.Closure | {P : Sort u} →
{α : Type u_1} →
{inst : Preorder α} →
{t : ClosureOperator α} →
{α' : Type u_1} →
{inst' : Preorder α'} →
{t' : ClosureOperator α'} → α = α' → inst ≍ inst' → t ≍ t' → ClosureOperator.noConfusionType P t t' |
_private.Init.Data.List.Find.0.List.lt_findIdx_iff._proof_1_3 | Init.Data.List.Find | ∀ {α : Type u_1} (xs : List α) (p : α → Bool),
∀ i < List.findIdx p xs, List.findIdx p xs ≤ xs.length → ¬i < xs.length → False |
Lean.Lsp.InlayHintParams | Lean.Data.Lsp.LanguageFeatures | Type |
DifferentiableOn.sum | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : 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] {s : Set E}
{ι : Type u_4} {u : Finset ι} {A : ι → E → F},
(∀ i ∈ u, DifferentiableOn 𝕜 (A i) s) → DifferentiableOn 𝕜 (∑ i ∈ u, A i) s |
MeasurableEquiv.piCongrLeft.eq_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {δ : Type u_4} {δ' : Type u_5} (π : δ' → Type u_6) [inst : (x : δ') → MeasurableSpace (π x)] (f : δ ≃ δ'),
MeasurableEquiv.piCongrLeft π f = { toEquiv := Equiv.piCongrLeft π f, measurable_toFun := ⋯, measurable_invFun := ⋯ } |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabUnsafe._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
PartOrdEmb.of.injEq | Mathlib.Order.Category.PartOrdEmb | ∀ (carrier : Type u_1) [str : PartialOrder carrier] (carrier_1 : Type u_1) (str_1 : PartialOrder carrier_1),
({ carrier := carrier, str := str } = { carrier := carrier_1, str := str_1 }) = (carrier = carrier_1 ∧ str ≍ str_1) |
Batteries.CodeAction.instInhabitedTacticCodeActionEntry.default | Batteries.CodeAction.Attr | Batteries.CodeAction.TacticCodeActionEntry |
neZero_iff | Init.Data.NeZero | ∀ {R : Type u_1} [inst : Zero R] {n : R}, NeZero n ↔ n ≠ 0 |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.Basic.0.CategoryTheory.Pretriangulated.opShiftFunctorEquivalence_add_unitIso_inv_app_eq._simp_1_2 | Mathlib.CategoryTheory.Triangulated.Opposite.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) |
Finsupp.instAddGroup._proof_12 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddGroup G] (x : ι →₀ G), -x + x = 0 |
CategoryTheory.ObjectProperty.coproductFromFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.CostructuredArrow P.ι X → C |
StieltjesFunction.mk.inj | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} {inst : LinearOrder R} {inst_1 : TopologicalSpace R} {toFun : R → ℝ} {mono' : Monotone toFun}
{right_continuous' : ∀ (x : R), ContinuousWithinAt toFun (Set.Ici x) x} {toFun_1 : R → ℝ} {mono'_1 : Monotone toFun_1}
{right_continuous'_1 : ∀ (x : R), ContinuousWithinAt toFun_1 (Set.Ici x) x},
{ toFun := toFun, mono' := mono', right_continuous' := right_continuous' } =
{ toFun := toFun_1, mono' := mono'_1, right_continuous' := right_continuous'_1 } →
toFun = toFun_1 |
_private.Mathlib.Algebra.Order.GroupWithZero.Canonical.0.instLinearOrderedAddCommGroupWithTopAdditiveOrderDual._simp_3 | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u} {a b : Additive α}, (a = b) = (Additive.toMul a = Additive.toMul b) |
LightProfinite.instEpiAppOppositeNatπAsLimitCone | Mathlib.Topology.Category.LightProfinite.Extend | ∀ (S : LightProfinite) (i : ℕᵒᵖ), CategoryTheory.Epi (S.asLimitCone.π.app i) |
Lean.Lsp.SymbolKind.interface.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.SymbolKind → Sort u} →
(t : Lean.Lsp.SymbolKind) → t.ctorIdx = 10 → motive Lean.Lsp.SymbolKind.interface → motive t |
ProfiniteAddGrp.hom_ext | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {A B : ProfiniteAddGrp.{u}} {f g : A ⟶ B}, ProfiniteAddGrp.Hom.hom f = ProfiniteAddGrp.Hom.hom g → f = g |
notMem_nonZeroDivisorsLeft_iff | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ (M₀ : Type u_1) [inst : MonoidWithZero M₀] {x : M₀}, x ∉ nonZeroDivisorsLeft M₀ ↔ {y | x * y = 0 ∧ y ≠ 0}.Nonempty |
Lean.RBNode.isSingleton | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → Lean.RBNode α β → Bool |
Std.Iter.toArray_drop | Std.Data.Iterators.Lemmas.Combinators.Drop | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {n : ℕ} [Std.Iterators.Finite α Id] {it : Std.Iter β},
(Std.Iter.drop n it).toArray = it.toArray.extract n |
Ideal.quotientInfToPiQuotient.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {ι : Type u_1} (I : ι → Ideal R) [inst_1 : ∀ (i : ι), (I i).IsTwoSided],
Ideal.quotientInfToPiQuotient I = Ideal.Quotient.lift (⨅ i, I i) (Pi.ringHom fun i => Ideal.Quotient.mk (I i)) ⋯ |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.balLeft.match_1.splitter._sparseCasesOn_3 | Batteries.Data.RBMap.Lemmas | {α : Type u} →
{motive : Batteries.RBNode α → Sort u_1} →
(t : Batteries.RBNode α) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) → (v : α) → (r : Batteries.RBNode α) → motive (Batteries.RBNode.node c l v r)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusion | Lean.Elab.Do.Legacy | {P : Sort u} →
{t t' : Lean.Elab.Term.Do.ToCodeBlock.Context} → t = t' → Lean.Elab.Term.Do.ToCodeBlock.Context.noConfusionType P t t' |
minpoly.dvd_map_of_isScalarTower | Mathlib.FieldTheory.Minpoly.Field | ∀ (A : Type u_3) (K : Type u_4) {R : Type u_5} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Ring R]
[inst_3 : Algebra A K] [inst_4 : Algebra A R] [inst_5 : Algebra K R] [IsScalarTower A K R] (x : R),
minpoly K x ∣ Polynomial.map (algebraMap A K) (minpoly A x) |
Lean.Doc.Block.brecOn_2.eq | Lean.DocString.Types | ∀ {i : Type u} {b : Type v} {motive_1 : Lean.Doc.Block i b → Sort u_1}
{motive_2 : Array (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1}
{motive_3 : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1}
{motive_4 : Array (Lean.Doc.Block i b) → Sort u_1}
{motive_5 : List (Lean.Doc.ListItem (Lean.Doc.Block i b)) → Sort u_1}
{motive_6 : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Sort u_1}
{motive_7 : List (Lean.Doc.Block i b) → Sort u_1} {motive_8 : Lean.Doc.ListItem (Lean.Doc.Block i b) → Sort u_1}
{motive_9 : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b) → Sort u_1}
(t : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)))
(F_1 : (t : Lean.Doc.Block i b) → t.below → motive_1 t)
(F_2 : (t : Array (Lean.Doc.ListItem (Lean.Doc.Block i b))) → Lean.Doc.Block.below_1 t → motive_2 t)
(F_3 :
(t : Array (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) → Lean.Doc.Block.below_2 t → motive_3 t)
(F_4 : (t : Array (Lean.Doc.Block i b)) → Lean.Doc.Block.below_3 t → motive_4 t)
(F_5 : (t : List (Lean.Doc.ListItem (Lean.Doc.Block i b))) → Lean.Doc.Block.below_4 t → motive_5 t)
(F_6 :
(t : List (Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b))) → Lean.Doc.Block.below_5 t → motive_6 t)
(F_7 : (t : List (Lean.Doc.Block i b)) → Lean.Doc.Block.below_6 t → motive_7 t)
(F_8 : (t : Lean.Doc.ListItem (Lean.Doc.Block i b)) → Lean.Doc.Block.below_7 t → motive_8 t)
(F_9 : (t : Lean.Doc.DescItem (Lean.Doc.Inline i) (Lean.Doc.Block i b)) → Lean.Doc.Block.below_8 t → motive_9 t),
Lean.Doc.Block.brecOn_2 t F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9 =
F_3 t (Lean.Doc.Block.brecOn_2.go t F_1 F_2 F_3 F_4 F_5 F_6 F_7 F_8 F_9).2 |
Set.fintypeImage2._proof_1 | Mathlib.Data.Finite.Prod | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} (f : α → β → γ) (s : Set α) (t : Set β),
Fintype ↑(Set.image2 f s t) = Fintype ↑((fun x => f x.1 x.2) '' s ×ˢ t) |
Algebra.FiniteType.out | Mathlib.RingTheory.FiniteType | ∀ {R : Type uR} {A : Type uA} {inst : CommSemiring R} {inst_1 : Semiring A} {inst_2 : Algebra R A}
[self : Algebra.FiniteType R A], ⊤.FG |
GradedMonoid.GMul.casesOn | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} →
{A : ι → Type u_2} →
[inst : Add ι] →
{motive : GradedMonoid.GMul A → Sort u} →
(t : GradedMonoid.GMul A) → ((mul : {i j : ι} → A i → A j → A (i + j)) → motive { mul := mul }) → motive t |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape._sizeOf_1 | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
{inst_1 : LinearOrder J} →
{inst_2 : SuccOrder J} →
{inst_3 : OrderBot J} →
{inst_4 : WellFoundedLT J} →
{X Y : C} →
{f : X ⟶ Y} →
[SizeOf C] →
[⦃X Y : C⦄ → (x : X ⟶ Y) → SizeOf (W x)] → [SizeOf J] → W.TransfiniteCompositionOfShape J f → ℕ |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app_assoc | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1)
{Z : C} (h : (CategoryTheory.unopUnop C).obj ((CategoryTheory.shiftFunctor Cᵒᵖᵒᵖ n).obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso C n).inv.app X) h =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.Pretriangulated.shiftFunctorOpIso C m n ⋯).hom.app (Opposite.unop X)).unop
((CategoryTheory.Pretriangulated.shiftFunctorOpIso Cᵒᵖ n m hnm).inv.app X).unop.unop)
h |
MeasureTheory.withDensityᵥ_toReal | Mathlib.MeasureTheory.VectorMeasure.WithDensity | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
AEMeasurable f μ →
∀ (hf : ∫⁻ (x : α), f x ∂μ ≠ ⊤), (μ.withDensityᵥ fun x => (f x).toReal) = (μ.withDensity f).toSignedMeasure |
Lean.ErrorExplanation.mk.injEq | Lean.ErrorExplanation | ∀ (doc : String) (metadata : Lean.ErrorExplanation.Metadata) (declLoc? : Option Lean.DeclarationLocation)
(doc_1 : String) (metadata_1 : Lean.ErrorExplanation.Metadata) (declLoc?_1 : Option Lean.DeclarationLocation),
({ doc := doc, metadata := metadata, declLoc? := declLoc? } =
{ doc := doc_1, metadata := metadata_1, declLoc? := declLoc?_1 }) =
(doc = doc_1 ∧ metadata = metadata_1 ∧ declLoc? = declLoc?_1) |
Ideal.fiberIsoOfBijectiveResidueField | Mathlib.RingTheory.Etale.QuasiFinite | {R : Type u_1} →
{R' : Type u_2} →
{S : Type u_3} →
[inst : CommRing R] →
[inst_1 : CommRing R'] →
[inst_2 : CommRing S] →
[inst_3 : Algebra R R'] →
[inst_4 : Algebra R S] →
{p : Ideal R} →
{q : Ideal R'} →
[inst_5 : p.IsPrime] →
[inst_6 : q.IsPrime] →
[inst_7 : q.LiesOver p] →
Function.Bijective ⇑(Ideal.ResidueField.mapₐ p q (Algebra.ofId R R') ⋯) →
↑(q.primesOver (TensorProduct R R' S)) ≃o ↑(p.primesOver S) |
EReal.add_iInf_le_iInf_add | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {α : Type u_2} {u v : α → EReal}, (⨅ x, u x) + ⨅ x, v x ≤ ⨅ x, (u + v) x |
Real.fromBinary_surjective | Mathlib.Topology.MetricSpace.HausdorffAlexandroff | Function.Surjective Real.fromBinary |
ULift.distrib | Mathlib.Algebra.Ring.ULift | {R : Type u} → [Distrib R] → Distrib (ULift.{u_1, u} R) |
Std.DHashMap.Raw.get?_union_of_not_mem_right | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : α → Type v} {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ ∪ m₂).get? k = m₁.get? k |
Lean.initFn._@.Lean.DocString.Links.3730308748._hygCtx._hyg.2 | Lean.DocString.Links | IO String |
CategoryTheory.Monad.algebraEquivOfIsoMonads_unitIso | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T₁ T₂ : CategoryTheory.Monad C} (h : T₁ ≅ T₂),
(CategoryTheory.Monad.algebraEquivOfIsoMonads h).unitIso =
CategoryTheory.Monad.algebraFunctorOfMonadHomId.symm ≪≫
CategoryTheory.Monad.algebraFunctorOfMonadHomEq ⋯ ≪≫ CategoryTheory.Monad.algebraFunctorOfMonadHomComp h.hom h.inv |
_private.Mathlib.Analysis.Normed.Operator.Compact.0.IsCompactOperator.add.match_1_1 | Mathlib.Analysis.Normed.Operator.Compact | ∀ {M₁ : Type u_1} {M₂ : Type u_2} {f g : M₁ → M₂} (A B : Set M₂) (x : M₁) (motive : x ∈ f ⁻¹' A ∩ g ⁻¹' B → Prop)
(x_1 : x ∈ f ⁻¹' A ∩ g ⁻¹' B), (∀ (hxA : x ∈ f ⁻¹' A) (hxB : x ∈ g ⁻¹' B), motive ⋯) → motive x_1 |
Set.Icc_union_Icc' | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α},
c ≤ b → a ≤ d → Set.Icc a b ∪ Set.Icc c d = Set.Icc (min a c) (max b d) |
MonadWriter.mk.noConfusion | Mathlib.Control.Monad.Writer | {ω : outParam (Type u)} →
{M : Type u → Type v} →
{P : Sort u_1} →
{tell : ω → M PUnit.{u + 1}} →
{listen : {α : Type u} → M α → M (α × ω)} →
{pass : {α : Type u} → M (α × (ω → ω)) → M α} →
{tell' : ω → M PUnit.{u + 1}} →
{listen' : {α : Type u} → M α → M (α × ω)} →
{pass' : {α : Type u} → M (α × (ω → ω)) → M α} →
{ tell := tell, listen := listen, pass := pass } =
{ tell := tell', listen := listen', pass := pass' } →
(tell ≍ tell' → listen ≍ listen' → pass ≍ pass' → P) → P |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.