name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.CanonicallyOverClass.casesOn | Mathlib.CategoryTheory.Comma.Over.OverClass | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X S : C} →
{motive : CategoryTheory.CanonicallyOverClass X S → Sort u_1} →
(t : CategoryTheory.CanonicallyOverClass X S) →
([toOverClass : CategoryTheory.OverClass X S] → motive { toOverClass := toOverClass }) → motive t |
Filter.diff_mem_inf_principal_compl | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f : Filter α} {s : Set α}, s ∈ f → ∀ (t : Set α), s \ t ∈ f ⊓ Filter.principal tᶜ |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_112 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax |
ENNReal.log_le_log_iff._simp_1 | Mathlib.Analysis.SpecialFunctions.Log.ENNRealLog | ∀ {x y : ENNReal}, (x.log ≤ y.log) = (x ≤ y) |
Mathlib.Tactic.MkIff.compactRelation._unsafe_rec | Mathlib.Tactic.MkIffOfInductiveProp | List Lean.Expr →
List (Lean.Expr × Lean.Expr) → List (Option Lean.Expr) × List (Lean.Expr × Lean.Expr) × (Lean.Expr → Lean.Expr) |
CategoryTheory.instFinalDiscreteOfIsConnected | Mathlib.CategoryTheory.Limits.Final.Connected | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {T : Type w} [Unique T]
(F : CategoryTheory.Functor C (CategoryTheory.Discrete T)) [CategoryTheory.IsConnected C], F.Final |
lt_or_antisymmRel_or_gt_or_incompRel | Mathlib.Order.Comparable | ∀ {α : Type u_1} [inst : Preorder α] (a b : α),
a < b ∨ AntisymmRel (fun x1 x2 => x1 ≤ x2) a b ∨ b < a ∨ IncompRel (fun x1 x2 => x1 ≤ x2) a b |
Float.toRatParts' | Batteries.Lean.Float | Float → Option (ℤ × ℤ) |
OrderAddMonoidIso.mk.injEq | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_6} {β : Type u_7} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Add α] [inst_3 : Add β]
(toAddEquiv : α ≃+ β) (map_le_map_iff' : ∀ {a b : α}, toAddEquiv.toFun a ≤ toAddEquiv.toFun b ↔ a ≤ b)
(toAddEquiv_1 : α ≃+ β) (map_le_map_iff'_1 : ∀ {a b : α}, toAddEquiv_1.toFun a ≤ toAddEquiv_1.toFun b ↔ a ≤ b),
({ toAddEquiv := toAddEquiv, map_le_map_iff' := map_le_map_iff' } =
{ toAddEquiv := toAddEquiv_1, map_le_map_iff' := map_le_map_iff'_1 }) =
(toAddEquiv = toAddEquiv_1) |
Bundle.Trivial.trivialization.isLinear | Mathlib.Topology.VectorBundle.Constructions | ∀ (𝕜 : Type u_1) (B : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace B],
Bundle.Trivialization.IsLinear 𝕜 (Bundle.Trivial.trivialization B F) |
Lean.Elab.Do.DoElemCont.recOn | Lean.Elab.Do.Basic | {motive : Lean.Elab.Do.DoElemCont → Sort u} →
(t : Lean.Elab.Do.DoElemCont) →
((resultName : Lean.Name) →
(resultType : Lean.Expr) →
(k : Lean.Elab.Do.DoElabM Lean.Expr) →
(kind : Lean.Elab.Do.DoElemContKind) →
motive { resultName := resultName, resultType := resultType, k := k, kind := kind }) →
motive t |
Monoid.CoprodI.Word.mem_rcons_iff | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] {i j : ι}
(p : Monoid.CoprodI.Word.Pair M i) (m : M j),
⟨j, m⟩ ∈ (Monoid.CoprodI.Word.rcons p).toList ↔ ⟨j, m⟩ ∈ p.tail.toList ∨ m ≠ 1 ∧ ∃ (h : i = j), m = h ▸ p.head |
Finset.mem_of_max | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {s : Finset α} {a : α}, s.max = ↑a → a ∈ s |
Function.Exact.linearEquivOfSurjective_apply | Mathlib.Algebra.Exact | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {P : Type u_6} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (h : Function.Exact ⇑f ⇑g) (hg : Function.Surjective ⇑g) (a : N ⧸ f.range),
(h.linearEquivOfSurjective hg) a = (f.range.liftQ g ⋯) a |
UInt64.add_sub_cancel | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a + b - b = a |
Filter.lift'_mono | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {h₁ h₂ : Set α → Set β},
f₁ ≤ f₂ → h₁ ≤ h₂ → f₁.lift' h₁ ≤ f₂.lift' h₂ |
Std.TreeSet.all | Std.Data.TreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → Std.TreeSet α cmp → (α → Bool) → Bool |
CategoryTheory.Functor.congruence_homRel | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_2, u_2} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} D] (F : CategoryTheory.Functor C D), CategoryTheory.Congruence F.homRel |
Algebra.PreSubmersivePresentation.ofHasCoeffs_algebra_algebraMap_apply | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] (P : Algebra.PreSubmersivePresentation R S ι σ) (R₀ : Type u_5) [inst_3 : CommRing R₀]
[inst_4 : Algebra R₀ R] [inst_5 : Algebra R₀ S] [inst_6 : IsScalarTower R₀ R S] [inst_7 : P.HasCoeffs R₀]
(a : MvPolynomial ι R₀),
Algebra.algebraMap a = (Ideal.Quotient.mk (Ideal.span (Set.range (Algebra.Presentation.relationOfHasCoeffs R₀)))) a |
CategoryTheory.Limits.pushoutCoconeOfRightIso_inl | 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 g],
(CategoryTheory.Limits.pushoutCoconeOfRightIso f g).inl = CategoryTheory.CategoryStruct.id Y |
Subsemigroup.comap_sup_map_of_injective | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] {f : M →ₙ* N},
Function.Injective ⇑f →
∀ (S T : Subsemigroup M), Subsemigroup.comap f (Subsemigroup.map f S ⊔ Subsemigroup.map f T) = S ⊔ T |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_inter_of_contains_eq_false_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Lean.Parser.OrElseOnAntiquotBehavior.noConfusionType | Lean.Parser.Basic | Sort v✝ → Lean.Parser.OrElseOnAntiquotBehavior → Lean.Parser.OrElseOnAntiquotBehavior → Sort v✝ |
Vector.extract_push._proof_2 | Init.Data.Vector.Extract | ∀ {n start stop : ℕ}, stop ≤ n → min stop n - start = min stop (n + 1) - start |
CategoryTheory.Endofunctor.Algebra.Hom.h | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{A₀ A₁ : CategoryTheory.Endofunctor.Algebra F} (self : A₀.Hom A₁),
CategoryTheory.CategoryStruct.comp (F.map self.f) A₁.str = CategoryTheory.CategoryStruct.comp A₀.str self.f |
WeierstrassCurve.Jacobian.dblZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Jacobian R → (Fin 3 → R) → R |
SimpleGraph.Copy.toSubgraph_surjOn | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Type u_4} {β : Type u_5} {A : SimpleGraph α} {B : SimpleGraph β},
Set.SurjOn SimpleGraph.Copy.toSubgraph Set.univ {B' | Nonempty (A ≃g B'.coe)} |
CategoryTheory.Functor.IsDenseSubsite.faithful_sheafPushforwardContinuous | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (J : CategoryTheory.GrothendieckTopology C)
(K : CategoryTheory.GrothendieckTopology D) (G : CategoryTheory.Functor C D) {A : Type u_4}
[inst_2 : CategoryTheory.Category.{v_4, u_4} A] [inst_3 : CategoryTheory.Functor.IsDenseSubsite J K G],
(G.sheafPushforwardContinuous A J K).Faithful |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.getQuotKind.match_3 | Lean.Elab.Quotation | (motive : Lean.SyntaxNodeKind → Sort u_1) →
(x : Lean.SyntaxNodeKind) →
(Unit → motive `Lean.Parser.Command.quot) →
(Unit → motive `Lean.Parser.Term.quot) →
(Unit → motive `Lean.Parser.Tactic.quot) →
(Unit → motive `Lean.Parser.Tactic.quotSeq) →
((kind : Lean.Name) → motive (kind.str "quot")) →
(Unit → motive `Lean.Parser.Term.dynamicQuot) → ((k : Lean.SyntaxNodeKind) → motive k) → motive x |
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.1564534894._hygCtx._hyg.1.noConfusion | Lean.Server.FileWorker.WidgetRequests | {P : Sort u} →
{t t' : Lean.Widget.RpcEncodablePacket✝} →
t = t' →
Lean.Widget.RpcEncodablePacket.«_@».Lean.Server.FileWorker.WidgetRequests.1564534894._hygCtx._hyg.1.noConfusionType
P t t' |
_private.Mathlib.Order.Iterate.0.Function.Commute.iterate_pos_le_iff_map_le'._simp_1_1 | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a < b) = (b ≤ a) |
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator.mk._flat_ctor | Lean.PrettyPrinter.Delaborator.SubExpr | ℕ → ℕ → Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator |
CategoryTheory.Mod_.Hom.mk.injEq | Mathlib.CategoryTheory.Monoidal.Mod_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D]
{A : C} [inst_4 : CategoryTheory.MonObj A] {M N : CategoryTheory.Mod_ D A} (hom : M.X ⟶ N.X)
[isMod_Hom : CategoryTheory.IsMod_Hom A hom] (hom_1 : M.X ⟶ N.X) (isMod_Hom_1 : CategoryTheory.IsMod_Hom A hom_1),
({ hom := hom, isMod_Hom := isMod_Hom } = { hom := hom_1, isMod_Hom := isMod_Hom_1 }) = (hom = hom_1) |
HomotopicalAlgebra.Cylinder.symm_i | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.Cylinder A)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C],
P.symm.i = CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coprod.braiding A A).hom P.i |
_private.Init.Data.Array.Basic.0.Array.allDiffAux | Init.Data.Array.Basic | {α : Type u} → [BEq α] → Array α → ℕ → Bool |
CategoryTheory.Bicategory.Adj.id_adj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (a : CategoryTheory.Bicategory.Adj B),
(CategoryTheory.CategoryStruct.id a).adj = CategoryTheory.Bicategory.Adjunction.id a.obj |
Finset.vadd.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : VAdd α β],
Finset.vadd = { vadd := Finset.image₂ fun x1 x2 => x1 +ᵥ x2 } |
RingEquiv.ofRingHom_apply | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (g : S →+* R)
(h₁ : f.comp g = RingHom.id S) (h₂ : g.comp f = RingHom.id R) (a : R), (RingEquiv.ofRingHom f g h₁ h₂) a = f a |
Fin.map_succEmb_Ico | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (i j : Fin n), Finset.map (Fin.succEmb n) (Finset.Ico i j) = Finset.Ico i.succ j.succ |
CategoryTheory.Functor.mapGrp_obj_grp_one | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (A : CategoryTheory.Grp C),
CategoryTheory.MonObj.one =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε F) (F.map CategoryTheory.MonObj.one) |
_private.Init.Data.BitVec.Lemmas.0.BitVec.not_sshiftRight._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {n : ℕ}, ∀ i < w, ¬0 < w → False |
CategoryTheory.Monad.PreservesColimitOfIsSplitPair.casesOn | Mathlib.CategoryTheory.Monad.Monadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{G : CategoryTheory.Functor D C} →
{motive : CategoryTheory.Monad.PreservesColimitOfIsSplitPair G → Sort u} →
(t : CategoryTheory.Monad.PreservesColimitOfIsSplitPair G) →
((out :
∀ {A B : D} (f g : A ⟶ B) [G.IsSplitPair f g],
CategoryTheory.Limits.PreservesColimit (CategoryTheory.Limits.parallelPair f g) G) →
motive ⋯) →
motive t |
Real.rpow_le_one | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x z : ℝ}, 0 ≤ x → x ≤ 1 → 0 ≤ z → x ^ z ≤ 1 |
AddSubmonoid.topologicalClosure._proof_1 | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] [SeparatelyContinuousAdd M] (s : AddSubmonoid M)
{a b : M}, a ∈ closure ↑s → b ∈ closure ↑s → a + b ∈ closure ↑s |
QuaternionAlgebra.instMulAction._proof_1 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R}, Function.Injective ⇑(QuaternionAlgebra.equivProd c₁ c₂ c₃) |
MeasureTheory.Measure.wrapped._@.Mathlib.MeasureTheory.Measure.Map.2222372135._hygCtx._hyg.8 | Mathlib.MeasureTheory.Measure.Map | Subtype (Eq @MeasureTheory.Measure.definition✝) |
Representation.IntertwiningMap.instSub._proof_1 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_3} {G : Type u_4} [inst : Semiring A] [inst_1 : Monoid G] {V : Type u_1} {W : Type u_2}
[inst_2 : AddCommMonoid V] [inst_3 : AddCommGroup W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W) (f g : ρ.IntertwiningMap σ) (g_1 : G),
(f.toLinearMap - g.toLinearMap) ∘ₗ ρ g_1 = σ g_1 ∘ₗ (f.toLinearMap - g.toLinearMap) |
AlgebraicGeometry.Scheme.Modules.pushforward_map_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} {M N : X.Modules} (f : X ⟶ Y) (φ : M ⟶ N) (U : Y.Opens),
AlgebraicGeometry.Scheme.Modules.Hom.app ((AlgebraicGeometry.Scheme.Modules.pushforward f).map φ) U =
AlgebraicGeometry.Scheme.Modules.Hom.app φ ((TopologicalSpace.Opens.map f.base).obj U) |
Array.toList_ofFnM | Init.Data.Array.OfFn | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Type u_1} [inst : Monad m] [LawfulMonad m] {f : Fin n → m α},
Array.toList <$> Array.ofFnM f = List.ofFnM f |
MeasureTheory.measureReal_eq_measureReal_larger_of_between_null_diff | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ s₃ : Set α},
s₁ ⊆ s₂ →
s₂ ⊆ s₃ →
μ.real (s₃ \ s₁) = 0 →
autoParam (μ (s₃ \ s₁) ≠ ⊤) MeasureTheory.measureReal_eq_measureReal_larger_of_between_null_diff._auto_1 →
μ.real s₂ = μ.real s₃ |
Finset.odd_sum_iff_odd_card_odd | Mathlib.Algebra.BigOperators.Ring.Nat | ∀ {ι : Type u_1} {s : Finset ι} (f : ι → ℕ), Odd (∑ i ∈ s, f i) ↔ Odd {x ∈ s | Odd (f x)}.card |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeUsingDefaultPrio.match_3 | Lean.Elab.SyntheticMVars | (motive : List (Lean.Name × ℕ) → Sort u_1) →
(__do_lift : List (Lean.Name × ℕ)) →
(Unit → motive []) → ((defaultInstances : List (Lean.Name × ℕ)) → motive defaultInstances) → motive __do_lift |
Lean.Parser.Command.notationItem | Lean.Parser.Syntax | Lean.Parser.Parser |
initFn._@.Mathlib.Init.1721590124._hygCtx._hyg.3 | Mathlib.Init | IO (Lean.Option Bool) |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.getRecommendedSpellingString.indentLine | Lean.Parser.Term.Doc | String → String |
Std.DTreeMap.Internal.Impl.minEntry?_eq_minEntry? | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] {l : Std.DTreeMap.Internal.Impl α β},
l.Ordered → l.minEntry? = Std.Internal.List.minEntry? l.toListModel |
String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.instIteratorIdSearchStepOfBackwardPattern._proof_9 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) [inst : String.Slice.Pattern.BackwardPattern pat]
(it : Std.IterM Id (String.Slice.Pattern.SearchStep s)) (h : ¬it.internalState.currPos = s.startPos)
(pos : (s.sliceTo it.internalState.currPos).Pos),
String.Slice.Pattern.BackwardPattern.dropSuffixOfNonempty? pat (s.sliceTo it.internalState.currPos) ⋯ = some pos →
match
Std.IterStep.yield { internalState := { currPos := String.Slice.Pos.ofSliceTo pos } }
(String.Slice.Pattern.SearchStep.matched (String.Slice.Pos.ofSliceTo pos) it.internalState.currPos) with
| Std.IterStep.yield it' (String.Slice.Pattern.SearchStep.rejected p₁ p₂) =>
∃ (h : it.internalState.currPos ≠ s.startPos),
String.Slice.Pattern.BackwardPattern.dropSuffixOfNonempty? pat (s.sliceTo it.internalState.currPos) ⋯ = none ∧
p₁ = it.internalState.currPos.prev h ∧
p₂ = it.internalState.currPos ∧ it'.internalState.currPos = it.internalState.currPos.prev h
| Std.IterStep.yield it' (String.Slice.Pattern.SearchStep.matched p₁ p₂) =>
∃ (h : it.internalState.currPos ≠ s.startPos),
∃ pos,
String.Slice.Pattern.BackwardPattern.dropSuffixOfNonempty? pat (s.sliceTo it.internalState.currPos) ⋯ =
some pos ∧
p₁ = String.Slice.Pos.ofSliceTo pos ∧
p₂ = it.internalState.currPos ∧ it'.internalState.currPos = String.Slice.Pos.ofSliceTo pos
| Std.IterStep.done => it.internalState.currPos = s.startPos
| Std.IterStep.skip it => False |
Matrix.toRows₁_apply | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} (A : Matrix (m₁ ⊕ m₂) n R) (i : m₁) (j : n),
A.toRows₁ i j = A (Sum.inl i) j |
Ordering.compares_lt | Mathlib.Data.Ordering.Basic | ∀ {α : Type u_1} [inst : LT α] (a b : α), Ordering.lt.Compares a b = (a < b) |
ClosedSubmodule.toSubmodule_bot | Mathlib.Topology.Algebra.Module.ClosedSubmodule | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : Module R M] [inst_4 : T1Space M], ↑⊥ = ⊥ |
Diffeology.dSmooth_iff | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : DiffeologicalSpace X] [inst_1 : DiffeologicalSpace Y] {f : X → Y},
Diffeology.DSmooth f ↔ ∀ (n : ℕ) (p : EuclideanSpace ℝ (Fin n) → X), Diffeology.IsPlot p → Diffeology.IsPlot (f ∘ p) |
_private.Mathlib.Algebra.GCDMonoid.Basic.0.lcm_mul_left.match_1_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a b c : α)
(motive : a ∣ lcm (a * b) (a * c) → Prop) (this : a ∣ lcm (a * b) (a * c)),
(∀ (w : α) (eq : lcm (a * b) (a * c) = a * w), motive ⋯) → motive this |
_private.Mathlib.Algebra.Category.ModuleCat.Sheaf.Free.0.SheafOfModules.map_ιFree_mapFree_hom._simp_1_1 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Free | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] {C' : Type u₂}
[inst_4 : CategoryTheory.Category.{v₂, u₂} C'] {J' : CategoryTheory.GrothendieckTopology C'}
{S : CategoryTheory.Sheaf J' RingCat} [inst_5 : CategoryTheory.HasSheafify J' AddCommGrpCat]
[inst_6 : J'.WEqualsLocallyBijective AddCommGrpCat]
[inst_7 : J'.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)]
(F : CategoryTheory.Functor (SheafOfModules R) (SheafOfModules S))
(η : F.obj (SheafOfModules.unit R) ≅ SheafOfModules.unit S) (I : Type u) (i : I)
[inst_8 : CategoryTheory.Limits.PreservesColimitsOfShape (CategoryTheory.Discrete I) F],
CategoryTheory.CategoryStruct.comp η.inv (F.map (SheafOfModules.ιFree i)) =
CategoryTheory.CategoryStruct.comp (SheafOfModules.ιFree i) (SheafOfModules.mapFree F η I).inv |
MeasureTheory.setLIntegral_le_iSup_mul | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} (f : α → ENNReal) {s : Set α},
MeasurableSet s → ∫⁻ (x : α) in s, f x ∂μ ≤ (⨆ x ∈ s, f x) * μ s |
CategoryTheory.Mod_.Hom.ext | Mathlib.CategoryTheory.Monoidal.Mod_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {D : Type u₂}
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D}
{A : C} {inst_4 : CategoryTheory.MonObj A} {M N : CategoryTheory.Mod_ D A} {x y : M.Hom N}, x.hom = y.hom → x = y |
Lean.hasPPNoDotAttribute | Lean.PrettyPrinter.Delaborator.Attributes | Lean.Environment → Lean.Name → Bool |
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.folder.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.Clause | ∀ {n : ℕ} (l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
Std.Tactic.BVDecide.LRAT.Internal.DefaultClause.ofArray.folder none l = none |
CategoryTheory.Abelian.SpectralObject.πE_d_ιE | Mathlib.Algebra.Homology.SpectralObject.Differentials | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (n₀ n₁ n₂ n₃ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.πE_d_ιE._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.πE_d_ιE._auto_3)
(hn₃ : autoParam (n₂ + 1 = n₃) CategoryTheory.Abelian.SpectralObject.πE_d_ιE._auto_5),
CategoryTheory.CategoryStruct.comp (X.πE f₃ f₄ f₅ n₀ n₁ n₂ hn₁ hn₂)
(CategoryTheory.CategoryStruct.comp (X.d f₁ f₂ f₃ f₄ f₅ n₀ n₁ n₂ n₃ hn₁ hn₂ hn₃)
(X.ιE f₁ f₂ f₃ n₁ n₂ n₃ hn₂ hn₃)) =
X.Ψ f₂ f₃ f₄ n₁ n₂ hn₂ |
Set.Ioo._proof_3 | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] (a b : α), {x | b < x ∧ x < a} = {x | x < a ∧ b < x} |
CategoryTheory.LocalizerMorphism.localizedFunctor_isEquivalence | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {D₁ : Type u₄} {D₂ : Type u₅} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₄, u₄} D₁]
[inst_3 : CategoryTheory.Category.{v₅, u₅} D₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂)
(L₁ : CategoryTheory.Functor C₁ D₁) [inst_4 : L₁.IsLocalization W₁] (L₂ : CategoryTheory.Functor C₂ D₂)
[inst_5 : L₂.IsLocalization W₂] [Φ.IsLocalizedEquivalence], (Φ.localizedFunctor L₁ L₂).IsEquivalence |
Lean.Parser.Term.paren.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer |
NumberField.mixedEmbedding.convexBodyLTFactor.congr_simp | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.convexBodyLTFactor K = NumberField.mixedEmbedding.convexBodyLTFactor K |
HomologicalComplex.comp_f_assoc | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ C₃ : HomologicalComplex V c}
(f : C₁ ⟶ C₂) (g : C₂ ⟶ C₃) (i : ι) {Z : V} (h : C₃.X i ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.CategoryStruct.comp f g).f i) h =
CategoryTheory.CategoryStruct.comp (f.f i) (CategoryTheory.CategoryStruct.comp (g.f i) h) |
Nonneg.commMonoidWithZero | Mathlib.Algebra.Order.Nonneg.Basic | {α : Type u_1} →
[inst : CommSemiring α] →
[inst_1 : PartialOrder α] →
[ZeroLEOneClass α] → [AddLeftMono α] → [PosMulMono α] → CommMonoidWithZero { x // 0 ≤ x } |
Std.Iterators.HetT.operation | Std.Data.Iterators.Lemmas.Equivalence.HetT | {m : Type w → Type w'} →
{α : Type v} → (self : Std.Iterators.HetT m α) → m (Std.Internal.USquash (Subtype self.Property)) |
FreeCommRing.map | Mathlib.RingTheory.FreeCommRing | {α : Type u} → {β : Type v} → (α → β) → FreeCommRing α →+* FreeCommRing β |
Lean.instInhabitedImport.default | Lean.Setup | Lean.Import |
_private.Mathlib.SetTheory.Ordinal.Family.0.Ordinal.iSup_Iio_eq_bsup._simp_1_4 | Mathlib.SetTheory.Ordinal.Family | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a |
Convex.toCone._simp_2 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {t : Set β} {a : α} {x : β}, (x ∈ a • t) = ∃ y ∈ t, a • y = x |
Lean.Level.PP.Result.max | Lean.Level | Lean.Level.PP.Result → Lean.Level.PP.Result → Lean.Level.PP.Result |
String.instLinearOrder._proof_12 | Mathlib.Data.String.Basic | ∀ (a b : String), compare a b = compareOfLessAndEq a b |
Finset.powerset_empty | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1}, ∅.powerset = {∅} |
SimpleGraph.Iso.coe_comp | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} {X : Type u_3} {G : SimpleGraph V} {G' : SimpleGraph W} {G'' : SimpleGraph X}
(f' : G' ≃g G'') (f : G ≃g G'), ⇑(f'.comp f) = ⇑f' ∘ ⇑f |
Std.TreeMap.Equiv.of_forall_getKey_eq_of_forall_constGet?_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
(∀ (k : α) (hk : k ∈ t₁) (hk' : k ∈ t₂), t₁.getKey k hk = t₂.getKey k hk') →
(∀ (k : α), t₁[k]? = t₂[k]?) → t₁.Equiv t₂ |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeSomeUsingDefaultPrio.visit._sparseCasesOn_1 | Lean.Elab.SyntheticMVars | {motive : Lean.Elab.Term.SyntheticMVarKind → Sort u} →
(t : Lean.Elab.Term.SyntheticMVarKind) →
((extraErrorMsg? : Option Lean.MessageData) → motive (Lean.Elab.Term.SyntheticMVarKind.typeClass extraErrorMsg?)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
GeneralSchauderBasis.basis | Mathlib.Analysis.Normed.Module.Bases | {β : Type u_3} →
{𝕜 : Type u_4} →
{X : Type u_5} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup X] →
[inst_2 : NormedSpace 𝕜 X] → {L : SummationFilter β} → GeneralSchauderBasis β 𝕜 X L → β → X |
_private.Mathlib.SetTheory.Ordinal.Basic.0.Cardinal.isNormal_ord._simp_1_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a |
Set.union_empty_iff | Mathlib.Data.Set.Basic | ∀ {α : Type u} {s t : Set α}, s ∪ t = ∅ ↔ s = ∅ ∧ t = ∅ |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.cmp.match_1.eq_4 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → PosNum → Sort u_1) (a b : PosNum) (h_1 : Unit → motive PosNum.one PosNum.one)
(h_2 : (x : PosNum) → motive x PosNum.one) (h_3 : (x : PosNum) → motive PosNum.one x)
(h_4 : (a b : PosNum) → motive a.bit0 b.bit0) (h_5 : (a b : PosNum) → motive a.bit0 b.bit1)
(h_6 : (a b : PosNum) → motive a.bit1 b.bit0) (h_7 : (a b : PosNum) → motive a.bit1 b.bit1),
(match a.bit0, b.bit0 with
| PosNum.one, PosNum.one => h_1 ()
| x, PosNum.one => h_2 x
| PosNum.one, x => h_3 x
| a.bit0, b.bit0 => h_4 a b
| a.bit0, b.bit1 => h_5 a b
| a.bit1, b.bit0 => h_6 a b
| a.bit1, b.bit1 => h_7 a b) =
h_4 a b |
instAddGroupUniformFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup β], instAddGroupUniformFun = Pi.addGroup |
ValuativeRel._aux_Mathlib_Topology_Algebra_Valued_ValuativeRel___unexpand_IsLocalRing_maximalIdeal_1 | Mathlib.Topology.Algebra.Valued.ValuativeRel | Lean.PrettyPrinter.Unexpander |
BotHom.instLattice._proof_3 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Bot α] [inst_1 : Lattice β] [inst_2 : OrderBot β] {x y : BotHom α β},
⇑y < ⇑x ↔ ⇑y < ⇑x |
isBigO_norm_restrict_cocompact | Mathlib.Analysis.Fourier.PoissonSummation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] (f : C(ℝ, E)) {b : ℝ},
0 < b →
(⇑f =O[Filter.cocompact ℝ] fun x => |x| ^ (-b)) →
∀ (K : TopologicalSpace.Compacts ℝ),
(fun x => ‖ContinuousMap.restrict (↑K) (f.comp (ContinuousMap.addRight x))‖) =O[Filter.cocompact ℝ] fun x =>
|x| ^ (-b) |
CategoryTheory.MonoidalCategory.MonoidalRightAction.actionHom_def'_assoc | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] {x₁ y₁ : D} {x₂ y₂ : C} (f : x₁ ⟶ y₁) (g : x₂ ⟶ y₂)
{Z : D} (h : CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionObj y₁ y₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHom f g) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomRight x₁ g)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionHomLeft f y₂)
h) |
Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData.ctorIdx | Lean.Elab.Tactic.Omega.Core | Lean.Elab.Tactic.Omega.Problem.FourierMotzkinData → ℕ |
AddMonCat.ctorIdx | Mathlib.Algebra.Category.MonCat.Basic | AddMonCat → ℕ |
_private.Mathlib.Analysis.Calculus.ContDiff.Defs.0.contDiffWithinAt_insert_self.match_1_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ (motive : WithTop ℕ∞ → Prop) (n : WithTop ℕ∞), (∀ (a : Unit), motive none) → (∀ (n : ℕ∞), motive (some n)) → motive n |
Lean.instInhabitedModuleSetup | Lean.Setup | Inhabited Lean.ModuleSetup |
Lean.Grind.Preorder.ne_of_gt | Init.Grind.Ordered.Order | ∀ {α : Type u} [inst : LE α] [inst_1 : LT α] [Std.LawfulOrderLT α] {a b : α}, a > b → a ≠ b |
Valued.hasBasis_nhds_zero | Mathlib.Topology.Algebra.Valued.ValuationTopology | ∀ (R : Type u) [inst : Ring R] (Γ₀ : Type v) [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [_i : Valued R Γ₀],
(nhds 0).HasBasis (fun x => True) fun γ => {x | Valued.v.restrict x < ↑γ} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.