name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MeasureTheory.measurePreserving_pi_empty | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u} {α : ι → Type v} [inst : Fintype ι] [inst_1 : IsEmpty ι] {m : (i : ι) → MeasurableSpace (α i)}
(μ : (i : ι) → MeasureTheory.Measure (α i)),
MeasureTheory.MeasurePreserving (⇑(MeasurableEquiv.ofUniqueOfUnique ((i : ι) → α i) Unit))
(MeasureTheory.Measure.pi μ) (MeasureTheory.Measure.dirac ()) | null | true |
definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.PiL2.1554134833._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [FiniteDimensional 𝕜 E] {n : ℕ},
Module.finrank 𝕜 E = n →
∀ [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E},
DirectSum.IsInternal V →
(Ortho... | null | false |
BoundedContinuousFunction.rec | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
{motive : BoundedContinuousFunction α β → Sort u_1} →
((toContinuousMap : C(α, β)) →
(map_bounded' : ∃ C, ∀ (x y : α), dist (toContinuousMap.toFun x) (toContinuousMap.toFun y) ≤ C) →
... | null | false |
_private.Mathlib.RingTheory.Coalgebra.CoassocSimps.0.CoassocSimps.«termλ» | Mathlib.RingTheory.Coalgebra.CoassocSimps | Lean.ParserDescr | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Finite.0.SimpleGraph.exists_minimal_degree_vertex._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] [inst_1 : DecidableRel G.Adj] [Nonempty V],
∃ v, G.minDegree = G.degree v | null | false |
CategoryTheory.ShortComplex.opcyclesFunctor | Mathlib.Algebra.Homology.ShortComplex.RightHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[CategoryTheory.Limits.HasKernels C] →
[CategoryTheory.Limits.HasCokernels C] → CategoryTheory.Functor (CategoryTheory.ShortComplex C) C | The opcycles functor `ShortComplex C ⥤ C` which sends a short complex `S` to `S.opcycles`
which is a cokernel of `S.f : S.X₁ ⟶ S.X₂`. | true |
monovaryOn_neg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
MonovaryOn (-f) (-g) s ↔ MonovaryOn f g s | null | true |
Lean.Elab.Term.elabLetDelayedDecl | Lean.Elab.Binders | Lean.Elab.Term.TermElab | null | true |
Array.appendCore.loop | Init.Prelude | {α : Type u} → Array α → ℕ → ℕ → Array α → Array α | null | true |
FormalGroup.Point | Mathlib.RingTheory.FormalGroup.Basic | {R : Type u_1} → [inst : CommRing R] → FormalGroup R → Type u_6 → Type (max 0 u_1 u_6) | `F.Point σ` represents the mathematical space of points of a formal group $F$
taking values in the formal power series ring `MvPowerSeries σ R` with the property
that constant coefficient is nilpotent.
TODO: Mathematically, a 1-dimensional formal group law $F$ over a ring $R$ defines a group
structure on the elements ... | true |
Subgroup.FG.eq_1 | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (P : Subgroup G), P.FG = IsMulFG ↥P | null | true |
instDecidableEqColex | Mathlib.Order.Lex | (α : Type u_2) → [DecidableEq α] → DecidableEq (Colex α) | null | true |
AlgEquiv.aut._proof_8 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A₁ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁]
(x : A₁ ≃ₐ[R] A₁), 1 * x = x | null | false |
MulEquiv.toMonCatIso | Mathlib.Algebra.Category.MonCat.Basic | {X Y : Type u} → [inst : Monoid X] → [inst_1 : Monoid Y] → X ≃* Y → (↧X ≅ ↧Y) | Build an isomorphism in the category `MonCat` from a `MulEquiv` between `Monoid`s. | true |
InfClosed.infClosure_eq | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeInf α] {s : Set α}, InfClosed s → infClosure s = s | **Alias** of the reverse direction of `infClosure_eq_self`. | true |
_private.Mathlib.Analysis.Meromorphic.Order.0.MeromorphicOn.codiscrete_setOfPred_meromorphicOrderAt_eq_zero_or_top._simp_1_2 | Mathlib.Analysis.Meromorphic.Order | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
_private.Std.Http.Internal.IndexMultiMap.0.Std.Internal.IndexMultiMap.insert.match_1.congr_eq_2 | Std.Http.Internal.IndexMultiMap | ∀ (motive : Option (Array ℕ) → Sort u_1) (x : Option (Array ℕ)) (h_1 : (idxs : Array ℕ) → motive (some idxs))
(h_2 : Unit → motive none),
x = none →
(match x with
| some idxs => h_1 idxs
| none => h_2 ()) ≍
h_2 () | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_comp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | The square `precomposeTransformSquare` respects compositions. | true |
AlgebraicGeometry.Scheme.instAddCommGroupEllAdicCohomology._proof_21 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (X : AlgebraicGeometry.Scheme) (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)] (n : ℕ),
autoParam (∀ (n_1 : ℕ) (a : X.EllAdicCohomology ℓ n), Int.negSucc n_1 • a = -(↑n_1.succ • a))
SubNegMonoid.zsmul_neg'._autoParam | null | false |
CategoryTheory.Bicategory.Adj.iso₂Mk._proof_1 | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {a b : CategoryTheory.Bicategory.Adj B} {α β : a ⟶ b}
(el : α.l ≅ β.l) (er : β.r ≅ α.r),
(CategoryTheory.Bicategory.conjugateEquiv β.adj α.adj) el.hom = er.hom →
(CategoryTheory.Bicategory.conjugateEquiv α.adj β.adj) el.inv = er.inv | null | false |
CategoryTheory.instPreadditiveOpposite._proof_10 | Mathlib.CategoryTheory.Preadditive.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (X Y : Cᵒᵖ)
(a : X ⟶ Y), -a + a = 0 | null | false |
String.Slice.Pos.byte.eq_1 | Init.Data.String.Basic | ∀ {s : String.Slice} (pos : s.Pos) (h : pos ≠ s.endPos), pos.byte h = s.getUTF8Byte pos.offset ⋯ | null | true |
_private.Mathlib.Analysis.Convex.Jensen.0.StrictConvexOn.map_sum_eq_iff_of_pos._simp_1_3 | Mathlib.Analysis.Convex.Jensen | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, ∑ i ∈ s, f i • x = (∑ i ∈ s, f i) • x | null | false |
CategoryTheory.Monoidal.InducingFunctorData.rec | Mathlib.CategoryTheory.Monoidal.Transport | {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.MonoidalCategoryStruct D] →
{F : CategoryTheory.Functor D C} →
{mo... | null | false |
Mathlib.Linter.linter.style.setOption | Mathlib.Tactic.Linter.Style | Lean.Option Bool | The `setOption` linter emits a warning on a `set_option` command, term or tactic
which sets a `pp`, `profiler` or `trace` option.
It also warns on an option containing `maxHeartbeats`
(as these should be scoped as `set_option ... in` instead). | true |
CategoryTheory.ULift.upFunctor | Mathlib.CategoryTheory.Category.ULift | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → CategoryTheory.Functor C (ULift.{u₂, u₁} C) | The functorial version of `ULift.up`. | true |
Mathlib.Tactic.filterUpwards | Mathlib.Order.Filter.Defs | Lean.ParserDescr | `filter_upwards [h₁, ⋯, hₙ]` replaces a goal of the form `s ∈ f` and terms
`h₁ : t₁ ∈ f, ⋯, hₙ : tₙ ∈ f` with `∀ x, x ∈ t₁ → ⋯ → x ∈ tₙ → x ∈ s`.
The list is an optional parameter, `[]` being its default value.
`filter_upwards [h₁, ⋯, hₙ] with a₁ a₂ ⋯ aₖ` is a short form for
`{ filter_upwards [h₁, ⋯, hₙ], intro a₁ a₂ ... | true |
instTotallyDisconnectedSpaceMultiplicative | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] [TotallyDisconnectedSpace α], TotallyDisconnectedSpace (Multiplicative α) | null | true |
BooleanAlgebra.toBooleanRing._proof_5 | Mathlib.Algebra.Ring.BooleanRing | ∀ {α : Type u_1} [inst : BooleanAlgebra α] (n : ℕ), (↑n).castDef = ↑n | null | false |
Module.Finite.addMonoidHom | Mathlib.LinearAlgebra.FreeModule.Finite.Matrix | ∀ (M : Type v) (N : Type w) [inst : AddCommGroup M] [Module.Finite ℤ M] [Module.Free ℤ M] [inst_3 : AddCommGroup N]
[Module.Finite ℤ N], Module.Finite ℤ (M →+ N) | null | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c = Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.reorder c_1) =
(c = c_1) | null | true |
_private.Batteries.Data.List.Lemmas.0.List.dropPrefix?.match_1.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (list : List α) (h_1 : (list : List α) → motive list [])
(h_2 : (head : α) → (tail : List α) → motive [] (head :: tail))
(h_3 : (a : α) → (as : List α) → (b : α) → (bs : List α) → motive (a :: as) (b :: bs)),
(match list, [] with
| list, [] => h_1 list
... | null | true |
SimpleGraph.Subgraph.Connected.mono' | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {H H' : G.Subgraph},
(∀ (v w : V), H.Adj v w → H'.Adj v w) → H.verts = H'.verts → H.Connected → H'.Connected | null | true |
dvd_mul_gcd_of_dvd_mul | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : GCDMonoid α] {m n k : α}, k ∣ m * n → k ∣ m * gcd k n | null | true |
CategoryTheory.GlueData.mk | Mathlib.CategoryTheory.GlueData | {C : Type u₁} →
[inst : CategoryTheory.Category.{v, u₁} C] →
(J : Type v) →
(U : J → C) →
(V : J × J → C) →
(f : (i j : J) → V (i, j) ⟶ U i) →
autoParam (∀ (i j : J), CategoryTheory.Mono (f i j)) CategoryTheory.GlueData.f_mono._autoParam →
(f_hasPullback :
... | null | true |
Filter.div_le_div_right | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f₁ f₂ g : Filter α}, f₁ ≤ f₂ → f₁ / g ≤ f₂ / g | null | true |
_private.Mathlib.Analysis.PSeries.0.Real.summable_nat_rpow_inv._simp_1_1 | Mathlib.Analysis.PSeries | ∀ (x : ℝ) (n : ℕ), x ^ n = x ^ ↑n | null | false |
MeasureTheory.memLp_zero_iff_aestronglyMeasurable._simp_1 | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {ε : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : ENorm ε]
[inst_1 : TopologicalSpace ε] {f : α → ε}, MeasureTheory.MemLp f 0 μ = MeasureTheory.AEStronglyMeasurable f μ | null | false |
instDecidablePredPermMemSetDerangements | Mathlib.Combinatorics.Derangements.Finite | {α : Type u_1} → [DecidableEq α] → [Fintype α] → DecidablePred fun x => x ∈ derangements α | null | true |
MulOpposite.instMulOneClass._proof_1 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : MulOneClass α] (x : αᵐᵒᵖ), 1 * x = x | null | false |
Submodule.range_inclusion | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p q : Submodule R M) (h : p ≤ q), (Submodule.inclusion h).range = Submodule.comap q.subtype p | null | true |
LinearMap.IsRightQuasiInverse.equiv | Mathlib.Algebra.Module.LinearMap.FiniteRange | ∀ {K : Type u_1} {V₂ : Type u_3} {V₃ : Type u_4} [inst : CommRing K] [inst_1 : AddCommGroup V₂] [inst_2 : Module K V₂]
[inst_3 : AddCommGroup V₃] [inst_4 : Module K V₃] {u : V₃ →ₗ[K] V₂} {v : V₂ →ₗ[K] V₃},
u.IsRightQuasiInverse v → v ∘ₗ u ≈ LinearMap.id | null | true |
CommRingCat.tensorProd_map_right | Mathlib.Algebra.Category.Ring.Under.Basic | ∀ (R S : CommRingCat) [inst : Algebra ↑R ↑S] {X Y : CategoryTheory.Under R} (f : X ⟶ Y),
((R.tensorProd S).map f).right =
CommRingCat.ofHom ↑(Algebra.TensorProduct.map (AlgHom.id ↑S ↑S) (CommRingCat.toAlgHom f)) | null | true |
Std.Tactic.BVDecide.Normalize.Bool.ite_else_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {α : Sort u_1} (c0 c1 : Bool) {a b : α}, (bif c0 then a else bif c1 then a else b) = bif !c0 && !c1 then b else a | null | true |
InitialSeg.transPrincipal_apply | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
[inst : IsWellOrder β s] [inst_1 : IsTrans γ t] (f : InitialSeg r s) (g : PrincipalSeg s t) (a : α),
(f.transPrincipal g).toRelEmbedding a = g.toRelEmbedding (f a) | null | true |
ModuleCat.HasLimits.limitCone._proof_1 | Mathlib.Algebra.Category.ModuleCat.Limits | ∀ {R : Type u_2} [inst : Ring R] {J : Type u_4} [inst_1 : CategoryTheory.Category.{u_3, u_4} J]
(F : CategoryTheory.Functor J (ModuleCat R))
[inst_2 : Small.{u_1, max u_4 u_1} ↑(F.comp (CategoryTheory.forget (ModuleCat R))).sections] (x x_1 : J)
(f : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((Categor... | null | false |
MulEquiv.piCongrRight_symm | Mathlib.Algebra.Group.Equiv.Basic | ∀ {η : Type u_15} {Ms : η → Type u_16} {Ns : η → Type u_17} [inst : (j : η) → Mul (Ms j)]
[inst_1 : (j : η) → Mul (Ns j)] (es : (j : η) → Ms j ≃* Ns j),
(MulEquiv.piCongrRight es).symm = MulEquiv.piCongrRight fun i => (es i).symm | null | true |
LieSubalgebra.exists_nested_lieIdeal_coe_eq_iff | Mathlib.Algebra.Lie.Ideal | ∀ (R : Type u) {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L)
{K' : LieSubalgebra R L} (h : K ≤ K'),
(∃ I, ↑R (↥K') I = LieSubalgebra.ofLe h) ↔ ∀ (x y : L), x ∈ K' → y ∈ K → ⁅x, y⁆ ∈ K | null | true |
_private.Init.Data.List.MinMaxIdx.0.List.minIdxOn_nil_eq_iff_true.match_1_1 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} (motive : [] ≠ [] → Prop) (h : [] ≠ []), motive h | null | false |
Submodule.ClosedComplemented.complement | Mathlib.Topology.Algebra.Module.Complement | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_2} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] → [inst_3 : Module R M] → {p : Submodule R M} → p.ClosedComplemented → Submodule R M | An arbitrary choice of topological complement of a topologically complemented submodule. | true |
EquivFunctor.mapEquiv_apply | Mathlib.Control.EquivFunctor | ∀ (f : Type u₀ → Type u₁) [inst : EquivFunctor f] {α β : Type u₀} (e : α ≃ β) (x : f α),
(EquivFunctor.mapEquiv f e) x = EquivFunctor.map e x | null | true |
PosNum.testBit.eq_5 | Mathlib.Data.Num.Lemmas | ∀ (a : PosNum), a.bit1.testBit 0 = true | null | true |
_private.Lean.Elab.Import.0.Lean.Elab.parseImports.match_1 | Lean.Elab.Import | (motive : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog → Sort u_1) →
(x : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog) →
((header : Lean.TSyntax `Lean.Parser.Module.header) →
(parserState : Lean.Parser.ModuleParserS... | null | false |
CategoryTheory.Epi.left_cancellation | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X Y : C} {f : X ⟶ Y} [self : CategoryTheory.Epi f] {Z : C}
(g h : Y ⟶ Z), CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h → g = h | A morphism `f` is an epimorphism if it can be cancelled when precomposed. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int32.reduceSub._regBuiltin.Int32.reduceSub.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.114 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
Std.Time.Hour.instLEOffset._aux_1 | Std.Time.Time.Unit.Hour | Std.Time.Hour.Offset → Std.Time.Hour.Offset → Prop | null | false |
MeasureTheory.convolution_zero | Mathlib.Analysis.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} [inst_3 : NontriviallyNormedField 𝕜]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 F] {L : E →L[... | null | true |
CategoryTheory.Subobject.ofLEMk.eq_1 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X ≤ CategoryTheory.Subobject.mk f),
X.ofLEMk f h =
CategoryTheory.CategoryStruct.comp (X.ofLE (CategoryTheory.Subobject.mk f) h)
(CategoryTheory.Subobjec... | null | true |
String.Slice.Pos.ofSlice_le_ofSlice_iff | Init.Data.String.Basic | ∀ {s : String.Slice} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {q r : (s.slice p₀ p₁ h).Pos},
String.Slice.Pos.ofSlice q ≤ String.Slice.Pos.ofSlice r ↔ q ≤ r | null | true |
Mathlib.Tactic.DefEqAbuse._aux_Mathlib_Tactic_DefEqAbuse___elabRules_Mathlib_Tactic_DefEqAbuse_defeqAbuseCmd_1 | Mathlib.Tactic.DefEqAbuse | Lean.Elab.Command.CommandElab | null | false |
_private.Mathlib.GroupTheory.Index.0.Subgroup.finiteIndex_iInf'.match_1_1 | Mathlib.GroupTheory.Index | ∀ {ι : Type u_1} {s : Finset ι} (motive : Subtype (Membership.mem s) → Prop) (x : Subtype (Membership.mem s)),
(∀ (i : ι) (hi : i ∈ s), motive ⟨i, hi⟩) → motive x | null | false |
Std.DTreeMap.keys | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List α | Returns a list of all keys present in the tree map in ascending order. | true |
_private.Mathlib.Algebra.Group.Units.Opposite.0.IsAddUnit.op.match_1_1 | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_1} [inst : AddMonoid M] {m : M} (motive : IsAddUnit m → Prop) (h : IsAddUnit m),
(∀ (u : AddUnits M) (hu : ↑u = m), motive ⋯) → motive h | null | false |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn._sparseCasesOn_4 | Lean.DocString.Parser | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
ULift.divInvMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : DivInvMonoid α], ULift.divInvMonoid = Function.Injective.divInvMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ ⋯ | null | true |
IsInvariantSubfield.mk._flat_ctor | Mathlib.FieldTheory.Fixed | ∀ {M : Type u} [inst : Monoid M] {F : Type v} [inst_1 : Field F] [inst_2 : MulSemiringAction M F] {S : Subfield F},
(∀ (m : M) {x : F}, x ∈ S → m • x ∈ S) → IsInvariantSubfield M S | null | false |
Aesop.LocalRuleSet.mk.sizeOf_spec | Aesop.RuleSet | ∀ (toBaseRuleSet : Aesop.BaseRuleSet) (simpTheoremsArray : Array (Lean.Name × Lean.Meta.SimpTheorems))
(simpTheoremsArrayNonempty : 0 < simpTheoremsArray.size) (simprocsArray : Array (Lean.Name × Lean.Meta.Simprocs))
(simprocsArrayNonempty : 0 < simprocsArray.size) (localNormSimpRules : Array Aesop.LocalNormSimpRul... | null | true |
Matroid.cRk_map_image._auto_1 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | Lean.Syntax | null | false |
VectorAll._unsafe_rec | Mathlib.Data.Vector3 | {α : Type u_1} → (k : ℕ) → (Vector3 α k → Prop) → Prop | null | false |
Std.DTreeMap.Raw.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF →
∀ {k fallback : α},
(t.erase k).isEmpty = false →
¬cmp k (t.minKeyD fallback) = Ordering.eq → (t.erase k).minKeyD fallback = t.minKeyD fallback | null | true |
CategoryTheory.MonoOver.mapIso._proof_5 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : C} (e : A ≅ B) (X : CategoryTheory.MonoOver A),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoOver.map e.hom).map
(((CategoryTheory.MonoOver.mapComp e.hom e.inv).symm ≪≫
CategoryTheory.eqToIso ⋯ ≪≫ Category... | null | false |
pow_nonneg._simp_1 | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} [ZeroLEOneClass M₀] [PosMulMono M₀],
0 ≤ a → ∀ (n : ℕ), (0 ≤ a ^ n) = True | null | false |
Lean.Data.AC.evalList._sparseCasesOn_1.else_eq | Init.Data.AC | ∀ {α : Type u} {motive : List α → Sort u_1} (t : List α) (nil : motive [])
(«else» : Nat.hasNotBit 1 t.ctorIdx → motive t) (h : Nat.hasNotBit 1 t.ctorIdx),
Lean.Data.AC.evalList._sparseCasesOn_1 t nil «else» = «else» h | null | false |
Int.le_of_not_le | Init.Data.Int.Order | ∀ {a b : ℤ}, ¬a ≤ b → b ≤ a | null | true |
Topology.IsLowerSet.WithLowerSetHomeomorph | Mathlib.Topology.Order.UpperLowerSetTopology | {α : Type u_1} →
[inst : Preorder α] → [inst_1 : TopologicalSpace α] → [Topology.IsLowerSet α] → Topology.WithLowerSet α ≃ₜ α | If `α` is equipped with the lower set topology, then it is homeomorphic to `WithLowerSet α`. | true |
ShareCommon.StateFactoryImpl.setFind? | Init.ShareCommon | (self : ShareCommon.StateFactoryImpl) → self.Set → ShareCommon.Object → Option ShareCommon.Object | null | true |
Equiv.Perm.isCycleOn_swap | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {a b : α} [inst : DecidableEq α], a ≠ b → (Equiv.swap a b).IsCycleOn {a, b} | null | true |
IntermediateField.instIsAlgebraicSubtypeMemTop | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {K : Type u} [inst : Field K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L], Algebra.IsAlgebraic (↥⊤) L | null | true |
_private.Batteries.Data.BinaryHeap.Basic.0.Batteries.BinaryHeap.maxChild_gt._proof_1_3 | Batteries.Data.BinaryHeap.Basic | ∀ {α : Type u_1} {sz : ℕ} {a : Vector α sz} {i : Fin sz}, 2 * ↑i + 3 ≤ sz → 2 * ↑i + 2 < sz | null | false |
Mathlib.Tactic.ComputeDegree.natDegree_natCast_le | Mathlib.Tactic.ComputeDegree | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (↑n).natDegree ≤ 0 | null | true |
PresheafOfModules.evaluationJointlyReflectsColimits._proof_2 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Colimits | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat} {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] (F : CategoryTheory.Functor J (PresheafOfModules R))
(c : CategoryTheory.Limits.Cocone F)
(hc : (X : Cᵒᵖ) → CategoryTheory.Limits.IsColimit ((Presh... | null | false |
Specialization.map_id | Mathlib.Topology.Specialization | ∀ {α : Type u_1} [inst : TopologicalSpace α], Specialization.map (ContinuousMap.id α) = OrderHom.id | null | true |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.Const.modify_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | null | false |
CategoryTheory.MorphismProperty.Over.mapPullbackAdj._proof_6 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition] [inst_3 : Q.IsStableUnderBaseChange]
(f : X ⟶ Y) [inst_4 : P.HasPullbacksAlong f] [inst_5 : P.IsStableUnderBaseChangeAlong f] (hPf : ... | null | false |
Matrix.IsSymm.fromBlocks | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {m : Type u_4} {A : Matrix m m α} {B : Matrix m n α} {C : Matrix n m α}
{D : Matrix n n α}, A.IsSymm → B.transpose = C → D.IsSymm → (Matrix.fromBlocks A B C D).IsSymm | A block matrix `A.fromBlocks B C D` is symmetric,
if `A` and `D` are symmetric and `Bᵀ = C`. | true |
Lean.Server.Reference.ci | Lean.Server.References | Lean.Server.Reference → Lean.Elab.ContextInfo | `ContextInfo` at the point of elaboration of this reference. | true |
Mathlib.pp.mathlib.binderPredicates | Mathlib.Util.PPOptions | Lean.Option Bool | The `pp.mathlib.binderPredicates` option is used to control whether mathlib pretty printers
should use binder predicate notation (such as `∀ x < 2, p x`).
| true |
Set.iUnion_comm | Mathlib.Data.Set.Lattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} {ι' : Sort u_5} (s : ι → ι' → Set α), ⋃ i, ⋃ i', s i i' = ⋃ i', ⋃ i, s i i' | null | true |
Mathlib.Tactic.AtomM.Context.mk._flat_ctor | Mathlib.Util.AtomM | Lean.Meta.TransparencyMode → (Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result) → Mathlib.Tactic.AtomM.Context | null | false |
Units.val_eq_neg_one | Mathlib.Algebra.Ring.Units | ∀ {α : Type u} [inst : Monoid α] [inst_1 : HasDistribNeg α] {a : αˣ}, ↑a = -1 ↔ a = -1 | null | true |
_private.Mathlib.Geometry.Euclidean.Sphere.PolePolar.0.EuclideanGeometry.Sphere.polar_eq_orthRadius_self_iff._simp_1_2 | Mathlib.Geometry.Euclidean.Sphere.PolePolar | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.liftWith_trans._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | null | false |
_private.Mathlib.Data.Finset.Lattice.Basic.0.Finset.instDistribLattice._simp_1 | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | null | false |
MulRingNorm.toAddGroupNorm | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → [inst : NonAssocRing R] → MulRingNorm R → AddGroupNorm R | null | true |
nnnorm_apply_le_nnnorm_cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Isometric | Lean.Syntax | null | false |
Algebra.IsInvariant.exists_smul_of_under_eq_of_profinite | Mathlib.RingTheory.Invariant.Profinite | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {G : Type u}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [SMulCommClass G A B] [inst_6 : TopologicalSpace G]
[CompactSpace G] [TotallyDisconnectedSpace G] [IsTopologicalGroup G] [inst_10 : TopologicalSpace B]
... | `G` acts transitively on the prime ideals of `B` above a given prime ideal of `A`. | true |
Algebra.Extension.Hom.mk.inj | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S} {P : Algebra.Extension R S}
{R' : Type u_1} {S' : Type u_2} {inst_3 : CommRing R'} {inst_4 : CommRing S'} {inst_5 : Algebra R' S'}
{P' : Algebra.Extension R' S'} {inst_6 : Algebra R R'} {inst_7 : Algebra S S'} {toRingHom : ... | null | true |
Perfection.coeff_mk | Mathlib.RingTheory.Perfection | ∀ {R : Type u_1} [inst : CommSemiring R] {p : ℕ} [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p] (f : ℕ → R)
(hf : ∀ (n : ℕ), f (n + 1) ^ p = f n) (n : ℕ), (Perfection.coeff R p n) ⟨f, hf⟩ = f n | null | true |
Function.Semiconj.comp_eq | Mathlib.Logic.Function.Conjugate | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {ga : α → α} {gb : β → β}, Function.Semiconj f ga gb → f ∘ ga = gb ∘ f | **Alias** of the forward direction of `Function.semiconj_iff_comp_eq`.
---
Definition of `Function.Semiconj` in terms of functional equality. | true |
Lean.Meta.Simp.Arith.Int.ToLinear.State.varMap._default | Lean.Meta.Tactic.Simp.Arith.Int.Basic | Lean.Meta.KExprMap ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.