name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
BddLat.ofHom | Mathlib.Order.Category.BddLat | {X Y : Type u} →
[inst : Lattice X] →
[inst_1 : BoundedOrder X] →
[inst_2 : Lattice Y] → [inst_3 : BoundedOrder Y] → BoundedLatticeHom X Y → (BddLat.of X ⟶ BddLat.of Y) | true |
_private.Mathlib.Analysis.Calculus.Deriv.Mul.0.derivWithin_fun_const_smul_field._simp_1_1 | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜}, derivWithin f s x = (fderivWithin 𝕜 f s x) 1 | false |
Lean.Grind.CommRing.mk._flat_ctor | Init.Grind.Ring.Basic | {α : Type u} →
(add mul : α → α → α) →
[natCast : NatCast α] →
[ofNat : (n : ℕ) → OfNat α n] →
[nsmul : SMul ℕ α] →
[npow : HPow α ℕ α] →
(∀ (a : α), a + 0 = a) →
(∀ (a b : α), a + b = b + a) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a b c : α), a * b * c = a * (b * c)) →
(∀ (a : α), a * 1 = a) →
autoParam (∀ (a : α), 1 * a = a) Lean.Grind.CommSemiring.one_mul._autoParam →
(∀ (a b c : α), a * (b + c) = a * b + a * c) →
autoParam (∀ (a b c : α), (a + b) * c = a * c + b * c)
Lean.Grind.CommSemiring.right_distrib._autoParam →
(∀ (a : α), 0 * a = 0) →
autoParam (∀ (a : α), a * 0 = 0) Lean.Grind.CommSemiring.mul_zero._autoParam →
(∀ (a : α), a ^ 0 = 1) →
(∀ (a : α) (n : ℕ), a ^ (n + 1) = a ^ n * a) →
autoParam (∀ (a : ℕ), OfNat.ofNat (a + 1) = OfNat.ofNat a + 1)
Lean.Grind.Semiring.ofNat_succ._autoParam →
autoParam (∀ (n : ℕ), OfNat.ofNat n = ↑n)
Lean.Grind.Semiring.ofNat_eq_natCast._autoParam →
autoParam (∀ (n : ℕ) (a : α), n • a = ↑n * a)
Lean.Grind.Semiring.nsmul_eq_natCast_mul._autoParam →
(neg : α → α) →
(sub : α → α → α) →
[intCast : IntCast α] →
[zsmul : SMul ℤ α] →
(∀ (a : α), neg a + a = 0) →
(∀ (a b : α), a - b = a + neg b) →
(∀ (i : ℤ) (a : α), -i • a = neg (i • a)) →
autoParam (∀ (n : ℕ) (a : α), ↑n • a = n • a)
Lean.Grind.Ring.zsmul_natCast_eq_nsmul._autoParam →
autoParam (∀ (n : ℕ), ↑(OfNat.ofNat n) = OfNat.ofNat n)
Lean.Grind.Ring.intCast_ofNat._autoParam →
autoParam (∀ (i : ℤ), ↑(-i) = neg ↑i)
Lean.Grind.Ring.intCast_neg._autoParam →
(∀ (a b : α), a * b = b * a) → Lean.Grind.CommRing α | false |
Sigma.Lex.LT | Mathlib.Data.Sigma.Order | {ι : Type u_1} → {α : ι → Type u_2} → [LT ι] → [(i : ι) → LT (α i)] → LT (Σₗ (i : ι), α i) | true |
Std.Do.Iter.foldM_mapM | Std.Do.Triple.SpecLemmas | ∀ {ps : Std.Do.PostShape} {α β γ δ : Type w} {n : Type w → Type w''} {o : Type w → Type w'''}
[inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n]
[WeaklyLawfulMonadAttach n] [inst_6 : Monad o] [LawfulMonad o] [inst_8 : Std.Do.WPMonad o ps]
[inst_9 : Std.IteratorLoop α Id n] [inst_10 : Std.IteratorLoop α Id o] [Std.LawfulIteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id o] [inst_13 : MonadLiftT n o] [LawfulMonadLiftT n o] {f : β → n γ} {g : δ → γ → o δ}
{init : δ} {it : Std.Iter β} {P : Std.Do.Assertion ps} {Q : Std.Do.PostCond δ ps},
⦃P⦄
Std.Iter.foldM
(fun d b => do
let c ← liftM (f b)
g d c)
init it ⦃Q⦄ →
⦃P⦄ Std.IterM.foldM g init (Std.Iter.mapM f it) ⦃Q⦄ | true |
Lean.Lsp.DocumentSymbol.rec | Lean.Data.Lsp.LanguageFeatures | {motive_1 : Lean.Lsp.DocumentSymbol → Sort u} →
{motive_2 : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol → Sort u} →
{motive_3 : Option (Array Lean.Lsp.DocumentSymbol) → Sort u} →
{motive_4 : Array Lean.Lsp.DocumentSymbol → Sort u} →
{motive_5 : List Lean.Lsp.DocumentSymbol → Sort u} →
((sym : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol) →
motive_2 sym → motive_1 (Lean.Lsp.DocumentSymbol.mk sym)) →
((name : String) →
(detail? : Option String) →
(kind : Lean.Lsp.SymbolKind) →
(range selectionRange : Lean.Lsp.Range) →
(children? : Option (Array Lean.Lsp.DocumentSymbol)) →
motive_3 children? →
motive_2
{ name := name, detail? := detail?, kind := kind, range := range,
selectionRange := selectionRange, children? := children? }) →
motive_3 none →
((val : Array Lean.Lsp.DocumentSymbol) → motive_4 val → motive_3 (some val)) →
((toList : List Lean.Lsp.DocumentSymbol) → motive_5 toList → motive_4 { toList := toList }) →
motive_5 [] →
((head : Lean.Lsp.DocumentSymbol) →
(tail : List Lean.Lsp.DocumentSymbol) →
motive_1 head → motive_5 tail → motive_5 (head :: tail)) →
(t : Lean.Lsp.DocumentSymbol) → motive_1 t | false |
Mathlib.Tactic.Widget.StringDiagram.IdNode.mk.inj | Mathlib.Tactic.Widget.StringDiagram | ∀ {vPos hPosSrc hPosTar : ℕ} {id : Mathlib.Tactic.BicategoryLike.Atom₁} {vPos_1 hPosSrc_1 hPosTar_1 : ℕ}
{id_1 : Mathlib.Tactic.BicategoryLike.Atom₁},
{ vPos := vPos, hPosSrc := hPosSrc, hPosTar := hPosTar, id := id } =
{ vPos := vPos_1, hPosSrc := hPosSrc_1, hPosTar := hPosTar_1, id := id_1 } →
vPos = vPos_1 ∧ hPosSrc = hPosSrc_1 ∧ hPosTar = hPosTar_1 ∧ id = id_1 | true |
_private.Mathlib.Data.List.Sublists.0.List.Pairwise.sublists'._simp_1_3 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | false |
Std.IterM.step_filterWithPostcondition._proof_4 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_3} {n : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {it : Std.IterM m β}
{f : β → Std.Iterators.PostconditionT n (ULift.{u_1, 0} Bool)} [inst_1 : Monad n] [inst_2 : MonadLiftT m n]
(it' : Std.IterM m β),
it.IsPlausibleStep (Std.IterStep.skip it') →
(Std.IterM.filterWithPostcondition f it).IsPlausibleStep
(Std.IterStep.skip (Std.IterM.filterWithPostcondition f it')) | false |
Mathlib.Meta.FunProp.FunPropDecl.funArgId | Mathlib.Tactic.FunProp.Decl | Mathlib.Meta.FunProp.FunPropDecl → ℕ | true |
WithBot.addMonoidWithOne | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {α : Type u} → [AddMonoidWithOne α] → AddMonoidWithOne (WithBot α) | true |
Metric.exists_finite_isCover_of_isCompact_closure | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {ε : NNReal} {s : Set X},
ε ≠ 0 → IsCompact (closure s) → ∃ N ⊆ s, N.Finite ∧ Metric.IsCover ε s N | true |
Order.succ_eq_zero | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddZeroClass α] [inst_2 : OrderBot α] [CanonicallyOrderedAdd α]
[inst_4 : One α] [NoMaxOrder α] [inst_6 : SuccAddOrder α] {a : WithBot α}, a.succ = 0 ↔ a = ⊥ | true |
CategoryTheory.MorphismProperty.isomorphisms.iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.MorphismProperty.isomorphisms C f = CategoryTheory.IsIso f | false |
Lean.Grind.OrderedAdd.zsmul_nonpos | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.IntModule M] [Lean.Grind.OrderedAdd M]
{k : ℤ} {a : M}, 0 ≤ k → a ≤ 0 → k • a ≤ 0 | true |
Affine.Simplex.dist_lt_of_mem_interior_of_strictConvexSpace | Mathlib.Analysis.Convex.StrictCombination | ∀ {V : Type u_2} {P : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [StrictConvexSpace ℝ V]
[inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) {r : ℝ} {p₀ p : P},
p ∈ s.interior → (∀ (i : Fin (n + 1)), dist (s.points i) p₀ ≤ r) → dist p p₀ < r | true |
Lean.Parser.Term.arrow | Lean.Parser.Term | Lean.Parser.TrailingParser | true |
Int.sub_fdiv_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b c : ℤ}, c ∣ b → (a - b).fdiv c = a.fdiv c - b.fdiv c | true |
Lean.Elab.DefViewElabHeaderData.mk.noConfusion | Lean.Elab.DefView | {P : Sort u} →
{shortDeclName declName : Lean.Name} →
{levelNames : List Lean.Name} →
{binderIds : Array Lean.Syntax} →
{numParams : ℕ} →
{type : Lean.Expr} →
{shortDeclName' declName' : Lean.Name} →
{levelNames' : List Lean.Name} →
{binderIds' : Array Lean.Syntax} →
{numParams' : ℕ} →
{type' : Lean.Expr} →
{ shortDeclName := shortDeclName, declName := declName, levelNames := levelNames,
binderIds := binderIds, numParams := numParams, type := type } =
{ shortDeclName := shortDeclName', declName := declName', levelNames := levelNames',
binderIds := binderIds', numParams := numParams', type := type' } →
(shortDeclName = shortDeclName' →
declName = declName' →
levelNames = levelNames' →
binderIds = binderIds' → numParams = numParams' → type = type' → P) →
P | false |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.ofPermHom_support._simp_1_2 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {b : β},
(b ∈ s.biUnion t) = ∃ a ∈ s, b ∈ t a | false |
SSet.Truncated.hoFunctor.monoidal._proof_18 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | autoParam
(∀ (X : SSet),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (SSet.hoFunctor.obj X)).inv =
CategoryTheory.CategoryStruct.comp (SSet.hoFunctor.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv)
(CategoryTheory.CategoryStruct.comp
(SSet.Truncated.hoFunctor.monoidal._aux_12 X (CategoryTheory.MonoidalCategoryStruct.tensorUnit SSet))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (SSet.hoFunctor.obj X)
SSet.Truncated.hoFunctor.monoidal._aux_10)))
CategoryTheory.Functor.OplaxMonoidal.oplax_right_unitality._autoParam | false |
Nat.instNeZeroHPow | Init.Data.Nat.Basic | ∀ {n m : ℕ} [NeZero n], NeZero (n ^ m) | true |
IsSelfAdjoint.natCast._simp_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : StarRing R] (n : ℕ), IsSelfAdjoint ↑n = True | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.Const.balanced_modify._proof_1_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] {k : α} {f : β → β} (sz : ℕ) (k_1 : α) (v : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
(Std.DTreeMap.Internal.Impl.inner sz k_1 v l r).Balanced →
(Std.DTreeMap.Internal.Impl.Const.modify k f l).Balanced →
(Std.DTreeMap.Internal.Impl.Const.modify k f r).Balanced →
(match compare k k_1 with
| Ordering.lt => Std.DTreeMap.Internal.Impl.inner sz k_1 v (Std.DTreeMap.Internal.Impl.Const.modify k f l) r
| Ordering.gt => Std.DTreeMap.Internal.Impl.inner sz k_1 v l (Std.DTreeMap.Internal.Impl.Const.modify k f r)
| Ordering.eq => Std.DTreeMap.Internal.Impl.inner sz k (f v) l r).Balanced | false |
Ideal.Quotient.algebra_isIntegral_of_liesOver | Mathlib.RingTheory.Ideal.GoingUp | ∀ {A : Type u_1} [inst : CommRing A] {B : Type u_2} [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Algebra.IsIntegral A B] (P : Ideal B) (p : Ideal A) [inst_4 : P.LiesOver p], Algebra.IsIntegral (A ⧸ p) (B ⧸ P) | true |
Std.Time.PlainDateTime.recOn | Std.Time.DateTime.PlainDateTime | {motive : Std.Time.PlainDateTime → Sort u} →
(t : Std.Time.PlainDateTime) →
((date : Std.Time.PlainDate) → (time : Std.Time.PlainTime) → motive { date := date, time := time }) → motive t | false |
inv_eq_one_divp' | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : Monoid α] (u : αˣ), ↑(1 / u) = 1 /ₚ u | true |
List.countPBefore.eq_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (xs : List α) (i : ℕ), List.countPBefore p xs i = List.countPBefore.go p xs i 0 | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.isEmpty_insertMany_list._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Finset.le_min_iff | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] {m : WithTop α} {s : Finset α}, m ≤ s.min ↔ ∀ a ∈ s, m ≤ ↑a | true |
CochainComplex.HomComplex.Cocycle.leftShift._proof_2 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {n : ℤ} (γ : CochainComplex.HomComplex.Cocycle K L n) (a n' : ℤ) (hn' : n + a = n'),
CochainComplex.HomComplex.δ n' (n' + 1) ((↑γ).leftShift a n' hn') = 0 | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.assemble₄_eq_some_of_toBitVec._simp_1_5 | Init.Data.String.Decode | ∀ {a b : UInt32}, (a < b) = (a.toBitVec < b.toBitVec) | false |
NNReal.instPosSMulStrictMono | Mathlib.Data.NNReal.Defs | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : MulAction ℝ α] [PosSMulStrictMono ℝ α], PosSMulStrictMono NNReal α | true |
Lean.Elab.Tactic.Conv.matchPattern? | Lean.Elab.Tactic.Conv.Pattern | Lean.Meta.AbstractMVarsResult → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Array Lean.Expr)) | true |
Std.HashMap.Raw.ofArray | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → Array (α × β) → Std.HashMap.Raw α β | true |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.toOption.eq_1 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type} {pat : ρ} [inst : String.Slice.Pattern.ToForwardSearcher pat σ]
{s : String.Slice} (currPos : s.Pos) (s_1 : Std.Iter (String.Slice.Pattern.SearchStep s)),
String.Slice.SplitIterator.toOption✝ (String.Slice.SplitIterator.operating currPos s_1) = some s_1 | true |
VectorField.mlieBracketWithin_def | Mathlib.Geometry.Manifold.VectorField.LieBracket | ∀ {𝕜 : 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} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {s : Set M} {V W : (x : M) → TangentSpace I x},
VectorField.mlieBracketWithin I V W s = fun x₀ =>
VectorField.mpullback I (modelWithCornersSelf 𝕜 E) (↑(extChartAt I x₀))
(VectorField.lieBracketWithin 𝕜
(VectorField.mpullbackWithin (modelWithCornersSelf 𝕜 E) I (↑(extChartAt I x₀).symm) V (Set.range ↑I))
(VectorField.mpullbackWithin (modelWithCornersSelf 𝕜 E) I (↑(extChartAt I x₀).symm) W (Set.range ↑I))
(↑(extChartAt I x₀).symm ⁻¹' s ∩ Set.range ↑I))
x₀ | true |
wrapped._@.Mathlib.Topology.Algebra.InfiniteSum.Defs.1210274395._hygCtx._hyg.8 | Mathlib.Topology.Algebra.InfiniteSum.Defs | Subtype (Eq @definition✝) | false |
CategoryTheory.Idempotents.Karoubi.Hom.recOn | Mathlib.CategoryTheory.Idempotents.Karoubi | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{P Q : CategoryTheory.Idempotents.Karoubi C} →
{motive : P.Hom Q → Sort u} →
(t : P.Hom Q) →
((f : P.X ⟶ Q.X) →
(comm : CategoryTheory.CategoryStruct.comp P.p (CategoryTheory.CategoryStruct.comp f Q.p) = f) →
motive { f := f, comm := comm }) →
motive t | false |
_private.Init.Data.Nat.Div.Lemmas.0.Nat.add_div._proof_1_2 | Init.Data.Nat.Div.Lemmas | ∀ {a b c : ℕ}, 0 < c → ¬c ≤ a % c + b % c → ¬a % c + b % c ≤ c - 1 → False | false |
HahnSeries.instNatCast | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{R : Type u_3} → [Zero Γ] → [inst : PartialOrder Γ] → [inst_1 : Zero R] → [NatCast R] → NatCast (HahnSeries Γ R) | true |
_private.Init.Data.Char.Basic.0.Char.isValidUInt32.match_1_1 | Init.Data.Char.Basic | ∀ (n : ℕ) (motive : Char.isValidCharNat n → Prop) (h : Char.isValidCharNat n),
(∀ (h : n < 55296), motive ⋯) → (∀ (left : 57343 < n) (h₂ : n < 1114112), motive ⋯) → motive h | false |
Cardinal.lift_mk_fin | Mathlib.SetTheory.Cardinal.Defs | ∀ (n : ℕ), Cardinal.lift.{u_1, 0} (Cardinal.mk (Fin n)) = ↑n | true |
AEMeasurable.lintegral_prod_right | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {f : α → β → ENNReal},
AEMeasurable (Function.uncurry f) (μ.prod ν) → AEMeasurable (fun x => ∫⁻ (y : β), f x y ∂ν) μ | true |
Int.Linear.le_of_le_cert.match_1.congr_eq_3 | Init.Data.Int.Linear | ∀ (motive : Int.Linear.Poly → Int.Linear.Poly → Sort u_1) (p₁ p₂ : Int.Linear.Poly)
(h_1 :
(k : ℤ) →
(v : Int.Linear.Var) →
(p : Int.Linear.Poly) → (k_1 : ℤ) → motive (Int.Linear.Poly.add k v p) (Int.Linear.Poly.num k_1))
(h_2 :
(k k_1 : ℤ) →
(v : Int.Linear.Var) → (p : Int.Linear.Poly) → motive (Int.Linear.Poly.num k) (Int.Linear.Poly.add k_1 v p))
(h_3 : (c₁ c₂ : ℤ) → motive (Int.Linear.Poly.num c₁) (Int.Linear.Poly.num c₂))
(h_4 :
(a₁ : ℤ) →
(x₁ : Int.Linear.Var) →
(p₁ : Int.Linear.Poly) →
(a₂ : ℤ) →
(x₂ : Int.Linear.Var) →
(p₂ : Int.Linear.Poly) → motive (Int.Linear.Poly.add a₁ x₁ p₁) (Int.Linear.Poly.add a₂ x₂ p₂))
(c₁ c₂ : ℤ),
p₁ = Int.Linear.Poly.num c₁ →
p₂ = Int.Linear.Poly.num c₂ →
(match p₁, p₂ with
| Int.Linear.Poly.add k v p, Int.Linear.Poly.num k_1 => h_1 k v p k_1
| Int.Linear.Poly.num k, Int.Linear.Poly.add k_1 v p => h_2 k k_1 v p
| Int.Linear.Poly.num c₁, Int.Linear.Poly.num c₂ => h_3 c₁ c₂
| Int.Linear.Poly.add a₁ x₁ p₁, Int.Linear.Poly.add a₂ x₂ p₂ => h_4 a₁ x₁ p₁ a₂ x₂ p₂) ≍
h_3 c₁ c₂ | true |
Asymptotics.wrapped._@.Mathlib.Analysis.Asymptotics.Defs.2970832229._hygCtx._hyg.2 | Mathlib.Analysis.Asymptotics.Defs | Subtype (Eq @Asymptotics.definition✝) | false |
zsmul_right_inj | Mathlib.Algebra.Group.Torsion | ∀ {G : Type u_2} [inst : AddGroup G] [IsAddTorsionFree G] {n : ℤ} {a b : G}, n ≠ 0 → (n • a = n • b ↔ a = b) | true |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Real.0.Real.finiteSpanningSetsInIooRat._simp_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.Real | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
CategoryTheory.Functorial.map_comp | Mathlib.CategoryTheory.Functor.Functorial | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : C → D} [self : CategoryTheory.Functorial F] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.map F (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.map F f) (CategoryTheory.map F g) | true |
Std.IterM.forIn_filterMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type u_1 → Type u_2} {n : Type u_1 → Type u_3} {o : Type u_1 → Type u_4} {α β β₂ γ : Type u_1} [inst : Monad m]
[LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n] [inst_4 : Monad o] [LawfulMonad o] [inst_6 : MonadAttach n]
[WeaklyLawfulMonadAttach n] [inst_8 : MonadLiftT m n] [LawfulMonadLiftT m n] [inst_10 : MonadLiftT n o]
[LawfulMonadLiftT n o] [inst_12 : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_14 : Std.IteratorLoop α m o]
[Std.LawfulIteratorLoop α m o] {it : Std.IterM m β} {f : β → n (Option β₂)} {init : γ} {g : β₂ → γ → o (ForInStep γ)},
forIn (Std.IterM.filterMapM f it) init g =
forIn it init fun out acc => do
let __do_lift ← liftM (f out)
match __do_lift with
| some c => g c acc
| none => pure (ForInStep.yield acc) | true |
WeierstrassCurve.Affine.CoordinateRing.instAlgebraPolynomial | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | {R : Type r} → [inst : CommRing R] → {W' : WeierstrassCurve.Affine R} → Algebra (Polynomial R) W'.CoordinateRing | true |
NNReal.agm_le_max | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {x y : NNReal}, x.agm y ≤ max x y | true |
_private.Mathlib.Tactic.FunProp.Theorems.0.Mathlib.Meta.FunProp.getTransitionTheorems.match_1 | Mathlib.Tactic.FunProp.Theorems | (motive :
Lean.Meta.RefinedDiscrTree.MatchResult Mathlib.Meta.FunProp.GeneralTheorem ×
Lean.Meta.RefinedDiscrTree Mathlib.Meta.FunProp.GeneralTheorem →
Sort u_1) →
(__discr :
Lean.Meta.RefinedDiscrTree.MatchResult Mathlib.Meta.FunProp.GeneralTheorem ×
Lean.Meta.RefinedDiscrTree Mathlib.Meta.FunProp.GeneralTheorem) →
((candidates : Lean.Meta.RefinedDiscrTree.MatchResult Mathlib.Meta.FunProp.GeneralTheorem) →
(thms : Lean.Meta.RefinedDiscrTree Mathlib.Meta.FunProp.GeneralTheorem) → motive (candidates, thms)) →
motive __discr | false |
_private.Mathlib.Analysis.Distribution.ContDiffMapSupportedIn.0.ContDiffMapSupportedIn.continuous_iff_comp_order_le._simp_1_2 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (a : Prop), (False → a) = True | false |
TensorProduct.AlgebraTensorModule.rightComm._proof_29 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_1) (S : Type u_6) (B : Type u_2) (M : Type u_3) (P : Type u_4) (Q : Type u_5) [inst : CommSemiring R]
[inst_1 : Semiring B] [inst_2 : Algebra R B] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module B M]
[inst_6 : IsScalarTower R B M] [inst_7 : AddCommMonoid P] [inst_8 : AddCommMonoid Q] [inst_9 : Module R Q]
[inst_10 : CommSemiring S] [inst_11 : Module S M] [inst_12 : Module S P] [inst_13 : Algebra S B]
[inst_14 : IsScalarTower S B M] [inst_15 : SMulCommClass R S M] [inst_16 : SMulCommClass S R M],
SMulCommClass R B (P →ₗ[S] TensorProduct R (TensorProduct S M P) Q) | false |
_private.Lean.Util.TestExtern.0.elabTestExtern._sparseCasesOn_1 | Lean.Util.TestExtern | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
ascPochhammer_succ_eval | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ {S : Type u_1} [inst : Semiring S] (n : ℕ) (k : S),
Polynomial.eval k (ascPochhammer S (n + 1)) = Polynomial.eval k (ascPochhammer S n) * (k + ↑n) | true |
RegularWreathProduct.instGroup._proof_5 | Mathlib.GroupTheory.RegularWreathProduct | ∀ {D : Type u_1} {Q : Type u_2} [inst : Group D] [inst_1 : Group Q] (n : ℕ) (x : D ≀ᵣ Q),
npowRecAuto (n + 1) x = npowRecAuto n x * x | false |
ContinuousAt.enorm | Mathlib.Analysis.Normed.Group.Continuity | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ContinuousENorm E] {X : Type u_8} [inst_2 : TopologicalSpace X]
{f : X → E} {a : X}, ContinuousAt f a → ContinuousAt (fun x => ‖f x‖ₑ) a | true |
Multiset.subsingletonEquiv._proof_1 | Mathlib.Data.Multiset.Basic | ∀ (α : Type u_1) [inst : Subsingleton α], Function.LeftInverse (Quot.lift id ⋯) Multiset.ofList | false |
NonUnitalAlgebra.elemental.instNonUnitalCommRingSubtypeMemNonUnitalSubalgebraOfT2Space._proof_2 | Mathlib.Topology.Algebra.NonUnitalAlgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] [inst_5 : TopologicalSpace A]
[inst_6 : IsSemitopologicalRing A] [inst_7 : ContinuousConstSMul R A] [inst_8 : T2Space A] {x : A}
(a b : ↥(NonUnitalAlgebra.elemental R x)), a * b = b * a | false |
AlgebraicGeometry.Scheme.AffineZariskiSite.restrictIsoSpec.eq_1 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ (X : AlgebraicGeometry.Scheme),
AlgebraicGeometry.Scheme.AffineZariskiSite.restrictIsoSpec X =
CategoryTheory.NatIso.ofComponents (fun U => ⋯.isoSpec) ⋯ | true |
ULift.seminormedCommRing._proof_20 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedCommRing α] (x y : ULift.{u_1, u_2} α), dist x y = ‖-x + y‖ | false |
Configuration.HasLines.hasPoints | Mathlib.Combinatorics.Configuration | {P : Type u_1} →
{L : Type u_2} →
[inst : Membership P L] →
[Configuration.HasLines P L] →
[inst_2 : Fintype P] → [inst_3 : Fintype L] → Fintype.card P = Fintype.card L → Configuration.HasPoints P L | true |
Mathlib.Tactic.BicategoryLike.HorizontalComp.tgtM._sunfold | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.HorizontalComp → m Mathlib.Tactic.BicategoryLike.Mor₁ | false |
_private.Mathlib.Order.Disjointed.0.partialSups_disjointed.match_1_3 | Mathlib.Order.Disjointed | ∀ {ι : Type u_1} [inst : PartialOrder ι] (i r : ι) (motive : (∃ a < i, r ≤ a) → Prop) (x : ∃ a < i, r ≤ a),
(∀ (a : ι) (ha : a < i ∧ r ≤ a), motive ⋯) → motive x | false |
Substring.prev | Init.Data.String.Substring | Substring.Raw → String.Pos.Raw → String.Pos.Raw | true |
Sylow.exists_subgroup_card_pow_prime | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] [Finite G] (p : ℕ) {n : ℕ} [Fact (Nat.Prime p)],
p ^ n ∣ Nat.card G → ∃ K, Nat.card ↥K = p ^ n | true |
_private.Mathlib.Analysis.Normed.Group.Basic.0.smul_ball''._simp_1_1 | Mathlib.Analysis.Normed.Group.Basic | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | false |
Lean.Elab.Tactic.Conv.evalZeta._regBuiltin.Lean.Elab.Tactic.Conv.evalZeta.declRange_3 | Lean.Elab.Tactic.Conv.Basic | IO Unit | false |
Matrix.diagonal_smul | Mathlib.Data.Matrix.Diagonal | ∀ {n : Type u_3} {R : Type u_7} {α : Type v} [inst : DecidableEq n] [inst_1 : Zero α] [inst_2 : SMulZeroClass R α]
(r : R) (d : n → α), Matrix.diagonal (r • d) = r • Matrix.diagonal d | true |
Set.Finite.inter_of_right | Mathlib.Data.Set.Finite.Basic | ∀ {α : Type u} {s : Set α}, s.Finite → ∀ (t : Set α), (t ∩ s).Finite | true |
CliffordAlgebra.toProd_one_tmul_ι | Mathlib.LinearAlgebra.CliffordAlgebra.Prod | ∀ {R : Type u_1} {M₁ : Type u_2} {M₂ : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M₁]
[inst_2 : AddCommGroup M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] (Q₁ : QuadraticForm R M₁)
(Q₂ : QuadraticForm R M₂) (m₂ : M₂),
(CliffordAlgebra.toProd Q₁ Q₂) (1 ᵍ⊗ₜ[R] (CliffordAlgebra.ι Q₂) m₂) =
(CliffordAlgebra.ι (QuadraticMap.prod Q₁ Q₂)) (0, m₂) | true |
ack_mono_left | Mathlib.Computability.Ackermann | ∀ (n : ℕ), Monotone fun m => ack m n | true |
Seminorm.mem_ball._simp_1 | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
(p : Seminorm 𝕜 E) {x y : E} {r : ℝ}, (y ∈ p.ball x r) = (p (y - x) < r) | false |
_private.Mathlib.FieldTheory.Galois.Profinite.0.InfiniteGalois.krullTopology_mem_nhds_one_iff_of_isGalois.match_1_3 | Mathlib.FieldTheory.Galois.Profinite | ∀ {k : Type u_2} {K : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] (A : Set Gal(K/k))
(motive : (∃ L, ↑L.fixingSubgroup ⊆ A) → Prop) (x : ∃ L, ↑L.fixingSubgroup ⊆ A),
(∀ (L : FiniteGaloisIntermediateField k K) (hL : ↑L.fixingSubgroup ⊆ A), motive ⋯) → motive x | false |
Set.IsPWO.image_of_monotoneOn | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α},
s.IsPWO → ∀ {f : α → β}, MonotoneOn f s → (f '' s).IsPWO | true |
_private.Lean.Elab.Tactic.Grind.Have.0.Lean.Elab.Tactic.Grind.evalHaveSilent.match_4 | Lean.Elab.Tactic.Grind.Have | (motive : List Lean.Meta.Grind.Goal → Sort u_1) →
(__discr : List Lean.Meta.Grind.Goal) →
((goal : Lean.Meta.Grind.Goal) → (goals : List Lean.Meta.Grind.Goal) → motive (goal :: goals)) →
((x : List Lean.Meta.Grind.Goal) → motive x) → motive __discr | false |
Pell.pellZd.eq_1 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.pellZd a1 n = { re := ↑(Pell.xn a1 n), im := ↑(Pell.yn a1 n) } | true |
ArithmeticFunction.LSeriesHasSum_zeta | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {s : ℂ}, 1 < s.re → LSeriesHasSum (fun n => ↑(ArithmeticFunction.zeta n)) s (riemannZeta s) | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Nat.mkPow | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | Lean.Expr → Lean.Expr → Lean.Expr | true |
_private.Lean.Server.Test.Cancel.0.Lean.Server.Test.Cancel._aux_Lean_Server_Test_Cancel___elabRules_Lean_Server_Test_Cancel_tacticWait_for_cancel_once_1.match_1 | Lean.Server.Test.Cancel | (motive : Option (Task Unit) → Sort u_1) →
(__do_lift : Option (Task Unit)) →
((t : Task Unit) → motive (some t)) → ((x : Option (Task Unit)) → motive x) → motive __do_lift | false |
EuclideanDomain.mod_add_div' | Mathlib.Algebra.EuclideanDomain.Defs | ∀ {R : Type u} [inst : EuclideanDomain R] (m k : R), m % k + m / k * k = m | true |
IO.getTID | Init.System.IO | BaseIO UInt64 | true |
NumberField.mixedEmbedding.euclidean.integerLattice.eq_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.mixedEmbedding.euclidean.integerLattice K =
ZLattice.comap ℝ (NumberField.mixedEmbedding.integerLattice K)
↑(NumberField.mixedEmbedding.euclidean.toMixed K).toLinearEquiv | true |
_private.Mathlib.NumberTheory.Height.Basic.0.Height.mulHeight_pow._simp_1_1 | Mathlib.NumberTheory.Height.Basic | ∀ {ι : Type u_2} {M : Type u_5} [inst : CommMonoid M] {m : Multiset ι} {f : ι → M} {n : ℕ},
(Multiset.map f m).prod ^ n = (Multiset.map (fun i => f i ^ n) m).prod | false |
Lean.CodeAction.FindTacticResult.tactic.sizeOf_spec | Lean.Server.CodeActions.Provider | ∀ (a : Lean.Syntax.Stack), sizeOf (Lean.CodeAction.FindTacticResult.tactic a) = 1 + sizeOf a | true |
PiFin.hasRepr | Mathlib.Data.Fin.VecNotation | {α : Type u} → {n : ℕ} → [Repr α] → Repr (Fin n → α) | true |
Right.mul_lt_mul_of_nonneg | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulZeroClass α] {a b c d : α} [inst_1 : Preorder α] [PosMulMono α] [MulPosStrictMono α],
a < b → c < d → 0 ≤ a → 0 ≤ c → a * c < b * d | true |
Mathlib.Tactic.GRewrite.Config.useRewrite | Mathlib.Tactic.GRewrite.Core | Mathlib.Tactic.GRewrite.Config → Bool | true |
Module.basisUnique_repr_eq_zero_iff | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : StrongRankCondition R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] [inst_4 : Module.Free R M] {ι : Type u_2} [inst_5 : Unique ι] {h : Module.finrank R M = 1}
{v : M} {i : ι}, ((Module.basisUnique ι h).repr v) i = 0 ↔ v = 0 | true |
Matrix.isNilpotent_trace_of_isNilpotent | Mathlib.LinearAlgebra.Matrix.Charpoly.Coeff | ∀ {R : Type u} [inst : CommRing R] {n : Type v} [inst_1 : DecidableEq n] [inst_2 : Fintype n] {M : Matrix n n R},
IsNilpotent M → IsNilpotent M.trace | true |
ite_eq_ite | Init.PropLemmas | ∀ {α : Sort u_1} (p : Prop) {h h' : Decidable p} (x y : α), ((if p then x else y) = if p then x else y) ↔ True | true |
UpperSet.coe_mk | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] (s : Set α) (hs : IsUpperSet s), ↑{ carrier := s, upper' := hs } = s | true |
NonUnitalNormedCommRing.toNonUnitalSeminormedCommRing._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [β : NonUnitalNormedCommRing α] (x y : α), dist x y = ‖-x + y‖ | false |
Mathlib.Tactic.ITauto.Proof.orInR.sizeOf_spec | Mathlib.Tactic.ITauto | ∀ (p : Mathlib.Tactic.ITauto.Proof), sizeOf p.orInR = 1 + sizeOf p | true |
CategoryTheory.FreeMonoidalCategory.instMonoidalCategory._proof_1 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} {W X Y Z : CategoryTheory.FreeMonoidalCategory C} (f : W ⟶ X) (g : Y ⟶ Z),
Quotient.map₂ CategoryTheory.FreeMonoidalCategory.Hom.tensor ⋯ f g =
CategoryTheory.CategoryStruct.comp (Quot.map (fun f => f.whiskerRight Y) ⋯ f)
(Quot.map (fun f => CategoryTheory.FreeMonoidalCategory.Hom.whiskerLeft X f) ⋯ g) | false |
Turing.PartrecToTM2.codeSupp_cons | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f fs : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.codeSupp (f.cons fs) k =
Turing.PartrecToTM2.trStmts₁ (Turing.PartrecToTM2.trNormal (f.cons fs) k) ∪
Turing.PartrecToTM2.codeSupp f (Turing.PartrecToTM2.Cont'.cons₁ fs k) | true |
PolynomialLaw.add._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f g : M →ₚₗ[R] N) {S : Type u_1} [inst_5 : CommSemiring S]
[inst_6 : Algebra R S] {S' : Type u_1} [inst_7 : CommSemiring S'] [inst_8 : Algebra R S'] (φ : S →ₐ[R] S'),
⇑(LinearMap.rTensor N φ.toLinearMap) ∘ (f.toFun' S + g.toFun' S) =
(f.toFun' S' + g.toFun' S') ∘ ⇑(LinearMap.rTensor M φ.toLinearMap) | false |
NontriviallyNormedField.ofNormNeOne._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ {𝕜 : Type u_1} [h' : NormedField 𝕜], (∃ x, x ≠ 0 ∧ ‖x‖ ≠ 1) → ∃ x, 1 < ‖x‖ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.