name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousLinearEquiv.piRing._proof_5 | Mathlib.Analysis.Normed.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], SMulCommClass 𝕜 𝕜 E | null | false |
Homeomorph.piCongrRight | Mathlib.Topology.Homeomorph.Lemmas | {ι : Type u_5} →
{Y₁ : ι → Type u_6} →
{Y₂ : ι → Type u_7} →
[inst : (i : ι) → TopologicalSpace (Y₁ i)] →
[inst_1 : (i : ι) → TopologicalSpace (Y₂ i)] → ((i : ι) → Y₁ i ≃ₜ Y₂ i) → ((i : ι) → Y₁ i) ≃ₜ ((i : ι) → Y₂ i) | `Equiv.piCongrRight` as a homeomorphism: this is the natural homeomorphism
`Π i, Y₁ i ≃ₜ Π j, Y₂ i` obtained from homeomorphisms `Y₁ i ≃ₜ Y₂ i` for each `i`. | true |
_private.Lean.Compiler.LCNF.CompilerM.0.Lean.Compiler.LCNF.normExprImp.go | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.FVarSubst pu → Bool → Lean.Expr → Lean.Expr | null | true |
AddAction.mem_stabilizer_finset' | Mathlib.Algebra.Pointwise.Stabilizer | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] {a : G} [inst_2 : DecidableEq α]
{s : Finset α}, a ∈ AddAction.stabilizer G s ↔ ∀ ⦃b : α⦄, b ∈ s → a +ᵥ b ∈ s | null | true |
AddCommGrpCat.instMonoι | Mathlib.Algebra.Category.Grp.Images | ∀ {G H : AddCommGrpCat} (f : G ⟶ H), CategoryTheory.Mono (AddCommGrpCat.image.ι f) | null | true |
String.Pos.posGE_offset._proof_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : s.Pos}, p.offset ≤ s.rawEndPos | null | false |
CategoryTheory.Pretriangulated.rotateRotateRotateIso._proof_1 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] (T : CategoryTheory.Pretriangulated.Triangle C),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Pretriangulated.rotate C).comp
((CategoryTheory.Pret... | null | false |
_private.Mathlib.AlgebraicGeometry.Sites.QuasiCompact.0.AlgebraicGeometry.Scheme.mem_propQCPrecoverage_iff_exists_quasiCompactCover.match_1_1 | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {S : AlgebraicGeometry.Scheme}
{R : CategoryTheory.Presieve S} (motive : (∃ 𝒰, R = CategoryTheory.Presieve.ofArrows 𝒰.X 𝒰.f) → Prop)
(x : ∃ 𝒰, R = CategoryTheory.Presieve.ofArrows 𝒰.X 𝒰.f),
(∀ (𝒰 : (AlgebraicGeometry.Scheme.propQCPrecoverage ... | null | false |
Lean.Lsp.PlainTermGoal | Lean.Data.Lsp.Extra | Type | `$/lean/plainTermGoal` client<-server reply. | true |
Std.ExtTreeMap.le_maxKey_of_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
(hc : k ∈ t), (cmp k (t.maxKey ⋯)).isLE = true | null | true |
Polynomial.IsDistinguishedAt.algEquivQuotient._proof_5 | Mathlib.RingTheory.PowerSeries.WeierstrassPreparation | ∀ {A : Type u_1} [inst : CommRing A] {g : Polynomial A} {I : Ideal A} (H : g.IsDistinguishedAt I)
[inst_1 : IsAdicComplete I A] (f : Polynomial A ⧸ Ideal.span {g}),
(⇑(Ideal.Quotient.mk (Ideal.span {g})) ∘ ⇑⋯.mod')
((↑↑(Ideal.quotientMapₐ (Ideal.span {↑g}) (Polynomial.coeToPowerSeries.algHom A) ⋯).toRingHom).... | null | false |
Aesop.ClusterState.AddM.Context.rec | Aesop.Forward.State | {motive : Aesop.ClusterState.AddM.Context → Sort u} →
((premiseMVars : Array Lean.MVarId) →
(premiseLMVars : Array Lean.LMVarId) → motive { premiseMVars := premiseMVars, premiseLMVars := premiseLMVars }) →
(t : Aesop.ClusterState.AddM.Context) → motive t | null | false |
CategoryTheory.PositiveCategory.mk._flat_ctor | Mathlib.CategoryTheory.MarkovCategory.Positive | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
(braiding :
(X Y : C) →
CategoryTheory.MonoidalCategoryStruct.tensorObj X Y ≅ CategoryTheory.MonoidalCategoryStruct.tensorObj Y X) →
(braiding_naturality_right :
... | null | false |
ContinuousMap.compMonoidHom'.eq_1 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {γ : Type u_3}
[inst_2 : TopologicalSpace γ] [inst_3 : MulOneClass γ] [inst_4 : ContinuousMul γ] (g : C(α, β)),
g.compMonoidHom' = { toFun := fun f => f.comp g, map_one' := ⋯, map_mul' := ⋯ } | null | true |
isOpen_extChartAt_target | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
{I : ModelWithCorners 𝕜 E H} [inst_5 : ChartedSpace H M] [I.Boundaryless] (x : M), IsOpen (extCh... | If we're boundaryless, `extChartAt` has open target | true |
ESeminormedAddCommMonoid.noConfusionType | Mathlib.Analysis.Normed.Group.Defs | Sort u →
{E : Type u_4} →
[inst : TopologicalSpace E] →
ESeminormedAddCommMonoid E →
{E' : Type u_4} → [inst' : TopologicalSpace E'] → ESeminormedAddCommMonoid E' → Sort u | null | false |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.pollNextEvent._sparseCasesOn_2 | Std.Http.Server.Connection | {motive : Std.CancellationReason → Sort u} →
(t : Std.CancellationReason) →
motive Std.CancellationReason.deadline → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Util.CollectAxioms.0.Lean.ExportedAxiomsState.recOn | Lean.Util.CollectAxioms | {motive : Lean.ExportedAxiomsState✝ → Sort u} →
(t : Lean.ExportedAxiomsState✝) →
((importedModuleEntries : Array (Array (Lean.Name × Array Lean.Name))) →
motive { importedModuleEntries := importedModuleEntries }) →
motive t | null | false |
Lean.Meta.Occurrences.pos | Init.MetaTypes | List ℕ → Lean.Meta.Occurrences | A list of indices for which occurrences should be rewritten. | true |
linter.tacticAnalysis.omegaToLia | Mathlib.Tactic.TacticAnalysis.Declarations | Lean.Option Bool | Report places where `omega` can be replaced by `lia`. | true |
_private.Init.Data.List.Find.0.List.lt_findIdx_of_not._simp_1_1 | Init.Data.List.Find | ∀ {a b : ℕ}, (¬a < b) = (b ≤ a) | null | false |
ContMDiffOn.sub_const | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {H : Type u_2} [inst_1 : TopologicalSpace H]
{E : Type u_3} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : SubNegMonoid G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H... | null | true |
AlgebraicGeometry.HasAffineProperty.diagonal_of_openCover | Mathlib.AlgebraicGeometry.Morphisms.Constructors | ∀ (P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme) {Q : AlgebraicGeometry.AffineTargetMorphismProperty}
[AlgebraicGeometry.HasAffineProperty P Q] {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
[inst : ∀ (i : 𝒰.I₀), AlgebraicGeometry.IsAffine (𝒰.X i)]
(𝒰' : (i : 𝒰.I₀) → (Category... | null | true |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.MinImports.minImportsLinter._sparseCasesOn_1 | Mathlib.Tactic.Linter.MinImports | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Matrix.IsFiniteCartan.rec | Mathlib.LinearAlgebra.Matrix.Cartan.Basic | {ι : Type u_1} →
[inst : Fintype ι] →
[inst_1 : DecidableEq ι] →
{M : Matrix ι ι ℤ} →
{motive : M.IsFiniteCartan → Sort u} →
((diag : ∀ (i : ι), M i i = 2) →
(offDiag_nonpos : ∀ (i j : ι), i ≠ j → M i j ≤ 0) →
(zero_comm : ∀ (i j : ι), M i j = 0 ↔ M j i = 0) →... | null | false |
Lean.Meta.Simp.SimprocEntry._sizeOf_inst | Lean.Meta.Tactic.Simp.Types | SizeOf Lean.Meta.Simp.SimprocEntry | null | false |
SSet.Truncated.Edge.CompStruct.d₁._autoParam | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | Lean.Syntax | null | false |
Int.Internal.Linear.le_combine | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (p₁ p₂ p₃ : Int.Internal.Linear.Poly),
Int.Internal.Linear.le_combine_cert p₁ p₂ p₃ = true →
Int.Internal.Linear.Poly.denote' ctx p₁ ≤ 0 →
Int.Internal.Linear.Poly.denote' ctx p₂ ≤ 0 → Int.Internal.Linear.Poly.denote' ctx p₃ ≤ 0 | null | true |
CategoryTheory.Sieve.mem_ofArrows_iff | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {I : Type u_1} {X : C} (Y : I → C) (f : (i : I) → Y i ⟶ X)
{W : C} (g : W ⟶ X),
(CategoryTheory.Sieve.ofArrows Y f).arrows g ↔ ∃ i a, g = CategoryTheory.CategoryStruct.comp a (f i) | null | true |
SubAddAction.instSupSet.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : VAdd R M],
SubAddAction.instSupSet = { sSup := fun S => { carrier := ⋃ s ∈ S, ↑s, vadd_mem' := ⋯ } } | null | true |
Lean.Elab.Term.ElabElimInfo.mk._flat_ctor | Lean.Elab.App | Lean.Expr → Lean.Expr → ℕ → Array ℕ → Lean.Elab.Term.ElabElimInfo | null | false |
DFinsupp.range_mapRangeAddMonoidHom | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {β₁ : ι → Type u_8} {β₂ : ι → Type u_9} [inst : (i : ι) → AddCommGroup (β₁ i)]
[inst_1 : (i : ι) → AddCommGroup (β₂ i)] (f : (i : ι) → β₂ i →+ β₁ i),
(DFinsupp.mapRange.addMonoidHom f).range =
AddSubgroup.comap DFinsupp.coeFnAddMonoidHom (AddSubgroup.pi Set.univ fun x => (f x).range) | null | true |
sbtw_comm | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y z : P}, Sbtw R x y z ↔ Sbtw R z y x | null | true |
Lean.Lsp.LeanQueryModuleParams.mk.injEq | Lean.Data.Lsp.Internal | ∀ (sourceRequestID : Lean.JsonRpc.RequestID) (queries : Array Lean.Lsp.LeanModuleQuery)
(sourceRequestID_1 : Lean.JsonRpc.RequestID) (queries_1 : Array Lean.Lsp.LeanModuleQuery),
({ sourceRequestID := sourceRequestID, queries := queries } =
{ sourceRequestID := sourceRequestID_1, queries := queries_1 }) =
... | null | true |
List.instDecidableMapsToCoeFinsetOfDecidablePredMemSet | Mathlib.Data.Finset.Defs | {α : Type u_1} →
{β : Type u_2} →
{f : α → β} → {s : Finset α} → {t : Set β} → [DecidablePred fun x => x ∈ t] → Decidable (Set.MapsTo f (↑s) t) | null | true |
IsPurelyInseparable.iterateFrobeniusₛₗ_algebraMap_base | Mathlib.FieldTheory.PurelyInseparable.Exponent | ∀ (F : Type u_1) (K : Type u_2) (L : Type u_3) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : IsPurelyInseparable.HasExponent K L] (p : ℕ) [inst_4 : ExpChar K p] [inst_5 : Field F]
[inst_6 : Algebra F K] [inst_7 : Algebra F L] [inst_8 : IsScalarTower F K L] [inst_9 : ExpChar F p] {n : ℕ}
(hn... | Action of `iterateFrobeniusₛₗ` on the base field. | true |
Lean.Meta.Match.DiscrInfo.mk._flat_ctor | Lean.Meta.Match.MatcherInfo | Option Lean.Name → Lean.Meta.Match.DiscrInfo | null | false |
CategoryTheory.Limits.widePushoutShapeUnop_obj | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type w) (X : (CategoryTheory.Limits.WidePushoutShape J)ᵒᵖ),
(CategoryTheory.Limits.widePushoutShapeUnop J).obj X = Opposite.unop X | null | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.getInstances.match_1 | Lean.Meta.SynthInstance | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((constName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const constName us)) →
((x : Lean.Expr) → motive x) → motive x | null | false |
Lean.Parser.Syntax.cat.parenthesizer | Lean.Parser.Syntax | Lean.PrettyPrinter.Parenthesizer | null | true |
CategoryTheory.ShortComplex.ShortExact.mono_f | Mathlib.Algebra.Homology.ShortComplex.ShortExact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, S.ShortExact → CategoryTheory.Mono S.f | null | true |
_private.Mathlib.MeasureTheory.Integral.PeakFunction.0.tendsto_integral_comp_smul_smul_of_integrable._simp_1_2 | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.closedBall x ε) = (dist y x ≤ ε) | null | false |
_private.Mathlib.Data.Int.CardIntervalMod.0.Int.Ioc_filter_dvd_eq._simp_1_1 | Mathlib.Data.Int.CardIntervalMod | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}, (b ∈ Finset.map f s) = ∃ a ∈ s, f a = b | null | false |
AlgebraicGeometry.AlgebraicCycle.degree_apply | Mathlib.AlgebraicGeometry.AlgebraicCycle.Basic | ∀ {X Y : AlgebraicGeometry.Scheme} {R : Type u_1} (f : X ⟶ Y) [inst : CompactSpace ↥X] [inst_1 : AddCommMonoid R]
(D : AlgebraicGeometry.AlgebraicCycle X R),
(AlgebraicGeometry.AlgebraicCycle.degree f) D = ∑ᶠ (x : ↥X), AlgebraicGeometry.Scheme.Hom.residueDegree f x • D x | null | true |
exists_of_not_isMeagre_biUnion | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} {ι : Type u_3} [inst : TopologicalSpace X] {I : Set ι},
I.Countable → ∀ {A : ι → Set X}, ¬IsMeagre (⋃ i ∈ I, A i) → ∃ i ∈ I, ¬IsMeagre (A i) | null | true |
_private.Mathlib.CategoryTheory.Presentable.Comma.0.CategoryTheory.Comma.isCardinalAccessibleCategory.instIsFilteredJ₁OfIsCardinalAccessibleCategory | Mathlib.CategoryTheory.Presentable.Comma | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
{F₁ : CategoryTheory.Functor C₁ D} {F₂ : CategoryTheory.Functor C₂ D} (κ : Cardinal.{w}) [inst_3 : Fact κ.IsRegular]
(f :... | null | true |
Order.Ideal.biSup_finset_mem_iff._simp_1 | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : CompleteLattice P] {I : Order.Ideal P} {α : Type u_2} {f : α → P} {s : Finset α},
(⨆ i ∈ s, f i ∈ I) = ∀ i ∈ s, f i ∈ I | null | false |
CategoryTheory.Endofunctor.Algebra.mk._flat_ctor | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C C} → (a : C) → (F.obj a ⟶ a) → CategoryTheory.Endofunctor.Algebra F | null | false |
LieSubalgebra.add_mem | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L)
{x y : L}, x ∈ L' → y ∈ L' → x + y ∈ L' | null | true |
CategoryTheory.WithTerminal.Hom.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithTerminal C),
x.Hom CategoryTheory.WithTerminal.star = PUnit.{v + 1} | null | true |
List.zipIdx.eq_1 | Init.Data.List.Impl | ∀ {α : Type u} (x : ℕ), [].zipIdx x = [] | null | true |
NonUnitalSubsemiring.toSubsemiring_toNonUnitalSubsemiring | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] (S : NonUnitalSubsemiring R) (h1 : 1 ∈ S),
(S.toSubsemiring h1).toNonUnitalSubsemiring = S | null | true |
_private.Batteries.Lean.Meta.UnusedNames.0.Lean.LocalContext.getUnusedUserNames.loop._sunfold | Batteries.Lean.Meta.UnusedNames | Lean.Name → Array Lean.Name → ℕ → ℕ → Array Lean.Name | null | false |
CategoryTheory.Limits.IsLimit.ofIsZero._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasZeroObject C] {F : CategoryTheory.Functor D C} (c : CategoryTheory.Limits.Cone F),
CategoryTheory.Limits.IsZer... | null | false |
Lean.Parser.Term.doFor | Lean.Parser.Do | Lean.Parser.Parser | `for x in e do s` iterates over `e` assuming `e`'s type has an instance of the `ForIn` typeclass.
`break` and `continue` are supported inside `for` loops.
`for x in e, x2 in e2, ... do s` iterates over the given collections in parallel,
until at least one of them is exhausted.
The types of `e2` etc. must implement the ... | true |
Mathlib.Tactic.getDSimpArgs | Mathlib.Tactic.Core | Lean.Syntax → Lean.Elab.Tactic.TacticM (Array Lean.Syntax) | Extract the arguments from a `dsimpArgs` syntax as an array of syntaxes | true |
exists_isTranscendenceBasis_and_isSeparable_of_linearIndepOn_pow' | Mathlib.FieldTheory.SeparablyGenerated | ∀ {k : Type u_1} {K : Type u_2} {ι : Type u_3} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] (p : ℕ),
Nat.Prime p →
(∀ (s : Finset K), LinearIndepOn k id ↑s → LinearIndepOn k (fun x => x ^ p) ↑s) →
∀ {a : ι → K} [ExpChar k p] (s : Set ι) (n : ι),
(IsTranscendenceBasis k fun i => a ↑i) →... | null | true |
CategoryTheory.End.ext | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u} {inst : CategoryTheory.CategoryStruct.{v, u} C} {X : C} {x y : CategoryTheory.End X},
x.asHom = y.asHom → x = y | null | true |
Fin.neg | Init.Data.Fin.Basic | (n : ℕ) → Neg (Fin n) | Negation on `Fin n` | true |
AlgebraicGeometry.isLimitOpensCone._proof_4 | Mathlib.AlgebraicGeometry.AffineTransitionLimit | ∀ {I : Type u_1} [inst : CategoryTheory.Category.{u_1, u_1} I] (D : CategoryTheory.Functor I AlgebraicGeometry.Scheme)
(c : CategoryTheory.Limits.Cone D) (i : I) (U : (D.obj i).Opens) (j : CategoryTheory.Over i),
CategoryTheory.IsPullback ((AlgebraicGeometry.opensCone D c i U).π.app j)
{ hom := ((TopologicalSpa... | null | false |
Part.Fix.approx._sunfold | Mathlib.Control.Fix | {α : Type u_1} → {β : α → Type u_2} → (((a : α) → Part (β a)) → (a : α) → Part (β a)) → Stream' ((a : α) → Part (β a)) | null | false |
_private.Std.Data.Iterators.Lemmas.Equivalence.Basic.0.Std.quotOfQuot._proof_1 | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α : Sort u_1} {R S : α → α → Prop},
(∀ (a b : α), R a b → S a b) → ∀ (x x_1 : α), R x x_1 → Quot.mk S x = Quot.mk S x_1 | null | false |
WellFounded.sigma_lex_of_wellFoundedOn_fiber | Mathlib.Order.WellFoundedSet | ∀ {ι : Type u_1} {γ : Type u_4} {π : ι → Type u_5} {rι : ι → ι → Prop} {rπ : (i : ι) → π i → π i → Prop} {f : γ → ι}
{g : (i : ι) → γ → π i},
WellFounded (Function.onFun rι f) →
(∀ (i : ι), (f ⁻¹' {i}).WellFoundedOn (Function.onFun (rπ i) (g i))) →
WellFounded (Function.onFun (Sigma.Lex rι rπ) fun c => ⟨f... | Stronger version of `PSigma.lex_wf`. Instead of requiring `rπ on g` to be well-founded, we only
require it to be well-founded on fibers of `f`. | true |
LocallyPathConnectedSpace.mk | Mathlib.Topology.Connected.LocallyPathConnected | ∀ {X : Type u_4} [inst : TopologicalSpace X],
(∀ (x : X), (nhds x).HasBasis (fun s => s ∈ nhds x ∧ IsPathConnected s) id) → LocallyPathConnectedSpace X | null | true |
TopCat.homeoOfIso_symm_apply | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat} (f : X ≅ Y) (a : ↑Y), (TopCat.homeoOfIso f).symm a = (CategoryTheory.ConcreteCategory.hom f.inv) a | null | true |
HahnSeries.finiteArchimedeanClassOrderIsoLex_apply_fst | Mathlib.RingTheory.HahnSeries.Lex | ∀ {Γ : Type u_1} {R : Type u_2} [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[inst_3 : IsOrderedAddMonoid R] {x : Lex (HahnSeries Γ R)} (h : x ≠ 0),
↑(ofLex ((HahnSeries.finiteArchimedeanClassOrderIsoLex Γ R) (FiniteArchimedeanClass.mk x h))).1 = (ofLex x).orderTop | null | true |
CategoryTheory.Square.opFunctor._proof_2 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y),
(CategoryTheory.CategoryStruct.comp (Opposite.unop X).op.f₁₃ φ.unop.τ₃.op).unop =
(CategoryTheory.CategoryStruct.comp φ.unop.τ₄.op (Opposite.unop Y).op.f₁₃).unop | null | false |
Mathlib.Tactic.Bound.lt_max_of_lt_left_or_lt_right | Mathlib.Tactic.Bound | ∀ {α : Type} [inst : LinearOrder α] {a b c : α}, a < b ∨ a < c → a < max b c | null | true |
_private.Mathlib.LinearAlgebra.Transvection.Generation.0.LinearEquiv.auxTransvection._proof_1 | Mathlib.LinearAlgebra.Transvection.Generation | ∀ {K : Type u_1} [inst : DivisionRing K] {V : Type u_2} [inst_1 : AddCommGroup V] [inst_2 : Module K V] {e : V ≃ₗ[K] V}
{f : Module.Dual K V} {u : V}, (↑e).fixedSubmodule ⊔ K ∙ (e u - u) ≤ LinearMap.ker f → f (u - e u) = 0 | null | false |
RatFunc.setOf_polynomial_valuation_lt_one_and_ne_zero_nonempty | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_1} {Γ : Type u_2} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [v.IsNontrivial] [Valuation.IsTrivialOn K v],
v RatFunc.X ≤ 1 → {p | v ↑p < 1 ∧ p ≠ 0}.Nonempty | **Alias** of `RatFunc.setOfPred_polynomial_valuation_lt_one_and_ne_zero_nonempty`. | true |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.whisker | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | Mathlib.Tactic.BicategoryLike.Mor₂ →
Mathlib.Tactic.BicategoryLike.Atom₁ →
Mathlib.Tactic.BicategoryLike.WhiskerLeft → Mathlib.Tactic.BicategoryLike.WhiskerLeft | Construct the expression for `f ◁ η`. | true |
_private.Aesop.Search.Expansion.0.Aesop.runFirstUnsafeRule.loop | Aesop.Search.Expansion | {Q : Type} →
[inst : Aesop.Queue Q] → Aesop.GoalRef → Aesop.UnsafeQueue → Aesop.SearchM Q (Aesop.UnsafeQueue × Aesop.RuleResult) | null | true |
CategoryTheory.InjectiveResolution.isLimitKernelFork._proof_5 | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C},
((HomologicalComplex.single C (ComplexShape.up ℕ) 0).obj Z).HasHomology 0 | null | false |
AddSemiconjBy.neg_neg_symm_iff | Mathlib.Algebra.Group.Semiconj.Basic | ∀ {G : Type u_1} [inst : SubtractionMonoid G] {a x y : G}, AddSemiconjBy (-a) (-x) (-y) ↔ AddSemiconjBy a y x | null | true |
HahnSeries.single | Mathlib.RingTheory.HahnSeries.Basic | {Γ : Type u_1} → {R : Type u_3} → [inst : PartialOrder Γ] → [inst_1 : Zero R] → Γ → ZeroHom R (HahnSeries Γ R) | `single a r` is the Hahn series which has coefficient `r` at `a` and zero otherwise. | true |
_private.Qq.Macro.0.Qq.Impl.isBad.match_1 | Qq.Macro | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((pre : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const (pre.str "rec") us)) →
((x : Lean.Expr) → motive x) → motive x | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_alter_eq_isEmpty_erase._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
LinearMap.isNilpotent_mulRight_iff._simp_1 | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ (R : Type u_1) {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A),
IsNilpotent (LinearMap.mulRight R a) = IsNilpotent a | null | false |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.IsPrime.notMem_of_isCoprime_of_mem.match_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {x y : R} (motive : IsCoprime x y → Prop) (h : IsCoprime x y),
(∀ (a b : R) (e : a * x + b * y = 1), motive ⋯) → motive h | null | false |
CategoryTheory.CommShift₂Setup.mk.noConfusion | Mathlib.CategoryTheory.Shift.CommShiftTwo | {D : Type u_5} →
{inst : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_1 : AddCommMonoid M} →
{inst_2 : CategoryTheory.HasShift D M} →
{P : Sort u} →
{toTwistShiftData :
CategoryTheory.TwistShiftData
(CategoryTheory.PullbackShi... | null | false |
CategoryTheory.preservesLimitsOfShape_presheafToSheaf | Mathlib.CategoryTheory.Sites.LeftExact | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} {D : Type w}
[inst_1 : CategoryTheory.Category.{t, w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
[inst_3 : ∀ (X : C), Catego... | null | true |
Lean.Meta.Simp.instInhabitedBuiltinSimprocs.default | Lean.Meta.Tactic.Simp.Simproc | Lean.Meta.Simp.BuiltinSimprocs | null | true |
Mathlib.Tactic.Reassoc.reassocExprHom | Mathlib.Tactic.CategoryTheory.Reassoc | Lean.Expr → Lean.MetaM (Lean.Expr × Array Lean.MVarId) | Given an equation `f = g` between morphisms `X ⟶ Y` in a category,
produce the equation `∀ {Z} (h : Y ⟶ Z), f ≫ h = g ≫ h`,
but with compositions fully right associated and identities removed.
Also returns the category `C` and any instance metavariables that need to be solved for.
| true |
Subgroup.focalSubgroupOf_eq_closure | Mathlib.GroupTheory.Focal | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.focalSubgroupOf = Subgroup.closure {g | ∃ x ∈ H, ∃ u, ↑g = ⁅x, u⁆} | null | true |
Array.isSome_findSome? | Init.Data.Array.Find | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Option β},
(Array.findSome? f xs).isSome = xs.any fun x => (f x).isSome | null | true |
Mathlib.Tactic.ITauto.Context.add | Mathlib.Tactic.ITauto | Mathlib.Tactic.ITauto.IProp →
Mathlib.Tactic.ITauto.Proof →
Mathlib.Tactic.ITauto.Context →
Except (Mathlib.Tactic.ITauto.IProp → Mathlib.Tactic.ITauto.Proof) Mathlib.Tactic.ITauto.Context | Insert a proposition and its proof into the context, as in `have : A := p`. This will eagerly
apply all level 1 rules on the spot, which are rules that don't split the goal and are validity
preserving: specifically, we drop `⊤` and `A → ⊤` hypotheses, close the goal if we find a `⊥`
hypothesis, split all conjunctions, ... | true |
AlgebraicGeometry.Scheme.IdealSheafData.glueData_t | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (i j : ↑X.affineOpens), I.glueData.t i j = I.glueDataT i j | null | true |
Finset.subtractionCommMonoid._proof_4 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : SubtractionCommMonoid α] (s t : Finset α), ↑(s - t) = ↑s - ↑t | null | false |
_private.Mathlib.NumberTheory.ModularForms.RamanujanFormula.0.Derivative.serreDerivative_eq_smul | Mathlib.NumberTheory.ModularForms.RamanujanFormula | ∀ {k' : ℤ} {k l L : ℂ} {g F : ModularForm (Matrix.SpecialLinearGroup.mapGL ℝ).range k'} {f : UpperHalfPlane → ℂ},
⇑F = Derivative.serreDerivative k f →
Module.rank ℂ (ModularForm (Matrix.SpecialLinearGroup.mapGL ℝ).range k') = 1 →
MDiff f →
Filter.Tendsto f UpperHalfPlane.atImInfty (nhds l) →
... | The dimension argument: let `F` be a weight-`k'` modular form whose underlying function is
the Serre derivative `∂_κ f` of a holomorphic `f` with limit `l` at `i∞`. If the space of
weight-`k'` forms has rank one with a generator `g` tending to `1` at `i∞`, then
`∂_κ f = -(κ / 12) l • g`. | true |
RootPairing.chainBotCoeff_add_chainTopCoeff_le_three | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] {i j : ι} [P.IsR... | null | true |
NumberField.AdeleRing.instInhabited | Mathlib.NumberTheory.NumberField.AdeleRing | (R : Type u_1) →
(K : Type u_2) →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
[inst_2 : Field K] →
[inst_3 : Algebra R K] → [inst_4 : IsFractionRing R K] → Inhabited (NumberField.AdeleRing R K) | null | true |
ContinuousMap.piEquiv._proof_1 | Mathlib.Topology.ContinuousMap.Basic | ∀ {I : Type u_1} (A : Type u_2) (X : I → Type u_3) [inst : TopologicalSpace A]
[inst_1 : (i : I) → TopologicalSpace (X i)],
Function.LeftInverse (fun f i => (ContinuousMap.eval i).comp f) ContinuousMap.pi | null | false |
WithCStarModule.instNormedAddCommGroupProd._proof_8 | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {E : Type u_3} {F : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : Module ℂ E] [inst_4 : SMul A E] [inst_5 : NormedAddCommGroup F]
[inst_6 : Module ℂ F] [inst_7 : SMul A F] [inst_8 : CStarModule A E] [inst_9 : CStarModule A F]
[inst_... | null | false |
List.Perm.cons | Init.Data.List.Basic | ∀ {α : Type u} (x : α) {l₁ l₂ : List α}, l₁.Perm l₂ → (x :: l₁).Perm (x :: l₂) | If one list is a permutation of the other, adding the same element as the head of each yields
lists that are permutations of each other: `l₁ ~ l₂ → x::l₁ ~ x::l₂`.
| true |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioo_union_Ioo._proof_1_1 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c d : α},
min a b < max c d → min c d < max a b → Set.Ioo a b ∪ Set.Ioo c d = Set.Ioo (min a c) (max b d) | null | false |
_private.Init.Data.Fin.Lemmas.0.Fin.zero_mul._simp_1_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | null | false |
ISize.toInt32_ofIntClamp | Init.Data.SInt.Lemmas | ∀ {n : ℤ},
-2 ^ (System.Platform.numBits - 1) ≤ n →
n < 2 ^ (System.Platform.numBits - 1) → (ISize.ofIntClamp n).toInt32 = Int32.ofInt n | null | true |
_private.Init.Data.String.Lemmas.Pattern.Find.Pred.0.String.find?_prop_eq_some_iff._simp_1_2 | Init.Data.String.Lemmas.Pattern.Find.Pred | ∀ {p : Prop} {x : Decidable p}, (decide p = false) = ¬p | null | false |
Std.Sat.AIG.RefVec.IfInput.rhs | Std.Sat.AIG.If | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {aig : Std.Sat.AIG α} → {w : ℕ} → Std.Sat.AIG.RefVec.IfInput aig w → aig.RefVec w | null | true |
_private.Lean.Meta.Tactic.LibrarySearch.0.Lean.Meta.LibrarySearch.librarySearchSymm.match_1 | Lean.Meta.Tactic.LibrarySearch | (motive : Option Lean.MVarId → Sort u_1) →
(__do_lift : Option Lean.MVarId) →
((symmGoal : Lean.MVarId) → motive (some symmGoal)) → ((x : Option Lean.MVarId) → motive x) → motive __do_lift | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.