name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Batteries.BinomialHeap.Imp.FindMin.recOn | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
{motive : Batteries.BinomialHeap.Imp.FindMin α → Sort u} →
(t : Batteries.BinomialHeap.Imp.FindMin α) →
((before : Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α) →
(val : α) →
(node : Batteries.BinomialHeap.Imp.HeapNode α) →
(next ... | false |
_private.Mathlib.Combinatorics.Enumerative.Partition.Glaisher.0.Nat.Partition.aux_mul_one_sub_X_pow._proof_1_2 | Mathlib.Combinatorics.Enumerative.Partition.Glaisher | ∀ (R : Type u_1) [inst : CommRing R] {m : ℕ},
0 < m → ∀ (i : ↑(Function.mulSupport fun i => 1 - (PowerSeries.X ^ (i + 1)) ^ m)), (↑i + 1) * m - 1 + 1 = (↑i + 1) * m | false |
Pell.Solution₁.instCommGroup._proof_7 | Mathlib.NumberTheory.Pell | ∀ {d : ℤ} (a : Pell.Solution₁ d), a * 1 = a | false |
Lean.Grind.CommRing.Poly.cancelVar | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | true |
CategoryTheory.Pseudofunctor.DescentData'.instCategory._proof_2 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_5} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryT... | false |
ContMDiffWithinAt.change_section_trivialization | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} {F : Type u_4} {M : Type u_5} {E : B → Type u_6}
[inst : NontriviallyNormedField 𝕜] {EB : Type u_7} [inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB]
{HB : Type u_8} [inst_3 : TopologicalSpace HB] {IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSp... | true |
MvPolynomial.monomial_zero' | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R], ⇑(MvPolynomial.monomial 0) = ⇑MvPolynomial.C | true |
WittVector.succNthValUnits.congr_simp | Mathlib.RingTheory.WittVector.DiscreteValuationRing | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (n : ℕ) (a a_1 : kˣ),
a = a_1 →
∀ (A A_1 : WittVector p k),
A = A_1 →
∀ (bs bs_1 : Fin (n + 1) → k),
bs = bs_1 → WittVector.succNthValUnits n a A bs = WittVector.succNthValUnits n a_1 A_1 bs_1 | true |
Finset.measure_zero | Mathlib.MeasureTheory.Measure.Typeclasses.NoAtoms | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (s : Finset α) (μ : MeasureTheory.Measure α) [MeasureTheory.NoAtoms μ],
μ ↑s = 0 | true |
Lean.Meta.RefinedDiscrTree.Key.bvar | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | ℕ → ℕ → Lean.Meta.RefinedDiscrTree.Key | true |
Lean.Grind.AC.diseq_simp_rhs_ac | Init.Grind.AC | ∀ {α : Sort u_1} (ctx : Lean.Grind.AC.Context α) {inst₁ : Std.Associative ctx.op} {inst₂ : Std.Commutative ctx.op}
(c lhs₁ rhs₁ lhs₂ rhs₂ rhs₂' : Lean.Grind.AC.Seq),
Lean.Grind.AC.simp_ac_cert c lhs₁ rhs₁ rhs₂ rhs₂' = true →
Lean.Grind.AC.Seq.denote ctx lhs₁ = Lean.Grind.AC.Seq.denote ctx rhs₁ →
Lean.Grin... | true |
Lean.isInstanceReducibleCore | Lean.ReducibilityAttrs | Lean.Environment → Lean.Name → Bool | true |
MulEquiv.withOneCongr._proof_2 | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Mul α] [inst_1 : Mul β] (e : α ≃* β) (x : WithOne α),
(WithOne.mapMulHom e.symm.toMulHom) ((WithOne.mapMulHom e.toMulHom) x) = x | false |
ONote.zero.elim | Mathlib.SetTheory.Ordinal.Notation | {motive : ONote → Sort u} → (t : ONote) → t.ctorIdx = 0 → motive ONote.zero → motive t | false |
Con.lift | Mathlib.GroupTheory.Congruence.Hom | {M : Type u_1} →
{P : Type u_3} →
[inst : MulOneClass M] → [inst_1 : MulOneClass P] → (c : Con M) → (f : M →* P) → c ≤ Con.ker f → c.Quotient →* P | true |
TopologicalSpace.Closeds.noncompactSpace_iff._simp_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], NoncompactSpace (TopologicalSpace.Closeds α) = NoncompactSpace α | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastRotateLeft.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.RotateLeft | ∀ {w : ℕ} (distance curr idx : ℕ), idx < curr → ¬idx < curr + 1 → False | false |
Int.mul_fmod_right | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod a = 0 | true |
Lean.Parser.OrElseOnAntiquotBehavior.rec | Lean.Parser.Basic | {motive : Lean.Parser.OrElseOnAntiquotBehavior → Sort u} →
motive Lean.Parser.OrElseOnAntiquotBehavior.acceptLhs →
motive Lean.Parser.OrElseOnAntiquotBehavior.takeLongest →
motive Lean.Parser.OrElseOnAntiquotBehavior.merge → (t : Lean.Parser.OrElseOnAntiquotBehavior) → motive t | false |
_private.Std.Data.DHashMap.Internal.WF.0.Std.DHashMap.Internal.Raw₀.alterₘ.match_1.eq_2 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u_3} {β : α → Type u_1} (a : α) (motive : Option (β a) → Sort u_2) (b : β a) (h_1 : Unit → motive none)
(h_2 : (b : β a) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b | true |
Std.HashMap.getKey!_eq_getKeyD_default | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {a : α}, m.getKey! a = m.getKeyD a default | true |
_private.Init.Data.List.Count.0.List.count_erase.match_1_1 | Init.Data.List.Count | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (c : α) (l : List α), motive (c :: l)) → motive x | false |
LieModule.toEnd_eq_iff | Mathlib.Algebra.Lie.OfAssociative | ∀ (R : Type u) (L : Type v) (M : Type w) [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]
[LieModule.IsFaithful R L M] {x y : L}, (LieModule.toEnd R L M) x = (LieModule.toEnd R L M) y ↔ x = y | true |
SSet.Subcomplex.PairingCore.index | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | {X : SSet} → {A : X.Subcomplex} → (self : A.PairingCore) → (s : self.ι) → Fin (self.dim s + 2) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_eq_default._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 |
Int.two_dvd_mul_add_one | Mathlib.Algebra.Ring.Int.Parity | ∀ (k : ℤ), 2 ∣ k * (k + 1) | true |
_private.Mathlib.Topology.EMetricSpace.Basic.0.EMetric.totallyBounded_iff'.match_1_1 | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {s : Set α} (ε : ENNReal)
(motive : (∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε) → Prop)
(x : ∃ t ⊆ s, t.Finite ∧ s ⊆ ⋃ y ∈ t, Metric.eball y ε),
(∀ (t : Set α) (left : t ⊆ s) (ft : t.Finite) (h : s ⊆ ⋃ y ∈ t, Metric.eball y ε), motive ⋯) → motive x | false |
Lean.Elab.Tactic.Omega.MetaProblem.ctorIdx | Lean.Elab.Tactic.Omega.Frontend | Lean.Elab.Tactic.Omega.MetaProblem → ℕ | false |
_private.Mathlib.RingTheory.RootsOfUnity.Basic.0.IsCyclic.monoidHomMulEquivRootsOfUnityOfGenerator._simp_2 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ {G : Type u_1} [inst : Monoid G] {x : G} {n : ℕ}, (orderOf x ∣ n) = (x ^ n = 1) | false |
Order.krullDim_eq_iSup_length | Mathlib.Order.KrullDimension | ∀ {α : Type u_1} [inst : Preorder α] [Nonempty α], Order.krullDim α = ↑(⨆ p, ↑p.length) | true |
Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit._proof_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α fun x => Unit) (h : t.Balanced) (a : α)
(r : Std.DTreeMap.Internal.Impl.Const.IteratedUnitInsertionInto t)
{P : (Std.DTreeMap.Internal.Impl α fun x => Unit) → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α fun x => Unit) (a : α) (h : t''.B... | false |
Vector.getElem_zero_flatten | Init.Data.Vector.Find | ∀ {α : Type u_1} {m n : ℕ} {xss : Vector (Vector α m) n} (h : 0 < n * m),
xss.flatten[0] = (Vector.findSome? (fun xs => xs[0]?) xss).get ⋯ | true |
MonoidHom.coeToMulHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : MulOne M] [inst_1 : MulOne N],
MonoidHom.coeToMulHom = { coe := MonoidHom.toMulHom } | true |
String.Pos.lt_of_lt_of_le | Init.Data.String.Basic | ∀ {s : String} {p q r : s.Pos}, p < q → q ≤ r → p < r | true |
HomotopyCategory.instPretriangulatedIntUp | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[CategoryTheory.Limits.HasBinaryBiproducts C] →
[inst_3 : CategoryTheory.Limits.HasZeroObject C] →
CategoryTheory.Pretriangulated (HomotopyCategory C (ComplexShape.up ℤ)) | true |
_private.Lean.Meta.Basic.0.Lean.Meta.setInlineAttribute.match_1 | Lean.Meta.Basic | (motive : Except String Lean.Environment → Sort u_1) →
(x : Except String Lean.Environment) →
((env : Lean.Environment) → motive (Except.ok env)) → ((msg : String) → motive (Except.error msg)) → motive x | false |
_private.Mathlib.Analysis.InnerProductSpace.OfNorm.0.inner_._proof_1 | Mathlib.Analysis.InnerProductSpace.OfNorm | (3 + 1).AtLeastTwo | false |
summable_sigma_of_nonneg | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {α : Type u_4} {β : α → Type u_3} {f : (x : α) × β x → ℝ},
(∀ (x : (x : α) × β x), 0 ≤ f x) →
(Summable f ↔ (∀ (x : α), Summable fun y => f ⟨x, y⟩) ∧ Summable fun x => ∑' (y : β x), f ⟨x, y⟩) | true |
Set.toFinset_empty | Mathlib.Data.Fintype.Sets | ∀ {α : Type u_1} [inst : Fintype ↑∅], ∅.toFinset = ∅ | true |
Computability.instDecidableEqΓ'.decEq._proof_3 | Mathlib.Computability.Encoding | ∀ (b : Bool), ¬Computability.Γ'.blank = Computability.Γ'.bit b | false |
CompleteBooleanAlgebra.himp._inherited_default | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
(le lt : α → α → Prop) →
(∀ (a : α), le a a) →
(∀ (a b c : α), le a b → le b c → le a c) →
(∀ (a b : α), lt a b ↔ le a b ∧ ¬le b a) →
(∀ (a b : α), le a b → le b a → a = b) →
(sup : α → α → α) →
(∀ (a b : α), le a (sup a b)) →
(∀ (... | false |
ClosedAddSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [AddGroup G] → [TopologicalSpace G] → Type u | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract.go | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{newWidth : ℕ} →
{aig : Std.Sat.AIG α} →
{w : ℕ} → aig.RefVec w → ℕ → (curr : ℕ) → curr ≤ newWidth → aig.RefVec curr → aig.RefVec newWidth | true |
_private.Mathlib.RingTheory.TensorProduct.Quotient.0.Algebra.TensorProduct.quotIdealMapEquivTensorQuot._simp_1 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Mul M] [inst_1 : Mul N] [inst_2 : FunLike F M N]
[MulHomClass F M N] (f : F) (x y : M), f x * f y = f (x * y) | false |
Commute.tsum_left | Mathlib.Topology.Algebra.InfiniteSum.Ring | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : NonUnitalNonAssocSemiring α]
[inst_1 : TopologicalSpace α] [IsTopologicalSemiring α] {f : ι → α} [T2Space α] [L.NeBot] (a : α),
(∀ (i : ι), Commute (f i) a) → Commute (∑'[L] (i : ι), f i) a | true |
Submodule.dualCoannihilator | Mathlib.LinearAlgebra.Dual.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Submodule R (Module.Dual R M) → Submodule R M | true |
_private.Lean.Elab.BuiltinEvalCommand.0.Lean.Elab.Command.elabEvalCoreUnsafe.match_3 | Lean.Elab.BuiltinEvalCommand | (motive : Option Lean.Elab.Command.EvalAction✝ → Sort u_1) →
(__do_lift : Option Lean.Elab.Command.EvalAction✝¹) →
((act : Lean.Elab.Command.EvalAction✝²) → motive (some act)) →
((x : Option Lean.Elab.Command.EvalAction✝³) → motive x) → motive __do_lift | false |
MeasurableEmbedding.measurableSet_range | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β},
MeasurableEmbedding f → MeasurableSet (Set.range f) | true |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff_frequently._simp_1_1 | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {f : Filter β} {m : α → β}, (Filter.comap m f).NeBot = ∀ t ∈ f, ∃ a, m a ∈ t | false |
_private.Mathlib.CategoryTheory.Category.Pairwise.0.CategoryTheory.instFintypePairwise.match_5.eq_2 | Mathlib.CategoryTheory.Category.Pairwise | ∀ (ι : Type u_1) (motive : CategoryTheory.Pairwise ι → Sort u_2) (a a_1 : ι)
(h_1 : (a : ι) → motive (CategoryTheory.Pairwise.single a))
(h_2 : (a a_2 : ι) → motive (CategoryTheory.Pairwise.pair a a_2)),
(match CategoryTheory.Pairwise.pair a a_1 with
| CategoryTheory.Pairwise.single a => h_1 a
| CategoryT... | true |
«_aux_ImportGraph_Tools_FindHome___elabRules_command#find_home!__1» | ImportGraph.Tools.FindHome | Lean.Elab.Command.CommandElab | false |
Option.mem_pmem | Mathlib.Data.Option.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α → Prop} (f : (a : α) → p a → β) (x : Option α) {a : α} (h : ∀ a ∈ x, p a)
(ha : a ∈ x), f a ⋯ ∈ Option.pmap f x h | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_34 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α) {n s : ℕ}
{h : n < (List.idxsOf x (head :: tail) s).length}, 0 < (List.filter (fun x_1 => x_1 == x) (head :: tail)).length | false |
_private.Lean.Elab.DocString.0.Lean.Doc.suggestionName.match_1 | Lean.Elab.DocString | (motive : Option Lean.Name → Sort u_1) →
(resolved? : Option Lean.Name) →
((resolved : Lean.Name) → motive (some resolved)) → (Unit → motive none) → motive resolved? | false |
Order.IsNormal.exists_map_le_lt_map_succ_of_exists_ge | Mathlib.Order.IsNormal | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [WellFoundedLT α] [inst_2 : SuccOrder α] [inst_3 : LinearOrder β]
[NoMaxOrder α] [inst_5 : OrderBot α] [WellFoundedLT β] {f : α → β} {x : β},
Order.IsNormal f → (∃ y, x ≤ f y) → f ⊥ ≤ x → ∃ a, f a ≤ x ∧ x < f (Order.succ a) | true |
Topology.IsConstructible.preimage | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Continuous f →
(∀ (s : Set Y), IsOpen s → IsRetrocompact s → IsRetrocompact (f ⁻¹' s)) →
Topology.IsConstructible s → Topology.IsConstructible (f ⁻¹' s) | true |
Lean.Grind.CommRing.Expr.toPolyC_nc.go | Init.Grind.Ring.CommSolver | ℕ → Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Poly | true |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple.0.RootPairing.GeckConstruction.instIsIrreducible_aux₂ | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Semisimple | ∀ {ι : Type u_1} {K : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field K] [inst_1 : CharZero K]
[inst_2 : DecidableEq ι] [inst_3 : Fintype ι] [inst_4 : AddCommGroup M] [inst_5 : Module K M]
[inst_6 : AddCommGroup N] [inst_7 : Module K N] {P : RootPairing ι K M N} [inst_8 : P.IsCrystallographic] {b : P.Base}
... | true |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.Mathlib.TacticAnalysis.TerminalReplacementOutcome.success.sizeOf_spec | Mathlib.Tactic.TacticAnalysis.Declarations | ∀ (stx : Lean.TSyntax `tactic), sizeOf (Mathlib.TacticAnalysis.TerminalReplacementOutcome.success✝ stx) = 1 + sizeOf stx | true |
_private.Lean.Widget.TaggedText.0.Lean.Widget.TaggedText.instMonadPrettyFormatStateMTaggedState.match_1 | Lean.Widget.TaggedText | (motive : Lean.Widget.TaggedText.TaggedState✝ → Sort u_1) →
(x : Lean.Widget.TaggedText.TaggedState✝¹) →
((out : Lean.Widget.TaggedText (ℕ × ℕ)) →
(ts : List (ℕ × ℕ × Lean.Widget.TaggedText (ℕ × ℕ))) →
(col : ℕ) → motive { out := out, tagStack := ts, column := col }) →
motive x | false |
CategoryTheory.PreZeroHypercover.sectionsEquivOfHasPullbacks | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S : C} →
(E : CategoryTheory.PreZeroHypercover S) →
[inst_1 : E.HasPullbacks] →
(F : CategoryTheory.Functor Cᵒᵖ (Type u_2)) →
(E.toPreOneHypercover.multicospanIndex F).sections ≃
Subtype (CategoryTh... | true |
LindelofSpace.mk | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u_2} [inst : TopologicalSpace X], IsLindelof Set.univ → LindelofSpace X | true |
Set.Finite.wellFoundedOn | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s : Set α}, s.Finite → s.WellFoundedOn r | true |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.addParentInstanceFields.match_9 | Lean.Elab.StructInst | (motive : List (Lean.Name × Array Lean.Name) → Sort u_1) →
(worklist : List (Lean.Name × Array Lean.Name)) →
((parentName : Lean.Name) →
(parentFields : Array Lean.Name) →
(worklist' : List (Lean.Name × Array Lean.Name)) → motive ((parentName, parentFields) :: worklist')) →
((x : List (Lea... | false |
Lean.DeclNameGenerator.noConfusionType | Lean.CoreM | Sort u → Lean.DeclNameGenerator → Lean.DeclNameGenerator → Sort u | false |
AddSubgroup.addCommutator.eq_1 | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G],
AddSubgroup.addCommutator = { bracket := fun H₁ H₂ => AddSubgroup.closure {g | ∃ g₁ ∈ H₁, ∃ g₂ ∈ H₂, ⁅g₁, g₂⁆ = g} } | true |
stoneCechEquivalence._proof_5 | Mathlib.Topology.Category.CompHaus.Basic | ∀ (Y : CompHaus), CompactSpace ↑Y.toTop | false |
maximal_subset_iff | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : Set α → Prop} {s : Set α}, Maximal P s ↔ P s ∧ ∀ ⦃t : Set α⦄, P t → s ⊆ t → s = t | true |
Localization.exists_awayMap_bijective_of_localRingHom_bijective | Mathlib.RingTheory.Unramified.LocalRing | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal R}
[inst_3 : p.IsPrime] {q : Ideal S} [inst_4 : q.IsPrime],
p.primesOver S = {q} →
∀ [Module.Finite R S] [inst_6 : q.LiesOver p],
(RingHom.ker (algebraMap R S)).FG →
Function.Bijective ⇑(Loc... | true |
CategoryTheory.CommMon.toMon | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommMon C → CategoryTheory.Mon C | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Unbounded.State.mk.noConfusion | Std.Sync.Channel | {α : Type} →
{P : Sort u} →
{values : Std.Queue α} →
{consumers : Std.Queue (Std.CloseableChannel.Consumer✝ α)} →
{closed : Bool} →
{values' : Std.Queue α} →
{consumers' : Std.Queue (Std.CloseableChannel.Consumer✝¹ α)} →
{closed' : Bool} →
{ values... | false |
CategoryTheory.MorphismProperty.comp_mem | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.IsStableUnderComposition] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
W f → W g → W (CategoryTheory.CategoryStruct.comp f g) | true |
linearOrderOfCompares._proof_8 | Mathlib.Order.Compare | ∀ {α : Type u_1} [inst : Preorder α] (cmp : α → α → Ordering),
(∀ (a b : α), (cmp a b).Compares a b) → ∀ (a b : α), a ≤ b ∨ b ≤ a | false |
_private.Mathlib.GroupTheory.Goursat.0.Subgroup.mk_goursatFst_eq_iff_mk_goursatSnd_eq._simp_1_1 | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} [inst : Group G] {N : Subgroup G} [nN : N.Normal] {x y : G}, (↑x = ↑y) = (x / y ∈ N) | false |
ZMod.χ₈' | Mathlib.NumberTheory.LegendreSymbol.ZModChar | MulChar (ZMod 8) ℤ | true |
Lean.Lsp.SignatureInformation._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureInformation → ℕ | false |
_private.Mathlib.Topology.Order.0.continuous_sInf_rng._simp_1_1 | Mathlib.Topology.Order | ∀ {α : Type u} {β : Type v} {f : α → β} {t₁ : TopologicalSpace α} {t₂ : TopologicalSpace β},
Continuous f = (TopologicalSpace.coinduced f t₁ ≤ t₂) | false |
ModularForm.mul._proof_2 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k_1 k_2 : ℤ} [inst : Γ.HasDetPlusMinusOne] (f : ModularForm Γ k_1)
(g : ModularForm Γ k_2) {c : OnePoint ℝ},
IsCusp c Γ →
∀ (γ : GL (Fin 2) ℝ),
γ • OnePoint.infty = c →
UpperHalfPlane.IsBoundedAtImInfty (SlashAction.map (k_1 + k_2) γ (f.mul g.toSlashInvariantForm).... | false |
Real.sin_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.sin (Real.pi - x) = Real.sin x | true |
RingQuot.instSemiring | Mathlib.Algebra.RingQuot | {R : Type uR} → [inst : Semiring R] → (r : R → R → Prop) → Semiring (RingQuot r) | true |
IsLocalization.Away.commutes | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_5} [inst : CommSemiring R] (S₁ : Type u_6) (S₂ : Type u_7) (T : Type u_8) [inst_1 : CommSemiring S₁]
[inst_2 : CommSemiring S₂] [inst_3 : CommSemiring T] [inst_4 : Algebra R S₁] [inst_5 : Algebra R S₂]
[inst_6 : Algebra R T] [inst_7 : Algebra S₁ T] [inst_8 : Algebra S₂ T] [IsScalarTower R S₁ T] [IsSca... | true |
Subring.list_sum_mem | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] (s : Subring R) {l : List R}, (∀ x ∈ l, x ∈ s) → l.sum ∈ s | true |
CochainComplex.mapBifunctorHomologicalComplexShift₁Iso | Mathlib.Algebra.Homology.BifunctorShift | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{D : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} D] →
[inst_3 : CategoryTheory.Preadditive C₁] →
[inst_4 : Category... | true |
GenContFract.coe_toGenContFract | Mathlib.Algebra.ContinuedFractions.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Coe α β] {g : GenContFract α},
↑g = { h := Coe.coe g.h, s := Stream'.Seq.map GenContFract.Pair.coeFn g.s } | true |
CommRingCat.Colimits.Relation.right_distrib | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
(x y z : CommRingCat.Colimits.Prequotient F),
CommRingCat.Colimits.Relation F ((x.add y).mul z) ((x.mul z).add (y.mul z)) | true |
UniformConvergenceCLM.neg_apply | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] (σ : 𝕜₁ →+* 𝕜₂) {E : Type u_3}
(F : Type u_4) [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : TopologicalSpace E]
[inst_5 : AddCommGroup F] [inst_6 : Module 𝕜₂ F] [inst_7 : TopologicalSpace F] [inst_8 : IsTopologi... | true |
Lean.Grind.AC.Seq.sort'_k | Init.Grind.AC | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.Seq | true |
IsUnifLocDoublingMeasure | Mathlib.MeasureTheory.Measure.Doubling | {α : Type u_1} → [PseudoMetricSpace α] → [inst : MeasurableSpace α] → MeasureTheory.Measure α → Prop | true |
_private.Mathlib.Topology.Order.0.isClosed_induced._simp_1_1 | Mathlib.Topology.Order | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsClosed s = IsOpen sᶜ | false |
Matrix.replicateRow_inj._simp_1 | Mathlib.LinearAlgebra.Matrix.RowCol | ∀ {n : Type u_3} {α : Type v} {ι : Type u_6} [Nonempty ι] {v w : n → α},
(Matrix.replicateRow ι v = Matrix.replicateRow ι w) = (v = w) | false |
CStarAlgebra.instNegPart | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.PosPart.Basic | {A : Type u_1} →
[inst : NonUnitalRing A] →
[inst_1 : Module ℝ A] →
[inst_2 : SMulCommClass ℝ A A] →
[inst_3 : IsScalarTower ℝ A A] →
[inst_4 : StarRing A] →
[inst_5 : TopologicalSpace A] → [NonUnitalContinuousFunctionalCalculus ℝ A IsSelfAdjoint] → NegPart A | true |
Aesop.ForwardStateStats.mk.noConfusion | Aesop.Stats.Basic | {P : Sort u} →
{ruleStateStats ruleStateStats' : Array Aesop.ForwardRuleStateStats} →
{ ruleStateStats := ruleStateStats } = { ruleStateStats := ruleStateStats' } →
(ruleStateStats = ruleStateStats' → P) → P | false |
Lean.Server.DirectImports.noConfusionType | Lean.Server.References | Sort u → Lean.Server.DirectImports → Lean.Server.DirectImports → Sort u | false |
Function.Surjective.addGroup.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₂] [inst_1 : Zero M₂] [inst_2 : SMul ℕ M₂] [inst_3 : Neg M₂]
[inst_4 : Sub M₂] [inst_5 : SMul ℤ M₂] [inst_6 : AddGroup M₁] (f : M₁ → M₂) (hf : Function.Surjective f)
(one : f 0 = 0) (mul : ∀ (x y : M₁), f (x + y) = f x + f y) (inv : ∀ (x : M₁), f (-x) = -f x)
(div : ... | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.TopologicalSpace.Compacts.instCompleteSpace.match_9 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] (U : SetRel α α) (K x : TopologicalSpace.Compacts α)
(motive : x ∈ {x | (fun K' => (↑K, ↑K') ∈ hausdorffEntourage U) x} → Prop)
(x_1 : x ∈ {x | (fun K' => (↑K, ↑K') ∈ hausdorffEntourage U) x}),
(∀ (left : (↑K, ↑x).1 ⊆ U.preimage (↑K, ↑x).2) (h : (↑K, ↑x).2 ⊆ U.image (↑K, ↑... | false |
Aesop.instInhabitedGoalDiff.default | Aesop.RuleTac.GoalDiff | Aesop.GoalDiff | true |
orderOf_one | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : Monoid G], orderOf 1 = 1 | true |
_private.Mathlib.Geometry.Euclidean.Inversion.Basic.0.EuclideanGeometry.dist_inversion_center._simp_1_6 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | false |
CochainComplex.mappingCocone.triangle_obj₂ | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C],
(CochainComplex.mappingCocone.triangle φ).obj₂ = K | true |
Asymptotics.isBigO_congr | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {l : Filter α} {f₁ f₂ : α → E}
{g₁ g₂ : α → F}, f₁ =ᶠ[l] f₂ → g₁ =ᶠ[l] g₂ → (f₁ =O[l] g₁ ↔ f₂ =O[l] g₂) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.