name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
FunLike.addCommGroup._proof_5 | Mathlib.Algebra.Group.FunLike | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : FunLike F α β] [inst_1 : SMul ℕ F] [inst_2 : AddCommGroup β]
[IsSMulApply ℕ F α β] (f : F) (n : ℕ), ⇑(n • f) = n • ⇑f | null | false |
Lean.Meta.Simp.SimprocQ | Qq.Simp | Type | A copy of `Lean.Meta.Simproc` with explicit types.
See `Simproc.ofQ` to construct terms of this type. | true |
DirectLimit.Ring.hom_ext | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_2} [inst : Preorder ι] {G : ι → Type u_3} {T : ⦃i j : ι⦄ → i ≤ j → Type u_6}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι]
[inst_4 : (i : ι) → NonAssocSemir... | null | true |
MonoidAlgebra.tensorEquiv_symm_single_eq_tmul_single_one | Mathlib.RingTheory.TensorProduct.MonoidAlgebra | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] (mn : M × N) (r : R),
(MonoidAlgebra.tensorEquiv R).symm (MonoidAlgebra.single mn r) =
MonoidAlgebra.single mn.1 r ⊗ₜ[R] MonoidAlgebra.single mn.2 1 | null | true |
MeasureTheory.Submartingale.stoppedAbove | Mathlib.Probability.Martingale.BorelCantelli | ∀ {Ω : Type u_2} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ℱ : MeasureTheory.Filtration ℕ m0}
{f : ℕ → Ω → ℝ} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.Submartingale f ℱ μ → ∀ (r : ℝ), MeasureTheory.Submartingale (MeasureTheory.stoppedAbove f r) ℱ μ | null | true |
CategoryTheory.MorphismProperty.HasPullbacksAlong.hasPullback | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.MorphismProperty C} {X Y : C} {f : X ⟶ Y}
[self : P.HasPullbacksAlong f] {W : C} (g : W ⟶ Y), P g → CategoryTheory.Limits.HasPullback g f | null | true |
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabStrLit.match_1 | Lean.Elab.BuiltinTerm | (motive : Option String → Sort u_1) →
(x : Option String) → ((val : String) → motive (some val)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.one_ascFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | null | false |
CategoryTheory.InitiallySmall.instCategoryCofilteredInitialModel | Mathlib.CategoryTheory.Filtered.FinallySmall | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.IsCofiltered C] →
[inst_2 : CategoryTheory.LocallySmall.{w, v, u} C] →
[inst_3 : CategoryTheory.InitiallySmall C] →
CategoryTheory.Category.{w, w} (CategoryTheory.InitiallySmall.CofilteredInitialModel C) | null | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_13 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α},
¬-1 * ↑i + ↑a.size ≤ 0 →
¬↑i + -1 * ↑(min j (a ++ b).size) ≤ 0 →
((a ++ b).extract i j).size = (a.extract i j).size →
∀ (w : ℕ), w + 1 ≤ ((a ++ b).extract i j).size → w < (a.extract i j).size | null | false |
finSuccEquiv'_symm_coe_below | Mathlib.Logic.Equiv.Fin.Basic | ∀ {n : ℕ} {i : Fin (n + 1)} {m : Fin n}, m.castSucc < i → (finSuccEquiv' i).symm (some m) = m.castSucc | null | true |
IsValuativeTopology.continuous_valuation_of_surjective | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {K : Type u_2} {Γ₀ : Type u_3} [inst : DivisionRing K] [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
(v : Valuation K Γ₀) [inst_2 : ValuativeRel K] [inst_3 : TopologicalSpace K] [IsValuativeTopology K] [v.Compatible],
Function.Surjective ⇑v → Continuous ⇑v | null | true |
Algebra.Generators.H1Cotangent.δ | Mathlib.RingTheory.Kaehler.JacobiZariski | {R : Type u₁} →
{S : Type u₂} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{T : Type u₃} →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
[inst_5 : Algebra S T] →
[IsScalarTower R S T] →
... | The connecting homomorphism in the Jacobi-Zariski sequence for given presentations.
Given representations `0 → I → R[X] → S → 0` and `0 → K → S[Y] → T → 0`,
we may consider the induced representation `0 → J → R[X, Y] → T → 0`,
and this map is obtained by applying snake lemma to the following diagram
```
T ⊗[S] Ω[S/... | true |
Option.map_min | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} [inst : Min α] [inst_1 : Min β] {o o' : Option α} {f : α → β},
(∀ (x y : α), f (x ⊓ y) = f x ⊓ f y) → Option.map f (o ⊓ o') = Option.map f o ⊓ Option.map f o' | null | true |
Ideal.quotientMap.eq_1 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u} [inst : Ring R] {S : Type v} [inst_1 : Ring S] {I : Ideal R} (J : Ideal S) [inst_2 : I.IsTwoSided]
[inst_3 : J.IsTwoSided] (f : R →+* S) (hIJ : I ≤ Ideal.comap f J),
Ideal.quotientMap J f hIJ = Ideal.Quotient.lift I ((Ideal.Quotient.mk J).comp f) ⋯ | null | true |
_private.Mathlib.Algebra.Lie.Basis.Base.0.LieAlgebra.Basis.root_mem_or_mem_neg._simp_1_7 | Mathlib.Algebra.Lie.Basis.Base | ∀ {R : Type u_2} {L : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [inst_8 : LieModule.LinearWeights R L M] {χ : LieModule.Weight R ... | null | false |
TopHom.map_top' | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_6} {β : Type u_7} [inst : Top α] [inst_1 : Top β] (self : TopHom α β), self.toFun ⊤ = ⊤ | The function preserves the top element. The preferred spelling is `map_top`. | true |
inf_lt_right | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b : α}, a ⊓ b < b ↔ ¬b ≤ a | null | true |
WellFoundedGT.max.eq_1 | Mathlib.Order.WellFounded | ∀ {α : Type u_1} [inst : LT α] [inst_1 : WellFoundedGT α] (s : Set α) (h : s.Nonempty),
WellFoundedGT.max s h = ⋯.min s h | null | true |
Mathlib.Tactic.RingNF.Config._sizeOf_inst | Mathlib.Tactic.Ring.RingNF | SizeOf Mathlib.Tactic.RingNF.Config | null | false |
Action.forget_ε | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} V] (G : Type u_2) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V],
CategoryTheory.Functor.LaxMonoidal.ε (Action.forget V G) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorUnit V) | null | true |
Representation.LinearizeMonoidal.η._proof_1 | Mathlib.RepresentationTheory.Action | ∀ (k : Type u_1) (G : Type u_2) [inst : Monoid G] [inst_1 : Semiring k] (g : G),
↑(MonoidAlgebra.uniqueLinearEquiv k PUnit.{u_1 + 1}) ∘ₗ
(Representation.linearize k G (CategoryTheory.MonoidalCategoryStruct.tensorUnit (Action (Type u_1) G))) g =
(Representation.trivial k G k) g ∘ₗ ↑(MonoidAlgebra.uniqueLinea... | null | false |
Irrational.ne_one | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, Irrational x → x ≠ 1 | null | true |
forall_imp_iff_exists_imp | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_3} {p : α → Prop} {b : Prop} [ha : Nonempty α], (∀ (x : α), p x) → b ↔ ∃ x, p x → b | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minView.match_1.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' : Std.DTreeMap.Internal.Impl α β)
(motive : Std.DTreeMap.Internal.Impl.View α β (l'.size + r'.size) → Sort u_3) (dk : α) (dv : β dk)
(dt : Std.DTreeMap.Internal.Impl α β) (hdt : dt.Balanced) (hdt' : dt.size = l'.size + r'.size)
(h_1 :
(dk : α) →
(dv : β dk) →
... | null | true |
PMF.support_uniformOfFintype | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {s : Finset α} {a : α},
a ∈ s → (MeasureTheory.Measure.uniformOfFinset s) {a} = (↑s.card)⁻¹ | **Alias** of `MeasureTheory.Measure.uniformOfFinset_apply_singleton_of_mem`. | true |
Mathlib.Tactic.BicategoryLike.Mor₂Iso._sizeOf_inst | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | SizeOf Mathlib.Tactic.BicategoryLike.Mor₂Iso | null | false |
CommGrpCat.Forget₂.createsLimit.eq_1 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] (F : CategoryTheory.Functor J CommGrpCat),
CommGrpCat.Forget₂.createsLimit F =
CategoryTheory.createsLimitOfReflectsIso fun c hc =>
have this := ⋯;
have this := ⋯;
have this_1 := this;
have this_2 := this_1;
{
liftedCon... | null | true |
CategoryTheory.NatTrans.PullbackShift.natIsoId.eq_1 | Mathlib.CategoryTheory.Shift.Pullback | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B),
CategoryTheory.NatTrans.PullbackShift.natIsoId C φ =
CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.... | null | true |
NormedAddGroupHom.norm_id_le | Mathlib.Analysis.Normed.Group.Hom | ∀ (V : Type u_1) [inst : SeminormedAddCommGroup V], ‖NormedAddGroupHom.id V‖ ≤ 1 | The norm of the identity is at most `1`. It is in fact `1`, except when the norm of every
element vanishes, where it is `0`. (Since we are working with seminorms this can happen even if the
space is non-trivial.) It means that one cannot do better than an inequality in general. | true |
SimpleGraph.not_isDiag_of_mem_edgeSet | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {e : Sym2 V}, e ∈ G.edgeSet → ¬e.IsDiag | null | true |
Array.append_inj_left | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs₁ xs₂ ys₁ ys₂ : Array α}, xs₁ ++ ys₁ = xs₂ ++ ys₂ → xs₁.size = xs₂.size → xs₁ = xs₂ | null | true |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_limsup._simp_1_6 | Mathlib.Order.Filter.ENNReal | ∀ {q : NNReal}, (0 ≤ ↑q) = True | null | false |
MeasureTheory.exists_isSigmaFiniteSet_measure_ge | Mathlib.MeasureTheory.Measure.Decomposition.Exhaustion | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure ν] (n : ℕ),
∃ t,
MeasurableSet t ∧
MeasureTheory.SigmaFinite (μ.restrict t) ∧
(⨆ s, ⨆ (_ : MeasurableSet s), ⨆ (_ : MeasureTheory.SigmaFinite (μ.restrict s)), ν s) - 1 / ↑n ≤ ν t | Let `C` be the supremum of `ν s` over all measurable sets `s` such that `μ.restrict s` is
sigma-finite. `C` is finite since `ν` is a finite measure. Then there exists a measurable set `t`
with `μ.restrict t` sigma-finite such that `ν t ≥ C - 1/n`. | true |
List.take_modify | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i j : ℕ) (l : List α), List.take j (l.modify i f) = (List.take j l).modify i f | null | true |
Subring.prod_top | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (s : Subring R),
s.prod ⊤ = Subring.comap (RingHom.fst R S) s | null | true |
RestrictedProduct.instRingCoeOfSubringClass._proof_10 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Ring (R i)] [inst_2 : ∀ (i : ι), SubringClass (S i) (R i)], ⇑0 = ⇑0 | null | false |
CategoryTheory.Arrow.homMk._auto_1 | Mathlib.CategoryTheory.Comma.Arrow | Lean.Syntax | null | false |
addOrderOf.eq_1 | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] (x : G), addOrderOf x = Function.minimalPeriod (fun x_1 => x + x_1) 0 | null | true |
AffineSubspace.setOf_sSameSide_eq_image2 | 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 p : P},
x ∉ s → p ∈ s → {y | s.SSameSide x y} = Set.image2 (fun t q => t • (x -ᵥ p) +ᵥ q) (... | **Alias** of `AffineSubspace.setOfPred_sSameSide_eq_image2`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Lean.Server.instRpcEncodableOption | Lean.Server.Rpc.Basic | {α : Type} → [Lean.Server.RpcEncodable α] → Lean.Server.RpcEncodable (Option α) | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_142 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
QuotientAddGroup.quotientKerEquivOfRightInverse._proof_2 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H : Type u_2} [inst_1 : AddGroup H] (φ : G →+ H) (ψ : H → G),
Function.RightInverse ψ ⇑φ → ∀ (x : G ⧸ φ.ker), (QuotientAddGroup.mk ∘ ψ) ((QuotientAddGroup.kerLift φ) x) = x | null | false |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.instToMessageDataNewDecl.match_1 | Lean.Meta.IndPredBelow | (motive : Lean.Meta.IndPredBelow.NewDecl✝ → Sort u_1) →
(x : Lean.Meta.IndPredBelow.NewDecl✝) →
((decl : Lean.LocalDecl) →
(indName : Lean.Name) →
(vars : Array Lean.FVarId) → motive (Lean.Meta.IndPredBelow.NewDecl.below✝ decl indName vars)) →
((decl : Lean.LocalDecl) →
(idx : ℕ)... | null | false |
Simps.Config.rhsMd._default | Mathlib.Tactic.Simps.Basic | Lean.Meta.TransparencyMode | null | false |
MulOpposite.instIsCancelMulZero | Mathlib.Algebra.GroupWithZero.Opposite | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Zero α] [IsCancelMulZero α], IsCancelMulZero αᵐᵒᵖ | null | true |
instInhabitedInt32 | Init.Data.SInt.Basic | Inhabited Int32 | null | true |
Std.Legacy.Range.«term[:_:_]» | Init.Data.Range.Basic | Lean.ParserDescr | null | true |
ENat.LEInfty.casesOn | Mathlib.Geometry.Manifold.IsManifold.Basic | {m : WithTop ℕ∞} → {motive : ENat.LEInfty m → Sort u} → (t : ENat.LEInfty m) → ((out : m ≤ ↑⊤) → motive ⋯) → motive t | null | false |
AlgHom.instMulWithConv._proof_3 | Mathlib.RingTheory.Bialgebra.Convolution | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
IsScalarTower R R A | null | false |
ZMod.exists_sq_eq_prime_iff_of_mod_four_eq_one | Mathlib.NumberTheory.LegendreSymbol.QuadraticReciprocity | ∀ {p q : ℕ} [inst : Fact (Nat.Prime p)] [inst_1 : Fact (Nat.Prime q)], p % 4 = 1 → q ≠ 2 → (IsSquare ↑q ↔ IsSquare ↑p) | If `p` and `q` are odd primes and `p % 4 = 1`, then `q` is a square mod `p` iff
`p` is a square mod `q`. | true |
CategoryTheory.Under.homMk_eta | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {X : T} {U V : CategoryTheory.Under X} (f : U ⟶ V)
(h : CategoryTheory.CategoryStruct.comp U.hom (CategoryTheory.Under.Hom.right f) = V.hom),
CategoryTheory.Under.homMk (CategoryTheory.Under.Hom.right f) h = f | null | true |
CategoryTheory.sheafHom'Iso | Mathlib.CategoryTheory.Sites.SheafHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
(F G : CategoryTheory.Sheaf J A) → CategoryTheory.sheafHom' F G ≅ CategoryTheory.presheafHom F.obj G.obj | The canonical isomorphism `sheafHom' F G ≅ presheafHom F.1 G.1`. | true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.instIteratorIdSearchStep.match_1.eq_1 | Init.Data.String.Pattern.String | ∀ (s : String.Slice) (motive : String.Slice.Pattern.ForwardSliceSearcher s → Sort u_1) (pos : s.Pos)
(h_1 : (pos : s.Pos) → motive (String.Slice.Pattern.ForwardSliceSearcher.emptyBefore pos))
(h_2 : (pos : s.Pos) → (h : pos ≠ s.endPos) → motive (String.Slice.Pattern.ForwardSliceSearcher.emptyAt pos h))
(h_3 :
... | null | true |
Lean.Grind.AC.Expr.denote_toSeq | Init.Grind.AC | ∀ {α : Sort u_1} (ctx : Lean.Grind.AC.Context α) {x : Std.Associative ctx.op} (e : Lean.Grind.AC.Expr),
Lean.Grind.AC.Seq.denote ctx e.toSeq = Lean.Grind.AC.Expr.denote ctx e | null | true |
CategoryTheory.InducedCategory.homMk | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → (F X ⟶ F Y) → (X ⟶ Y) | Construct a morphism in the induced category
from a morphism in the original category. | true |
Lean.Meta.Grind.EMatchDiagInfo.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.EMatchDiagInfo → Sort u} →
(t : Lean.Meta.Grind.EMatchDiagInfo) →
((lctx : Lean.LocalContext) →
(sources : List Lean.Meta.Grind.EMatchDiagNode) →
(target : Lean.Meta.Grind.EMatchDiagNode) → motive { lctx := lctx, sources := sources, target := target }) →
motive t | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go.eq_def | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (val : BitVec w) (curr : ℕ)
(s : aig.RefVec curr) (hcurr : curr ≤ w),
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go aig val curr s hcurr =
if hcurr : curr < w then
have bitRef := aig.mkConstCached (val.getLsbD curr... | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.addRecAux._f | Init.Data.BitVec.Bitblast | {l w : ℕ} → BitVec (l * w) → (rem : ℕ) → Nat.below (motive := fun rem => BitVec w → BitVec w) rem → BitVec w → BitVec w | null | false |
AffineSubspace.affineSpan_pair_parallel_iff_vectorSpan_eq | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {p₁ p₂ p₃ p₄ : P},
line[k, p₁, p₂].Parallel line[k, p₃, p₄] ↔ vectorSpan k {p₁, p₂} = vectorSpan k {p₃, p₄} | null | true |
IsLprojection.instLatticeSubtypeOfFaithfulSMul._proof_2 | Mathlib.Analysis.Normed.Module.MStructure | ∀ {X : Type u_2} [inst : NormedAddCommGroup X] {M : Type u_1} [inst_1 : Ring M] [inst_2 : Module M X]
[inst_3 : FaithfulSMul M X] (P Q : { P // IsLprojection X P }), Q ≤ P ⊔ Q | null | false |
Additive.ofMul_lt._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.TypeTags | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (Additive.ofMul a < Additive.ofMul b) = (a < b) | null | false |
Std.Tactic.BVDecide.BVExpr.extract.noConfusion | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {P : Sort u} →
{w start len : ℕ} →
{expr : Std.Tactic.BVDecide.BVExpr w} →
{w' start' len' : ℕ} →
{expr' : Std.Tactic.BVDecide.BVExpr w'} →
len = len' →
Std.Tactic.BVDecide.BVExpr.extract start len expr ≍ Std.Tactic.BVDecide.BVExpr.extract start' len' expr' →
(w =... | null | false |
_private.Mathlib.LinearAlgebra.Matrix.DotProduct.0.Matrix.vecMul_conjTranspose_mul_self_eq_zero._simp_1_2 | Mathlib.LinearAlgebra.Matrix.DotProduct | ∀ {n : Type u_3} {α : Type v} {ι : Type u_6} [inst : Zero α] [Nonempty ι] (v : n → α),
(Matrix.replicateRow ι v = 0) = (v = 0) | null | false |
ArchimedeanClass.instFieldFiniteResidueField._proof_23 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
autoParam (∀ (n : ℕ) (x : ArchimedeanClass.FiniteResidueField K), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._autoParam | null | false |
CategoryTheory.Functor.CoreMonoidal.toOplaxMonoidal_η | 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} (h : F.CoreMonoidal), CategoryTheory.Functor.OplaxMonoidal.η F = h.εIso.i... | null | true |
Mathlib.Tactic.DepRewrite.zetaDelta | Mathlib.Tactic.DepRewrite | Lean.Expr → Std.HashSet Lean.FVarId → Lean.MetaM Lean.Expr | In `e`, inline the values of those `ldecl`s that appear in `fvars`. | true |
Lean.Meta.Grind.SymbolPriorityEntry.mk.injEq | Lean.Meta.Tactic.Grind.EMatchTheorem | ∀ (declName : Lean.Name) (prio : ℕ) (declName_1 : Lean.Name) (prio_1 : ℕ),
({ declName := declName, prio := prio } = { declName := declName_1, prio := prio_1 }) =
(declName = declName_1 ∧ prio = prio_1) | null | true |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.Inv2.property._simp_1_5 | Std.Sat.AIG.RelabelNat | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = false) = (a ≠ b) | null | false |
Std.DTreeMap.Internal.Impl.size_insert_le | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k : α} {v : β k}, (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.size ≤ t.size + 1 | null | true |
WeierstrassCurve.Ψ_neg | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {R : Type r} [inst : CommRing R] (W : WeierstrassCurve R) (n : ℤ), W.Ψ (-n) = -W.Ψ n | null | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.knowsType | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context → Bool | null | true |
CategoryTheory.Functor.isMittagLeffler_of_surjective | Mathlib.CategoryTheory.CofilteredSystem | ∀ {J : Type u} [inst : CategoryTheory.Category.{v_1, u} J] (F : CategoryTheory.Functor J (Type v)),
(∀ ⦃i j : J⦄ (f : i ⟶ j), Function.Surjective ⇑(CategoryTheory.ConcreteCategory.hom (F.map f))) → F.IsMittagLeffler | null | true |
_private.Mathlib.RingTheory.Polynomial.ContentIdeal.0.Polynomial.mul_contentIdeal_le_radical_contentIdeal_mul._simp_1_3 | Mathlib.RingTheory.Polynomial.ContentIdeal | ∀ {R : Type u_1} {S : Type u_2} {F : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : FunLike F R S]
[rc : RingHomClass F R S] {I : Ideal R} (f : F), (I ≤ RingHom.ker f) = (Ideal.map f I = ⊥) | null | false |
CategoryTheory.Bicategory.HasLeftKanExtension.rec | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c : B} →
{f : a ⟶ b} →
{g : a ⟶ c} →
{motive : CategoryTheory.Bicategory.HasLeftKanExtension f g → Sort u_1} →
((hasInitial : CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftExtension f g)) → motive ⋯) →... | null | false |
CategoryTheory.Limits.IsLimit.mkConeMorphism.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F}
(lift : (s : CategoryTheory.Limits.Cone F) → s ⟶ t)
(uniq : ∀ (s : CategoryTheory.Limits.Cone F) (m : s ⟶ t), m = lift s),
C... | null | true |
Pi.addSemigroup._proof_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → AddSemigroup (f i)] (a b c : (i : I) → f i),
a + b + c = a + (b + c) | null | false |
Inclusion.IExpr.recOn | Mathlib.Tactic.Inclusion.Core.Types | {motive : Inclusion.IExpr → Sort u} →
(t : Inclusion.IExpr) →
((iType : Inclusion.IType) → (expr : Lean.Expr) → motive { iType := iType, expr := expr }) → motive t | null | false |
List.flatMap.eq_1 | Init.Data.List.Basic | ∀ {α : Type u} {β : Type v} (b : α → List β) (as : List α), List.flatMap b as = (List.map b as).flatten | null | true |
_private.Init.Data.Nat.Fold.0.Nat.foldTR.loop._sunfold | Init.Data.Nat.Fold | {α : Type u} → (n : ℕ) → ((i : ℕ) → i < n → α → α) → (j : ℕ) → j ≤ n → α → α | null | false |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.ne_zero._simp_1_2 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b ≠ 0) = (a ≠ b) | null | false |
_private.Mathlib.Computability.DFA.0.Language.IsRegular.add.match_1_1 | Mathlib.Computability.DFA | ∀ {T : Type u_1} {L2 : Language T} (motive : L2.IsRegular → Prop) (h2 : L2.IsRegular),
(∀ (σ2 : Type) (w : Fintype σ2) (M2 : DFA T σ2) (hM2 : M2.accepts = L2), motive ⋯) → motive h2 | null | false |
_private.Std.Sat.CNF.Sat.0.Std.Sat.CNF.Clause.not_sat_empty._simp_1_1 | Std.Sat.CNF.Sat | ∀ {α : Type u_1} (a : α → Bool) (c : Std.Sat.CNF.Clause α),
Std.Sat.CNF.Clause.Sat a c = (Std.Sat.CNF.Clause.eval a c = true) | null | false |
_private.Mathlib.CategoryTheory.Filtered.Small.0.CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min.sizeOf_spec | Mathlib.CategoryTheory.Filtered.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {n : ℕ} {X : (k : ℕ) → k < n → (t : Type (max v w)) × (t → C)}
[inst_1 : SizeOf C] {k k' : ℕ} (hk : k < n) (hk' : k' < n) (a : (X k hk).fst) (a_1 : (X k' hk').fst),
sizeOf (CategoryTheory.IsCofiltered.CofilteredClosureSmall.InductiveStep.min✝ hk hk' a a_1) =
... | null | true |
_private.Batteries.Data.Fin.Fold.0.Fin.dfoldrM_loop_succ._proof_3 | Batteries.Data.Fin.Fold | ∀ {n i : ℕ} {h : i + 1 < n + 1}, ¬i < n + 1 → False | null | false |
String.Slice.Pos.skip?_char_eq_none_iff._simp_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos}, (pos.skip? c = none) = ∀ (h : pos ≠ s.endPos), pos.get h ≠ c | null | false |
ProfiniteAddGrp.ContinuousMulEquiv.toProfiniteAddGrpIso._proof_2 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X : ProfiniteAddGrp.{u_1}}, TotallyDisconnectedSpace ↑X.toProfinite.toTop | null | false |
Homogenization.toLinearMap_congr | Mathlib.LinearAlgebra.AffineSpace.Homogenization | ∀ {R : Type u_1} [inst : Ring R] {V₁ : Type u_4} {P₁ : Type u_5} [inst_1 : AddCommGroup V₁] [inst_2 : Module R V₁]
[inst_3 : AddTorsor V₁ P₁] {V₂ : Type u_6} {P₂ : Type u_7} [inst_4 : AddCommGroup V₂] [inst_5 : Module R V₂]
[inst_6 : AddTorsor V₂ P₂] (f : P₁ ≃ᵃ[R] P₂), ↑(Homogenization.congr f) = Homogenization.map... | null | true |
ContMDiff.vadd | Mathlib.Geometry.Manifold.Algebra.SMul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {H' : Type u_4}
[inst_4 : TopologicalSpace H'] {E' : Type u_5} [inst_5 : NormedAddCommGroup E'] [inst_6 : Normed... | null | true |
_private.Mathlib.Order.Monotone.Basic.0.StrictAnti.isMax_of_apply.match_1_1 | Mathlib.Order.Monotone.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α} (motive : (∃ b, a < b) → Prop) (x : ∃ b, a < b),
(∀ (w : α) (hb : a < w), motive ⋯) → motive x | null | false |
_private.Lean.ExtraModUses.0.Lean.instHashableExtraModUse.hash.match_1 | Lean.ExtraModUses | (motive : Lean.ExtraModUse → Sort u_1) →
(x : Lean.ExtraModUse) →
((a : Lean.Name) → (a_1 a_2 : Bool) → motive { module := a, isExported := a_1, isMeta := a_2 }) → motive x | null | false |
CategoryTheory.Quotient.lift._proof_2 | Mathlib.CategoryTheory.Quotient | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (r : HomRel C) {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] (F : CategoryTheory.Functor C D)
(H : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) {X Y Z : CategoryTheory.Quotient r} (f : X ⟶ Y)
(g : Y ⟶ Z),
Quot.liftOn ... | null | false |
IntermediateField.map_id | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L),
IntermediateField.map (AlgHom.id K L) S = S | Mapping intermediate fields along the identity does not change them. | true |
_private.Mathlib.LinearAlgebra.Dimension.Constructions.0.rank_quotient_add_rank_le.match_1_1 | Mathlib.LinearAlgebra.Dimension.Constructions | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (M' : Submodule R M)
(motive : { s // LinearIndepOn R id s } → Prop) (x : { s // LinearIndepOn R id s }),
(∀ (t : Set ↥M') (ht : LinearIndepOn R id t), motive ⟨t, ht⟩) → motive x | null | false |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.rw.inj | Mathlib.Tactic.ClickSuggestions.TryPremises | ∀ {i : Mathlib.Tactic.ClickSuggestions.RwInfo} {arr : Array Mathlib.Tactic.ClickSuggestions.RwLemma}
{i_1 : Mathlib.Tactic.ClickSuggestions.RwInfo} {arr_1 : Array Mathlib.Tactic.ClickSuggestions.RwLemma},
Mathlib.Tactic.ClickSuggestions.Candidates.rw✝ i arr = Mathlib.Tactic.ClickSuggestions.Candidates.rw✝ i_1 arr_1... | null | true |
MinTropical.instZeroOfTop | Mathlib.Algebra.Tropical.Basic | {R : Type u} → [Top R] → Zero (MinTropical R) | null | true |
CategoryTheory.Functor.whiskeringLeft._proof_2 | Mathlib.CategoryTheory.Whiskering | ∀ (C : Type u_5) [inst : CategoryTheory.Category.{u_6, u_5} C] (D : Type u_3)
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] (E : Type u_4) [inst_2 : CategoryTheory.Category.{u_2, u_4} E]
(F : CategoryTheory.Functor C D) {X Y Z : CategoryTheory.Functor D E} (f : X ⟶ Y) (g : Y ⟶ Z),
F.whiskerLeft (CategoryTheory.... | null | false |
Module.End.isIntegral | Mathlib.RingTheory.IntegralClosure.Algebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_5} [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M],
Algebra.IsIntegral R (Module.End R M) | null | true |
GeneralSchauderBasis.proj.eq_1 | Mathlib.Analysis.Normed.Module.Bases | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {X : Type u_2} [inst_1 : NormedAddCommGroup X]
[inst_2 : NormedSpace 𝕜 X] {β : Type u_3} {L : SummationFilter β} (b : GeneralSchauderBasis β 𝕜 X L) (A : Finset β),
b.proj A = ∑ i ∈ A, ContinuousLinearMap.smulRight (b.coord i) (↑b i) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.