name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Operations.0.SimpleGraph.Walk.concatRecAux.match_1.eq_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} (motive : (v : V) → G.Walk u v → Sort u_2)
(h_1 : Unit → motive u SimpleGraph.Walk.nil)
(h_2 : (v v_1 : V) → (h : G.Adj u v_1) → (p : G.Walk v_1 v) → motive v (SimpleGraph.Walk.cons h p)),
(match u, SimpleGraph.Walk.nil with
| .(u), SimpleGraph.Walk.nil => h_1 ()
... | null | true |
Std.DTreeMap.Internal.Const.RiiSliceData.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
{P : Sort u_1} →
{treeMap : Std.DTreeMap.Internal.Impl α fun x => β} →
{range : Std.Rii α} →
{treeMap' : Std.DTreeMap.Internal.Impl α fun x => β} →
{range' : Std.Rii α} →
{ treeMap := treeMap, range := range } = { treeMap := treeMap',... | null | false |
ProbabilityTheory.iIndepFun.indepFun_mul_left | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10}
{m : MeasurableSpace β} [inst : Mul β] [MeasurableMul₂ β] {f : ι → Ω → β},
ProbabilityTheory.iIndepFun f μ →
(∀ (i : ι), Measurable (f i)) → ∀ (i j k : ι), i ≠ k → j ≠ k → ProbabilityTheory.IndepFun (f i * f ... | null | true |
RingCon.instAddMonoidQuotient._proof_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : AddMonoid R] [inst_1 : Mul R] (c : RingCon R) (a b c_1 : c.Quotient),
a + b + c_1 = a + (b + c_1) | null | false |
LowerSet.map | Mathlib.Order.UpperLower.CompleteLattice | {α : Type u_1} → {β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → α ≃o β → LowerSet α ≃o LowerSet β | An order isomorphism of Preorders induces an order isomorphism of their lower sets. | true |
CategoryTheory.ObjectProperty.hasFiniteResolution.map_exactFunctor | Mathlib.CategoryTheory.ObjectProperty.HasFiniteResolution.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P : CategoryTheory.ObjectProperty C} {D : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {Q : CategoryTheory.ObjectProperty D}
(F : CategoryTheo... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Pos.le_sliceTo_iff._simp_1_2 | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ : s.Pos} {p : (s.sliceTo p₀).Pos} {q : s.Pos} {h : q ≤ p₀},
(p₀.sliceTo q h < p) = (q < String.Pos.ofSliceTo p) | null | false |
Set.subsingleton_range_iff._simp_1 | Mathlib.Logic.Function.Const | ∀ {α : Sort u_1} {β : Type u_4} {f : α → β}, (Set.range f).Subsingleton = Function.IsConst f | null | false |
_private.Mathlib.AlgebraicTopology.ModelCategory.Over.0.HomotopicalAlgebra.fibrations_over_iff._simp_1_2 | Mathlib.AlgebraicTopology.ModelCategory.Over | ∀ {T : Type u_3} [inst : CategoryTheory.Category.{v_3, u_3} T] {W : CategoryTheory.MorphismProperty T} {X : T}
{Y Z : CategoryTheory.Over X} (f : Y ⟶ Z), W.over f = W (CategoryTheory.Over.Hom.left f) | null | false |
CategoryTheory.ShortComplex.X₃ | Mathlib.Algebra.Homology.ShortComplex.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] → CategoryTheory.ShortComplex C → C | the third (right) object of a `ShortComplex` | true |
Function.LeftInverse.eq | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {g : β → α} {f : α → β}, Function.LeftInverse g f → ∀ (x : α), g (f x) = x | null | true |
_private.Mathlib.CategoryTheory.Bicategory.Span.Basic.0.CategoryTheory.Span.SpanBicat.instBicategory._proof_65 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
eq_top_or_eq_bot | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : LE α] [inst_1 : BoundedOrder α] [IsSimpleOrder α] (a : α), a = ⊤ ∨ a = ⊥ | null | true |
Aesop.ForwardHypData.mk.inj | Aesop.RuleTac.Forward.Basic | ∀ {depths depths_1 : Std.HashMap Lean.FVarId ℕ}, { depths := depths } = { depths := depths_1 } → depths = depths_1 | null | true |
DirectSum.coe_decompose_mul_of_right_mem_of_le | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddCommMonoid ι]
[inst_3 : PartialOrder ι] [CanonicallyOrderedAdd ι] [inst_5 : SetLike σ A] [inst_6 : AddSubmonoidClass σ A]
(𝒜 : ι → σ) [inst_7 : GradedRing 𝒜] {a b : A} {n i : ι} [inst_8 : Sub ι] [OrderedSub ι]... | null | true |
_private.Mathlib.Data.Ordmap.Ordset.0.Ordnode.adjustWith.match_1.splitter | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} →
(motive : Ordnode α → Sort u_2) →
(x : Ordnode α) →
(Unit → motive Ordnode.nil) →
((sz : ℕ) → (l : Ordnode α) → (y : α) → (r : Ordnode α) → motive (Ordnode.node sz l y r)) → motive x | null | true |
Submodule.toBaseChange_surjective' | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {M : Type u_2} (A : Type u_3) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] (p : Submodule R M) {y : TensorProduct R A M},
y ∈ Submodule.baseChange A p → ∃ x, ↑((Submodule.toBaseChange A p) x) = y | This version enables better pattern matching via the tactic `obtain`. | true |
Subalgebra.topologicalClosure_comap_homeomorph | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u} [inst_1 : TopologicalSpace A] [inst_2 : Semiring A]
[inst_3 : Algebra R A] [inst_4 : IsSemitopologicalSemiring A] (s : Subalgebra R A) {B : Type u_2}
[inst_5 : TopologicalSpace B] [inst_6 : Ring B] [inst_7 : IsSemitopologicalRing B] [inst_8 : Algebra R B]
(f :... | This is really a statement about topological algebra isomorphisms,
but we don't have those, so we use the clunky approach of talking about
an algebra homomorphism, and a separate homeomorphism,
along with a witness that as functions they are the same.
| true |
ScottContinuous.inf₂.match_1 | Mathlib.Order.ScottContinuity.Complete | {β : Type u_1} → (motive : β × β → Sort u_2) → (x : β × β) → ((a b : β) → motive (a, b)) → motive x | null | false |
Set.MapsTo.mem_iff | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β},
Set.MapsTo f s t → Set.MapsTo f sᶜ tᶜ → ∀ {x : α}, f x ∈ t ↔ x ∈ s | null | true |
Convexity.ConvexSpace.AffineMap.instZero | Mathlib.Geometry.Convex.AffineMap.Module | {R : Type u_1} →
{X : Type u_3} →
{M : Type u_4} →
[inst : Semiring R] →
[inst_1 : PartialOrder R] →
[inst_2 : IsStrictOrderedRing R] →
[inst_3 : Convexity.ConvexSpace R X] →
[AddCommMonoid M] → [inst_5 : Convexity.ConvexSpace R M] → Zero (Convexity.ConvexSpace.Af... | null | true |
LinearMap.lflip._proof_1 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R₂ : Type u_1} {S : Type u_5} {S₂ : Type u_6} [inst : Semiring R₂] [inst_1 : Semiring S] [inst_2 : Semiring S₂]
{N : Type u_4} {P : Type u_3} [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P] [inst_5 : Module S N]
[inst_6 : Module R₂ P] [inst_7 : Module S₂ P] [inst_8 : SMulCommClass S₂ R₂ P] {σ₁₂ : S →+* S₂}... | null | false |
Semigrp.hom_inv_apply | Mathlib.Algebra.Category.Semigrp.Basic | ∀ {X Y : Semigrp} (e : X ≅ Y) (s : ↑Y),
(CategoryTheory.ConcreteCategory.hom e.hom) ((CategoryTheory.ConcreteCategory.hom e.inv) s) = s | null | true |
Ideal.Quotient.tower_quotient_map_quotient | Mathlib.RingTheory.Ideal.Over | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {p : Ideal R} [inst_2 : Algebra R S],
IsScalarTower R (R ⧸ p) (S ⧸ Ideal.map (algebraMap R S) p) | null | true |
CategoryTheory.Functor.CoreMonoidal.mk | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
{F : CategoryTheory.Functor C D} →
(εIso :
... | null | true |
Lean.Lsp.RpcConnected.mk.inj | Lean.Data.Lsp.Extra | ∀ {sessionId sessionId_1 : UInt64}, { sessionId := sessionId } = { sessionId := sessionId_1 } → sessionId = sessionId_1 | null | true |
_private.Mathlib.Logic.Function.Iterate.0.Function.iterate_add.match_1_1 | Mathlib.Logic.Function.Iterate | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
_private.Mathlib.MeasureTheory.Measure.Tight.0.MeasureTheory.IsTightMeasureSet.map._simp_1_5 | Mathlib.MeasureTheory.Measure.Tight | ∀ {α : Type u_1} {s t : Set α}, (sᶜ ⊆ tᶜ) = (t ⊆ s) | null | false |
Lean.Elab.PartialTermInfo.toElabInfo | Lean.Elab.InfoTree.Types | Lean.Elab.PartialTermInfo → Lean.Elab.ElabInfo | null | true |
AddCommute.zero_left | Mathlib.Algebra.Group.Commute.Defs | ∀ {M : Type u_2} [inst : AddZeroClass M] (a : M), AddCommute 0 a | null | true |
_aux_Mathlib_LinearAlgebra_SModEq_Basic___unexpand_SModEq_1 | Mathlib.LinearAlgebra.SModEq.Basic | Lean.PrettyPrinter.Unexpander | null | false |
Tactic.ReduceModChar.TypeToCharPResult.ctorElim | Mathlib.Tactic.ReduceModChar | {u : Lean.Level} →
{α : Q(Type u)} →
{motive : Tactic.ReduceModChar.TypeToCharPResult α → Sort u} →
(ctorIdx : ℕ) →
(t : Tactic.ReduceModChar.TypeToCharPResult α) →
ctorIdx = t.ctorIdx → Tactic.ReduceModChar.TypeToCharPResult.ctorElimType ctorIdx → motive t | null | false |
CommRingCat | Mathlib.Algebra.Category.Ring.Basic | Type (u + 1) | The category of commutative rings. | true |
Mathlib.Tactic.Find.«_aux_Mathlib_Tactic_Find___elabRules_Mathlib_Tactic_Find_command#find__1» | Mathlib.Tactic.Find | Lean.Elab.Command.CommandElab | `#find t` finds definitions and theorems whose result type matches the term `t`, and prints them as
info lines. Use holes in `t` to indicate arbitrary subexpressions, for example `#find _ ∧ _` will
match any conjunction.
`#find` is also available as a tactic, and there is also the `find` tactic which looks for lemmas
... | false |
Std.Internal.instInhabitedIndexMultiMap | Std.Http.Internal.IndexMultiMap | {α : Type u_1} →
{β : Type u_2} →
[inst : BEq α] → [inst_1 : Hashable α] → [Inhabited α] → [Inhabited β] → Inhabited (Std.Internal.IndexMultiMap α β) | null | true |
_private.Mathlib.Data.Nat.Multiplicity.0.Nat.Prime.emultiplicity_choose_prime_pow_add_emultiplicity._simp_1_1 | Mathlib.Data.Nat.Multiplicity | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ t → a ∉ s | null | false |
AffineEquiv.toAffineMap_injective | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_1} {P₁ : Type u_2} {P₂ : Type u_3} {V₁ : Type u_6} {V₂ : Type u_7} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂], Function.Injective AffineEquiv.toAffineMap | null | true |
Computation.Bind.f.match_1 | Mathlib.Data.Seq.Computation | {α : Type u_1} →
{β : Type u_2} →
(motive : Computation α ⊕ Computation β → Sort u_3) →
(x : Computation α ⊕ Computation β) →
((ca : Computation α) → motive (Sum.inl ca)) → ((cb : Computation β) → motive (Sum.inr cb)) → motive x | null | false |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesEIso._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | null | false |
Std.ExtTreeSet.minD_empty | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {fallback : α}, ∅.minD fallback = fallback | null | true |
RatFunc.CompletionAtInfty.instField._proof_19 | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (a : RatFunc.CompletionAtInfty F), a * 1 = a | null | false |
HahnSeries.instSMulZeroClass | Mathlib.RingTheory.HahnSeries.Addition | {Γ : Type u_1} →
{R : Type u_3} →
[inst : PartialOrder Γ] →
{V : Type u_8} → [inst_1 : Zero V] → [SMulZeroClass R V] → SMulZeroClass R (HahnSeries Γ V) | null | true |
birkhoffAverage_apply_sub_birkhoffAverage | Mathlib.Dynamics.BirkhoffSum.Average | ∀ {R : Type u_1} {α : Type u_2} {M : Type u_3} [inst : DivisionSemiring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] (f : α → α) (g : α → M) (n : ℕ) (x : α),
birkhoffAverage R f g n (f x) - birkhoffAverage R f g n x = (↑n)⁻¹ • (g (f^[n] x) - g x) | Birkhoff average is "almost invariant" under `f`:
the difference between `birkhoffAverage R f g n (f x)` and `birkhoffAverage R f g n x`
is equal to `(n : R)⁻¹ • (g (f^[n] x) - g x)`. | true |
String.Slice.skipPrefix?_string_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s : String.Slice} {pos : s.Pos}, s.skipPrefix? pat = some pos ↔ ∃ t, pos.Splits pat t | null | true |
Representation.IntertwiningMap.instAddCommMonoid._proof_6 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : Module A V] [inst_5 : Module A W]
(ρ : Representation A G V) (σ : Representation A G W),
autoParam (∀ (n : ℕ) (x : ρ.IntertwiningMap σ), (n + 1) • x... | null | false |
Partrec.optionCasesOn_right | Mathlib.Computability.Partrec | ∀ {α : Type u_1} {β : Type u_2} {σ : Type u_4} [inst : Primcodable α] [inst_1 : Primcodable β] [inst_2 : Primcodable σ]
{o : α → Option β} {f : α → σ} {g : α → β →. σ},
Computable o → Computable f → Partrec₂ g → Partrec fun a => Option.casesOn (o a) (Part.some (f a)) (g a) | null | true |
Lean.InductiveVal.ctors | Lean.Declaration | Lean.InductiveVal → List Lean.Name | List of the names of the constructors for this inductive datatype. | true |
Std.Http.Protocol.H1.Config.maxHeaderNameLength._default | Std.Http.Protocol.H1.Config | ℕ | null | false |
Lean.Elab.Term.UseImplicitLambdaResult.yes.inj | Lean.Elab.Term.TermElabM | ∀ {expectedType expectedType_1 : Lean.Expr},
Lean.Elab.Term.UseImplicitLambdaResult.yes expectedType = Lean.Elab.Term.UseImplicitLambdaResult.yes expectedType_1 →
expectedType = expectedType_1 | null | true |
RightDerivMeasurableAux.B | Mathlib.Analysis.Calculus.FDeriv.Measurable | {F : Type u_1} → [inst : NormedAddCommGroup F] → [NormedSpace ℝ F] → (ℝ → F) → Set F → ℝ → ℝ → ℝ → Set ℝ | The set `B f K r s ε` is the set of points `x` around which there exists a vector
`L` belonging to `K` (a given set of vectors) such that `h • L` approximates well `f (x + h)`
(up to an error `ε`), simultaneously at scales `r` and `s`. | true |
Finset.mem_mul | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α} {x : α},
x ∈ s * t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.const._unsafe_rec | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | (basis : Tactic.ComputeAsymptotics.Basis) → ℝ → Tactic.ComputeAsymptotics.MultiseriesExpansion basis | null | false |
Lean.Lsp.WorkspaceEdit._sizeOf_1 | Lean.Data.Lsp.Basic | Lean.Lsp.WorkspaceEdit → ℕ | null | false |
Filter.limsSup_top | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} [inst : CompleteLattice α], ⊤.limsSup = ⊤ | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.radical_sup | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData}, (I ⊔ J).radical = (I.radical ⊔ J.radical).radical | null | true |
AffineSubspace.sOppSide_pointReflection | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y : P}, x ∈ s → y ∉ s → s.SOppSide y ((AffineEquiv.pointReflection R x) y) | null | true |
CommGrpCat.ctorIdx | Mathlib.Algebra.Category.Grp.Basic | CommGrpCat → ℕ | null | false |
UInt8.mul_def | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), a * b = { toBitVec := a.toBitVec * b.toBitVec } | null | true |
Matrix.toLinearEquiv'_symm_apply | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {n : Type u_1} [inst : Fintype n] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : DecidableEq n] (P : Matrix n n R)
(h : Invertible P), ↑(P.toLinearEquiv' h).symm = Matrix.toLin' ⅟P | null | true |
_private.Mathlib.RingTheory.Polynomial.IsIntegral.0.IsIntegral.coeff._proof_1_2 | Mathlib.RingTheory.Polynomial.IsIntegral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (x : Polynomial R)
(x_1 : Polynomial S),
(Polynomial.mapRingHom (algebraMap R S)) x * x_1 = x_1 * (Polynomial.mapRingHom (algebraMap R S)) x | null | false |
AddMonoidHom.add._proof_1 | Mathlib.Algebra.Group.Hom.Basic | ∀ {M : Type u_2} {N : Type u_1} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] (f g : M →+ N), f 0 + g 0 = 0 | null | false |
Lean.Meta.Sym.BackwardRule.expr | Lean.Meta.Sym.Apply | Lean.Meta.Sym.BackwardRule → Lean.Expr | The theorem used to create the rule. It is often of the form `Expr.const declName`. | true |
Computation.LiftRel.symm | Mathlib.Data.Seq.Computation | ∀ {α : Type u} (R : α → α → Prop) [Std.Symm R], Std.Symm (Computation.LiftRel R) | null | true |
MeasureTheory.Measure.nullMeasurable_comp_snd | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β}
[hν : MeasureTheory.SFinite ν] [NeZero μ] {f : β → γ},
MeasureTheory.NullMeasurable (f ∘ Prod.snd) (μ.prod ν) ↔ MeasureThe... | null | true |
Set.inter_mul_union_subset_union | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Mul α] {s₁ s₂ t₁ t₂ : Set α}, s₁ ∩ s₂ * (t₁ ∪ t₂) ⊆ s₁ * t₁ ∪ s₂ * t₂ | null | true |
UInt64.toUSize_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin UInt64.size), (UInt64.ofFin n).toUSize = USize.ofNat ↑n | null | true |
WithZero.map'_comp | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MulOneClass α] [inst_1 : MulOneClass β] [inst_2 : MulOneClass γ]
(f : α →* β) (g : β →* γ), WithZero.map' (g.comp f) = (WithZero.map' g).comp (WithZero.map' f) | null | true |
Filter.disjoint_prod | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β} {f' : Filter α} {g' : Filter β},
Disjoint (f ×ˢ g) (f' ×ˢ g') ↔ Disjoint f f' ∨ Disjoint g g' | null | true |
GaloisConnection.u_eq_top | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : OrderTop α] {l : α → β} {u : β → α},
GaloisConnection l u → ∀ {x : β}, u x = ⊤ ↔ l ⊤ ≤ x | null | true |
CommHopfAlgCat.isoEquivBialgEquiv._proof_2 | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u_1} [inst : CommRing R] {X Y : Type u_2} [inst_1 : CommRing X] [inst_2 : HopfAlgebra R X]
[inst_3 : CommRing Y] [inst_4 : HopfAlgebra R Y] (x : X ≃ₐc[R] Y),
CommHopfAlgCat.ofIso (CommHopfAlgCat.isoMk x) = CommHopfAlgCat.ofIso (CommHopfAlgCat.isoMk x) | null | false |
instDistribPNat | Mathlib.Data.PNat.Basic | Distrib ℕ+ | null | true |
_private.Lean.Compiler.LCNF.SpecInfo.0.Lean.Compiler.LCNF.isWeakSpecType._f | Lean.Compiler.LCNF.SpecInfo | Lean.Environment → (type : Lean.Expr) → Lean.Expr.below type → Bool | null | false |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.isFullyInvariant_iff_le_imp_isotypicComponent_le.match_1_5 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (S S' : Submodule R M)
(e : ↥S' ≃ₗ[R] ↥S) (motive : (∃ h, h ∘ₗ S.subtype = S'.subtype ∘ₗ ↑e.symm) → Prop)
(x : ∃ h, h ∘ₗ S.subtype = S'.subtype ∘ₗ ↑e.symm),
(∀ (p : M →ₗ[R] M) (eq : p ∘ₗ S.subtype = S'.subtype ∘ₗ ↑e.sy... | null | false |
Lean.Parser.Command.structFields.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
Representation.mem_invariants_iff_of_forall_mem_zpowers | Mathlib.RepresentationTheory.Invariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] (ρ : Representation k G V) (g : G),
(∀ (x : G), x ∈ Subgroup.zpowers g) → ∀ (x : V), x ∈ ρ.invariants ↔ (ρ g) x = x | null | true |
Lean.Grind.CommRing.Poly.combine.go.eq_def | Init.Grind.Ring.CommSolver | ∀ (fuel : ℕ) (p₁ p₂ : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.combine.go fuel p₁ p₂ =
match fuel with
| 0 => p₁.concat p₂
| fuel.succ =>
match p₁, p₂ with
| Lean.Grind.CommRing.Poly.num k₁, Lean.Grind.CommRing.Poly.num k₂ => Lean.Grind.CommRing.Poly.num (k₁ + k₂)
| Lean.Grind... | null | true |
Mathlib.Tactic.IntervalCases.Methods.bisect | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods →
Lean.MVarId →
Subarray Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal →
Mathlib.Tactic.IntervalCases.Bound →
Mathlib.Tactic.IntervalCases.Bound → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Unit | Given `(z1, e1, p1)` a lower bound on `e` and `(z2, e2, p2)` an upper bound on `e`, such that the
distance between the bounds matches the number of `cases` in the subarray (which must be positive),
proves the goal `g` using the metavariables in the array by recursive bisection.
This is the core of the tactic, producing... | true |
CategoryTheory.finCategoryOpposite | Mathlib.CategoryTheory.FinCategory.Basic | {J : Type v} → [inst : CategoryTheory.SmallCategory J] → [CategoryTheory.FinCategory J] → CategoryTheory.FinCategory Jᵒᵖ | The opposite of a finite category is finite.
| true |
Mathlib.Tactic.rflTac | Mathlib.Tactic.Relation.Rfl | Lean.Elab.Tactic.TacticM Unit | This tactic applies to a goal whose target has the form `x ~ x`, where `~` is a reflexive
relation, that is, a relation which has a reflexive lemma tagged with the attribute `@[refl]`.
| true |
CategoryTheory.Abelian.Ext.comp._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {a b c : ℕ}, a + b = c → ↑b + ↑a = ↑c | null | false |
IsCompact.lt_sInf_iff_of_continuous | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} {β : Type u_3} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α]
[inst_2 : TopologicalSpace β] [ClosedIicTopology α] {f : β → α} {K : Set β},
IsCompact K → K.Nonempty → ContinuousOn f K → ∀ (y : α), y < sInf (f '' K) ↔ ∀ x ∈ K, y < f x | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_6 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {newWidth : ℕ}, ∀ curr ≤ newWidth, ¬curr < newWidth → curr = newWidth | null | false |
VAddAssocClass.opposite_mid | Mathlib.Algebra.Group.Action.Opposite | ∀ {M : Type u_5} {N : Type u_6} [inst : Add N] [inst_1 : VAdd M N] [VAddCommClass M N N], VAddAssocClass M Nᵃᵒᵖ N | null | true |
AlgCat.intEquivalence_inverse_obj | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (A : RingCat), AlgCat.intEquivalence.inverse.obj A = ↧↑A | null | true |
znumCoe | Mathlib.Data.Num.Basic | {α : Type u_1} → [Zero α] → [One α] → [Add α] → [Neg α] → CoeHTCT ZNum α | null | true |
Vector.countP_toList | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {p : α → Bool} {xs : Vector α n}, List.countP p xs.toList = Vector.countP p xs | null | true |
CStarMatrix.add_mul | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {l : Type u_7} [inst : Fintype m] [inst_1 : NonUnitalNonAssocSemiring A]
(L M : CStarMatrix l m A) (N : CStarMatrix m n A), (L + M) * N = L * N + M * N | null | true |
MonoidAlgebra.instFree | Mathlib.LinearAlgebra.Finsupp.VectorSpace | ∀ {M : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
[Module.Free R S], Module.Free R (MonoidAlgebra S M) | null | true |
CategoryTheory.IndParallelPairPresentation | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{A B : CategoryTheory.Functor Cᵒᵖ (Type v₁)} → (A ⟶ B) → (A ⟶ B) → Type (max u₁ (v₁ + 1)) | Structure containing data exhibiting two parallel natural transformations `f` and `g` between
presheaves `A` and `B` as induced by a natural transformation in a functor category exhibiting
`A` and `B` as ind-objects. | true |
_private.Lean.Expr.0.Lean.Expr.isLet.match_1 | Lean.Expr | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool) → motive (Lean.Expr.letE declName type value body nondep)) →
((x : Lean.Expr) → motive x) → motive x | null | false |
ProfiniteGrp.instHasForget₂ContinuousMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : ProfiniteGrp.{u_1}} (f : X ⟶ Y), Continuous ⇑(ProfiniteGrp.Hom.hom f) | null | false |
_private.Mathlib.Analysis.MeanInequalities.0.ENNReal.inner_le_weight_mul_Lp_of_nonneg._simp_1_4 | Mathlib.Analysis.MeanInequalities | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
CategoryTheory.Functor.WellOrderInductionData.lift | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | {J : Type u} →
[inst : LinearOrder J] →
[inst_1 : SuccOrder J] →
{F : CategoryTheory.Functor Jᵒᵖ (Type v)} →
F.WellOrderInductionData →
(j : J) → Order.IsSuccLimit j → ↑(⋯.functor.op.comp F).sections → F.obj (Opposite.op j) | When `j` is a limit element, and `x` is a compatible family of elements
in `F.obj (op i)` for all `i < j`, this is a lifting to `F.obj (op j)`. | true |
AList | Mathlib.Data.List.AList | {α : Type u} → (α → Type v) → Type (max u v) | `AList β` is a key-value map stored as a `List` (i.e. a linked list).
It is a wrapper around certain `List` functions with the added constraint
that the list have unique keys. | true |
_private.Lean.Parser.Basic.0.Lean.Parser.strAux.parse._unsafe_rec | Lean.Parser.Basic | String → String → String.Pos.Raw → Lean.Parser.ParserContext → Lean.Parser.ParserState → Lean.Parser.ParserState | null | false |
Int.toArray_rcc_ne_empty_iff | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, (m...=n).toArray ≠ #[] ↔ m ≤ n | null | true |
Std.Time.TimeZone.ZoneRules.mk._flat_ctor | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.LocalTimeType →
Array Std.Time.TimeZone.Transition → Option Std.Time.TimeZone.RecurringRule → Std.Time.TimeZone.ZoneRules | null | false |
Encodable.encodeSubtype | Mathlib.Logic.Encodable.Basic | {α : Type u_1} → {P : α → Prop} → [encA : Encodable α] → { a // P a } → ℕ | Explicit encoding function for a decidable subtype of an encodable type | true |
Float.instDecidableEqModel | Init.Data.Float.Model.Float | DecidableEq Float.Model | null | true |
_private.Batteries.Lean.Meta.UnusedNames.0.Lean.LocalContext.getUnusedUserNameIndex.match_1 | Batteries.Lean.Meta.UnusedNames | (motive : Lean.Name.MatchUpToIndexSuffix → Sort u_1) →
(x : Lean.Name.MatchUpToIndexSuffix) →
(Unit → motive Lean.Name.MatchUpToIndexSuffix.exactMatch) →
(Unit → motive Lean.Name.MatchUpToIndexSuffix.noMatch) →
((i : ℕ) → motive (Lean.Name.MatchUpToIndexSuffix.suffixMatch i)) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.