name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Field.toSemifield._proof_1 | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_1} [inst : Field K] (a b : K), a * b = b * a |
instContinuousConstSMulMatrix | Mathlib.Topology.Instances.Matrix | ∀ {α : Type u_2} {m : Type u_4} {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : SMul α R]
[ContinuousConstSMul α R], ContinuousConstSMul α (Matrix m n R) |
BitVec.reduceSMTSDiv._regBuiltin.BitVec.reduceSMTSDiv.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.396261550._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit |
LocallyFiniteOrder.orderAddMonoidHom.congr_simp | Mathlib.Algebra.Order.Monoid.LocallyFiniteOrder | ∀ (G : Type u_2) [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
[inst_3 : LocallyFiniteOrder G], LocallyFiniteOrder.orderAddMonoidHom G = LocallyFiniteOrder.orderAddMonoidHom G |
CategoryTheory.Limits.HasBiproduct.of_hasProduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_1}
[Finite J] (f : J → C) [CategoryTheory.Limits.HasProduct f], CategoryTheory.Limits.HasBiproduct f |
CompactlySupportedContinuousMap.coe_inf._simp_1 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SemilatticeInf β] [inst_2 : Zero β]
[inst_3 : TopologicalSpace β] [inst_4 : ContinuousInf β] (f g : CompactlySupportedContinuousMap α β),
⇑f ⊓ ⇑g = ⇑(f ⊓ g) |
CategoryTheory.StrictlyUnitaryLaxFunctor.mk'._proof_4 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u_6} [inst : CategoryTheory.Bicategory B] {C : Type u_2} [inst_1 : CategoryTheory.Bicategory C]
(S : CategoryTheory.StrictlyUnitaryLaxFunctorCore B C) (x : B),
CategoryTheory.CategoryStruct.id (S.obj x) = S.map (CategoryTheory.CategoryStruct.id x) |
Int.gcd.eq_1 | Init.Data.Int.Linear | ∀ (m n : ℤ), m.gcd n = m.natAbs.gcd n.natAbs |
map_ratCast_smul | Mathlib.Algebra.Module.Rat | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] {F : Type u_3}
[inst_2 : FunLike F M M₂] [AddMonoidHomClass F M M₂] (f : F) (R : Type u_4) (S : Type u_5) [inst_4 : DivisionRing R]
[inst_5 : DivisionRing S] [inst_6 : Module R M] [inst_7 : Module S M₂] (c : ℚ) (x : M), f (↑c • x) = ↑c • f x |
Std.ExtTreeSet.isEmpty_insertMany_list | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {l : List α},
(t.insertMany l).isEmpty = (t.isEmpty && l.isEmpty) |
sInfHom.dual_apply_toFun | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : InfSet α] [inst_1 : InfSet β] (f : sInfHom α β) (a : αᵒᵈ),
(sInfHom.dual f) a = (⇑OrderDual.toDual ∘ ⇑f ∘ ⇑OrderDual.ofDual) a |
Std.Time.Database.WindowsDb.default | Std.Time.Zoned.Database.Windows | Std.Time.Database.WindowsDb |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.eq_σ_comp_of_not_injective._proof_1_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} (x y : Fin ((SimplexCategory.mk (n + 1)).len + 1)), ¬x = y → ¬x < y → y < x |
FGModuleCat.instCreatesColimitsOfShapeModuleCatForget₂LinearMapIdCarrierObjIsFG | Mathlib.Algebra.Category.FGModuleCat.Colimits | {J : Type} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.FinCategory J] →
{k : Type u} →
[inst_2 : Ring k] →
CategoryTheory.CreatesColimitsOfShape J (CategoryTheory.forget₂ (FGModuleCat k) (ModuleCat k)) |
Std.DHashMap.Internal.AssocList.getKey._unsafe_rec | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
(a : α) → (l : Std.DHashMap.Internal.AssocList α β) → Std.DHashMap.Internal.AssocList.contains a l = true → α |
Lean.Parser.FirstTokens.tokens.inj | Lean.Parser.Types | ∀ {a a_1 : List Lean.Parser.Token}, Lean.Parser.FirstTokens.tokens a = Lean.Parser.FirstTokens.tokens a_1 → a = a_1 |
Finset.instMulLeftMono | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α], MulLeftMono (Finset α) |
instSemiringCorner._proof_5 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalSemiring R] (idem : IsIdempotentElem e) (n : ℕ) (x : idem.Corner),
npowRecAuto (n + 1) x = npowRecAuto n x * x |
minpoly.natSepDegree_eq_one_iff_eq_expand_X_sub_C | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Ring E] [IsDomain E] [inst_3 : Algebra F E] (q : ℕ)
[hF : ExpChar F q] {x : E},
(minpoly F x).natSepDegree = 1 ↔ ∃ n y, minpoly F x = (Polynomial.expand F (q ^ n)) (Polynomial.X - Polynomial.C y) |
Submonoid.powers._proof_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] (n n_1 : M) (i : ℕ), (fun x => n ^ x) i = n_1 ↔ ((powersHom M) n) i = n_1 |
LowerSet.erase_lt._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {a : α}, (s.erase a < s) = (a ∈ s) |
Std.ExtDHashMap.containsThenInsert.congr_simp | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
(m m_1 : Std.ExtDHashMap α β),
m = m_1 → ∀ (a : α) (b b_1 : β a), b = b_1 → m.containsThenInsert a b = m_1.containsThenInsert a b_1 |
_private.Mathlib.Analysis.Analytic.Basic.0.HasFPowerSeriesWithinOnBall.isBigO_image_sub_image_sub_deriv_principal._simp_1_4 | Mathlib.Analysis.Analytic.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False |
MeasureTheory.AEDisjoint.iUnion_right_iff | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {ι : Sort u_3} [Countable ι]
{t : ι → Set α}, MeasureTheory.AEDisjoint μ s (⋃ i, t i) ↔ ∀ (i : ι), MeasureTheory.AEDisjoint μ s (t i) |
Matrix.fromRows_mulVec | Mathlib.Data.Matrix.ColumnRowPartitioned | ∀ {R : Type u_1} {m₁ : Type u_3} {m₂ : Type u_4} {n : Type u_5} [inst : Semiring R] [inst_1 : Fintype n]
(A₁ : Matrix m₁ n R) (A₂ : Matrix m₂ n R) (v : n → R),
(A₁.fromRows A₂).mulVec v = Sum.elim (A₁.mulVec v) (A₂.mulVec v) |
_private.Aesop.Search.RuleSelection.0.Aesop.selectUnsafeRules.match_1 | Aesop.Search.RuleSelection | (motive : Option Aesop.UnsafeQueue → Sort u_1) →
(x : Option Aesop.UnsafeQueue) → ((rules : Aesop.UnsafeQueue) → motive (some rules)) → (Unit → motive none) → motive x |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.pair_injective._simp_1_5 | Mathlib.SetTheory.ZFC.Basic | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
le_of_mul_le_of_one_le | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ZeroLEOneClass R] [NeZero 1] [MulPosStrictMono R]
[PosMulMono R] {a b c : R}, a * c ≤ b → 0 ≤ b → 1 ≤ c → a ≤ b |
Subring.instField._proof_5 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] (q : ℚ), ↑q = ↑q.num / ↑q.den |
Std.Time.Month.instToStringOffset | Std.Time.Date.Unit.Month | ToString Std.Time.Month.Offset |
Lean.IR.EmitC.GroundState.rec | Lean.Compiler.IR.EmitC | {motive : Lean.IR.EmitC.GroundState → Sort u} →
((auxCounter : ℕ) → motive { auxCounter := auxCounter }) → (t : Lean.IR.EmitC.GroundState) → motive t |
UpperSet.instCompleteLinearOrder._proof_9 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LinearOrder α] (a b : UpperSet α), compare a b = compareOfLessAndEq a b |
Lean.Compiler.LCNF.Arg._sizeOf_inst | Lean.Compiler.LCNF.Basic | (pu : Lean.Compiler.LCNF.Purity) → SizeOf (Lean.Compiler.LCNF.Arg pu) |
CategoryTheory.cokernelOpUnop._proof_6 | Mathlib.CategoryTheory.Abelian.Opposite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C}
(f : X ⟶ Y), CategoryTheory.Limits.HasKernel f |
Std.ExtHashMap.getKeyD_inter_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k fallback : α}, k ∉ m₁ → (m₁ ∩ m₂).getKeyD k fallback = fallback |
IsScalarTower.Invertible.algebraTower._proof_1 | Mathlib.RingTheory.AlgebraTower | ∀ (S : Type u_1) (A : Type u_2) [inst : CommSemiring S] [inst_1 : Semiring A], MonoidHomClass (S →+* A) S A |
groupHomology.δ₀_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep k G)} (hX : X.ShortExact)
(z : ↥(groupHomology.cycles₁ X.X₃)) (y : G →₀ ↑X.X₂.V),
(Finsupp.mapRange.linearMap (ModuleCat.Hom.hom X.g.hom)) y = ↑z →
∀ (x : ↑X.X₁.V),
(CategoryTheory.ConcreteCategory.hom X.f.hom) x =
(CategoryTheory.ConcreteCategory.hom (groupHomology.d₁₀ X.X₂)) y →
(CategoryTheory.ConcreteCategory.hom (groupHomology.δ hX 1 0 ⋯))
((CategoryTheory.ConcreteCategory.hom (groupHomology.H1π X.X₃)) z) =
(CategoryTheory.ConcreteCategory.hom (groupHomology.H0π X.X₁)) x |
InformationTheory.not_differentiableAt_klFun_zero | Mathlib.InformationTheory.KullbackLeibler.KLFun | ¬DifferentiableAt ℝ InformationTheory.klFun 0 |
Set.Ioc.orderTop._proof_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α} [Fact (a < b)], IsGreatest (Set.Ioc a b) b |
eVariationOn.comp_eq_of_antitoneOn | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {E : Type u_2} [inst_1 : PseudoEMetricSpace E] {β : Type u_3}
[inst_2 : LinearOrder β] (f : α → E) {t : Set β} (φ : β → α),
AntitoneOn φ t → eVariationOn (f ∘ φ) t = eVariationOn f (φ '' t) |
Multiset.countP_cons_of_neg | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} (s : Multiset α),
¬p a → Multiset.countP p (a ::ₘ s) = Multiset.countP p s |
Std.ExtHashMap.erase_eq_empty_iff._simp_1 | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α}, (m.erase k = ∅) = (m = ∅ ∨ m.size = 1 ∧ k ∈ m) |
Function.funext_iff_of_subsingleton | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} [Subsingleton α] {g : α → β} (x y : α), f x = g y ↔ f = g |
Filter.tendsto_snd | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} {f : Filter α} {g : Filter β}, Filter.Tendsto Prod.snd (f ×ˢ g) g |
Std.DTreeMap.Raw.inter | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} → Std.DTreeMap.Raw α β cmp → Std.DTreeMap.Raw α β cmp → Std.DTreeMap.Raw α β cmp |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.maxKey?_modify_eq_maxKey?._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) |
Lean.Server.References.casesOn | Lean.Server.References | {motive : Lean.Server.References → Sort u} →
(t : Lean.Server.References) →
((ileans : Lean.Server.ILeanMap) →
(workers : Lean.Server.WorkerRefMap) → motive { ileans := ileans, workers := workers }) →
motive t |
OnePoint.isOpen_range_coe | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], IsOpen (Set.range OnePoint.some) |
Aesop.elabGlobalRuleIdent | Aesop.Builder.Basic | Aesop.BuilderName → Lean.Term → Lean.Elab.TermElabM Lean.Name |
Ordinal.partialOrder.match_15 | Mathlib.SetTheory.Ordinal.Basic | ∀ (x x_1 : WellOrder)
(motive :
⟦x⟧.liftOn₂ ⟦x_1⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯ ∧
¬⟦x_1⟧.liftOn₂ ⟦x⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯ →
Prop)
(x_2 :
⟦x⟧.liftOn₂ ⟦x_1⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯ ∧
¬⟦x_1⟧.liftOn₂ ⟦x⟧
(fun x x_2 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_2 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯),
(∀ (f : InitialSeg x.r x_1.r)
(h :
¬⟦x_1⟧.liftOn₂ ⟦x⟧
(fun x x_3 =>
match x with
| { α := α, r := r, wo := wo } =>
match x_3 with
| { α := α_1, r := s, wo := wo } => Nonempty (InitialSeg r s))
⋯),
motive ⋯) →
motive x_2 |
pow_lt_pow_iff_right_of_lt_one₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : PartialOrder M₀] {a : M₀} {m n : ℕ} [PosMulStrictMono M₀],
0 < a → a < 1 → (a ^ m < a ^ n ↔ n < m) |
_private.Mathlib.Data.Int.Init.0.Int.le_induction._proof_1_5 | Mathlib.Data.Int.Init | ∀ {m : ℤ} (k : ℤ), m + -1 * k + -1 ≤ 0 → m ≤ k + 1 |
CategoryTheory.Limits.Multicofork.IsColimit.isPushout.multicofork | Mathlib.CategoryTheory.Limits.Shapes.MultiequalizerPullback | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{J : CategoryTheory.Limits.MultispanShape} →
[inst_1 : Unique J.L] →
{I : CategoryTheory.Limits.MultispanIndex J C} →
{J.fst default, J.snd default} = Set.univ →
J.fst default ≠ J.snd default →
CategoryTheory.Limits.PushoutCocone (I.fst default) (I.snd default) → CategoryTheory.Limits.Multicofork I |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Proof.0.Lean.Meta.Grind.Arith.CommRing.caching | Lean.Meta.Tactic.Grind.Arith.CommRing.Proof | {α : Type u_1} → α → Lean.Meta.Grind.Arith.CommRing.ProofM Lean.Expr → Lean.Meta.Grind.Arith.CommRing.ProofM Lean.Expr |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkChainResult.go | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic →
Array (Array (Lean.TSyntax `tactic)) →
ℕ →
List (Lean.TSyntax `tactic) →
Option Lean.SyntaxNodeKind → StateT (Array (Lean.TSyntax `tactic)) Lean.Elab.Tactic.Try.TryTacticM Unit |
_private.Mathlib.NumberTheory.ModularForms.DedekindEta.0.ModularForm.logDeriv_eta_eq_E2._proof_1_8 | Mathlib.NumberTheory.ModularForms.DedekindEta | ∀ (z : UpperHalfPlane),
2 * ↑Real.pi * Complex.I / 24 +
∑' (x : ℕ),
2 * ↑Real.pi * Complex.I *
(-((↑x + 1) * Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1)) /
(1 - Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1))) =
↑Real.pi * Complex.I / 12 * (6 / ↑Real.pi ^ 2 * 2⁻¹ * (2 * (↑Real.pi ^ 2 / 6))) +
∑' (x : ℕ),
-(↑Real.pi * Complex.I / 12 *
(6 / ↑Real.pi ^ 2 * 2⁻¹ *
(8 * ↑Real.pi ^ 2 *
((↑x + 1) * Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1) /
(1 - Complex.exp (2 * ↑Real.pi * Complex.I * ↑z) ^ (x + 1)))))) |
CochainComplex.mappingCone.shiftTrianglehIso | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
{K L : CochainComplex C ℤ} →
(φ : K ⟶ L) →
(n : ℤ) →
(CategoryTheory.Pretriangulated.Triangle.shiftFunctor (HomotopyCategory C (ComplexShape.up ℤ)) n).obj
(CochainComplex.mappingCone.triangleh φ) ≅
CochainComplex.mappingCone.triangleh ((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).map φ) |
CategoryTheory.Arrow.mapCechConerve._proof_1 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.Arrow C}
[inst_1 : ∀ (n : ℕ), CategoryTheory.Limits.HasWidePushout g.left (fun x => g.right) fun x => g.hom] (F : f ⟶ g)
(n : SimplexCategory) (i : Fin (n.len + 1)),
CategoryTheory.CategoryStruct.comp f.hom
((fun i => CategoryTheory.CategoryStruct.comp F.right (CategoryTheory.Limits.WidePushout.ι (fun x => g.hom) i))
i) =
CategoryTheory.CategoryStruct.comp F.left (CategoryTheory.Limits.WidePushout.head fun x => g.hom) |
NonUnitalNonAssocSemiring.directSumGNonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.DirectSum.Ring | ∀ (ι : Type u_2) {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {i j : ι} (a b c : R), (a + b) * c = a * c + b * c |
Aesop.Index.mk.injEq | Aesop.Index | ∀ {α : Type} (byTarget byHyp : Lean.Meta.DiscrTree (Aesop.Rule α)) (unindexed : Lean.PHashSet (Aesop.Rule α))
(byTarget_1 byHyp_1 : Lean.Meta.DiscrTree (Aesop.Rule α)) (unindexed_1 : Lean.PHashSet (Aesop.Rule α)),
({ byTarget := byTarget, byHyp := byHyp, unindexed := unindexed } =
{ byTarget := byTarget_1, byHyp := byHyp_1, unindexed := unindexed_1 }) =
(byTarget = byTarget_1 ∧ byHyp = byHyp_1 ∧ unindexed = unindexed_1) |
Lean.Meta.Grind.GoalState.newRawFacts | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.GoalState → Std.Queue Lean.Meta.Grind.NewRawFact |
HomotopicalAlgebra.Cylinder.instCofibrationI₁ | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.Cylinder A)
[inst_2 : CategoryTheory.Limits.HasBinaryCoproduct A A] [inst_3 : HomotopicalAlgebra.CategoryWithCofibrations C]
[inst_4 : CategoryTheory.Limits.HasInitial C] [(HomotopicalAlgebra.cofibrations C).IsStableUnderComposition]
[(HomotopicalAlgebra.cofibrations C).IsStableUnderCobaseChange] [HomotopicalAlgebra.IsCofibrant A] [P.IsGood],
HomotopicalAlgebra.Cofibration P.i₁ |
BoxIntegral.Box.lower_lt_upper._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_2} (self : BoxIntegral.Box ι) (i : ι), (self.lower i < self.upper i) = True |
_private.Mathlib.RingTheory.Valuation.ValuativeRel.Basic.0.ValuativeRel.ValueGroupWithZero.embed._simp_10 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False |
_private.Mathlib.CategoryTheory.Galois.Prorepresentability.0.CategoryTheory.PreGaloisCategory.PointedGaloisObject.instIsCofilteredOrEmpty.match_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (motive : CategoryTheory.PreGaloisCategory.PointedGaloisObject F → Prop)
(x : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(∀ (B : C) (b : (F.obj B).carrier) (isGalois : CategoryTheory.PreGaloisCategory.IsGalois B),
motive { obj := B, pt := b, isGalois := isGalois }) →
motive x |
RecursiveIn.below.left | Mathlib.Computability.RecursiveIn | ∀ {O : Set (ℕ →. ℕ)} {motive : (a : ℕ →. ℕ) → RecursiveIn O a → Prop}, RecursiveIn.below ⋯ |
Lean.Meta.UnificationHintEntry.mk.sizeOf_spec | Lean.Meta.UnificationHint | ∀ (keys : Array Lean.Meta.UnificationHintKey) (val : Lean.Name),
sizeOf { keys := keys, val := val } = 1 + sizeOf keys + sizeOf val |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.ae_withDensity_iff_ae_restrict'._simp_1_2 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {a b : Prop}, (a = b) = (a ↔ b) |
_private.Mathlib.Data.List.Cycle.0.Cycle.next_reverse_eq_prev._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Cycle α) (hs : s.Nodup) (x : α) (hx : x ∈ s),
s.next hs x hx = s.reverse.prev ⋯ x ⋯ |
CategoryTheory.monoidalUnopUnop._proof_14 | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y : Cᵒᵖᵒᵖ} (X' : Cᵒᵖᵒᵖ) (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' X)))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.unopUnop C).obj X')
((CategoryTheory.unopUnop C).map f)) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.unopUnop C).map (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X' f))
(CategoryTheory.CategoryStruct.id
((CategoryTheory.unopUnop C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X' Y))) |
_private.Mathlib.Analysis.InnerProductSpace.TwoDim.0.Orientation.wrapped._proof_1._@.Mathlib.Analysis.InnerProductSpace.TwoDim.1773570744._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | @Orientation.definition✝ = @Orientation.definition✝ |
_private.Init.Data.List.Sort.Lemmas.0.List.mergeSort.match_1.eq_2 | Init.Data.List.Sort.Lemmas | ∀ {α : Type u_1} (motive : List α → (α → α → Bool) → Sort u_2) (a : α) (x : α → α → Bool)
(h_1 : (x : α → α → Bool) → motive [] x) (h_2 : (a : α) → (x : α → α → Bool) → motive [a] x)
(h_3 : (a b : α) → (xs : List α) → (le : α → α → Bool) → motive (a :: b :: xs) le),
(match [a], x with
| [], x => h_1 x
| [a], x => h_2 a x
| a :: b :: xs, le => h_3 a b xs le) =
h_2 a x |
CommSemiRingCat.forget₂SemiRing_preservesLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}],
CategoryTheory.Limits.PreservesLimitsOfSize.{w, v, u, u, u + 1, u + 1}
(CategoryTheory.forget₂ CommSemiRingCat SemiRingCat) |
TrivSqZeroExt.instL1NormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : NormedRing R] [inst_1 : NormedAddCommGroup M] (a b : TrivSqZeroExt R M),
a + b = b + a |
_private.Init.Data.Array.Range.0.Array.mem_zipIdx._proof_1 | Init.Data.Array.Range | ∀ {α : Type u_1} {x : α} {i : ℕ} {xs : Array α} {k : ℕ},
k ≤ (x, i).2 → (x, i).2 < k + xs.size → ¬i - k < xs.size → False |
HomogeneousIdeal.instMax._proof_1 | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : DecidableEq ι] [inst_2 : AddMonoid ι]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_5 : GradedRing 𝒜]
(I J : HomogeneousIdeal 𝒜), Ideal.IsHomogeneous 𝒜 (I.toIdeal ⊔ J.toIdeal) |
Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.ctorElim | Lean.Elab.GuardMsgs | {motive : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Tactic.GuardMsgs.WhitespaceMode) →
ctorIdx = t.ctorIdx → Lean.Elab.Tactic.GuardMsgs.WhitespaceMode.ctorElimType ctorIdx → motive t |
SimpleGraph.induceHomOfLE | Mathlib.Combinatorics.SimpleGraph.Maps | {V : Type u_1} → (G : SimpleGraph V) → {s s' : Set V} → s ≤ s' → SimpleGraph.induce s G ↪g SimpleGraph.induce s' G |
Monoid.CoprodI.Word.rcons_eq_smul | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : DecidableEq ι]
[inst_2 : (i : ι) → DecidableEq (M i)] {i : ι} (p : Monoid.CoprodI.Word.Pair M i),
Monoid.CoprodI.Word.rcons p = Monoid.CoprodI.of p.head • p.tail |
AlgEquiv.isTranscendenceBasis | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {A' : Type v'} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A]
[inst_2 : CommRing A'] [inst_3 : Algebra R A] [inst_4 : Algebra R A'] (e : A ≃ₐ[R] A'),
IsTranscendenceBasis R x → IsTranscendenceBasis R (⇑e ∘ x) |
AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.instIsIsoInvApp | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : AlgebraicGeometry.PresheafedSpace C} (f : X ⟶ Y)
[H : AlgebraicGeometry.PresheafedSpace.IsOpenImmersion f] (U : TopologicalSpace.Opens ↑↑X),
CategoryTheory.IsIso (AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.invApp f U) |
Std.TreeMap.getKeyD_eq_fallback | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
a ∉ t → t.getKeyD a fallback = fallback |
BoxIntegral.Box.coe_subset_coe._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, (↑I ⊆ ↑J) = (I ≤ J) |
OrderTopology.t5Space | Mathlib.Topology.Order.T5 | ∀ {X : Type u_1} [inst : LinearOrder X] [inst_1 : TopologicalSpace X] [OrderTopology X], T5Space X |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_6 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
(X Y Z : P.FullSubcategory),
P
(CategoryTheory.MonoidalCategoryStruct.tensorObj X.obj
{ obj := CategoryTheory.MonoidalCategoryStruct.tensorObj Y.obj Z.obj, property := ⋯ }.obj) |
Std.DHashMap.Internal.Raw₀.contains_insertMany_list | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List ((a : α) × β a)} {k : α},
(↑(m.insertMany l)).contains k = (m.contains k || (List.map Sigma.fst l).contains k) |
_private.Lean.Compiler.LCNF.ToImpure.0.Lean.Compiler.LCNF.lowerResultType.resultTypeForArity._sparseCasesOn_2 | Lean.Compiler.LCNF.ToImpure | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Lean.Server.Rpc.RequestHandling.0.Lean.Server.wrapRpcProcedure.match_1 | Lean.Server.Rpc.RequestHandling | (paramType : Type) →
(motive : Id (Except String paramType) → Sort u_1) →
(x : Id (Except String paramType)) →
((v : paramType) → motive (Except.ok v)) → ((e : String) → motive (Except.error e)) → motive x |
convexHullAddMonoidHom | Mathlib.Analysis.Convex.Combination | (R : Type u_1) →
(E : Type u_3) →
[inst : Field R] →
[inst_1 : AddCommGroup E] → [Module R E] → [inst_3 : LinearOrder R] → [IsStrictOrderedRing R] → Set E →+ Set E |
_private.Mathlib.GroupTheory.Complement.0.Subgroup.instMulActionLeftTransversal._simp_1 | Mathlib.GroupTheory.Complement | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) |
Mathlib.Tactic.Widget.StringDiagram.PenroseVar.e | Mathlib.Tactic.Widget.StringDiagram | Mathlib.Tactic.Widget.StringDiagram.PenroseVar → Lean.Expr |
HomotopicalAlgebra.instIsStableUnderBaseChangeFibrations | Mathlib.AlgebraicTopology.ModelCategory.Instances | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
[inst_2 : HomotopicalAlgebra.CategoryWithCofibrations C] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
[(HomotopicalAlgebra.trivialCofibrations C).IsWeakFactorizationSystem (HomotopicalAlgebra.fibrations C)],
(HomotopicalAlgebra.fibrations C).IsStableUnderBaseChange |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.getElem?_toList_eq.match_1_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u_1} (motive : Option α → Prop) (x : Option α),
(x = none → motive none) → (∀ (next : α), x = some next → motive (some next)) → motive x |
CategoryTheory.Idempotents.Karoubi.decompId_p._proof_1 | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.Idempotents.Karoubi C),
CategoryTheory.CategoryStruct.comp { X := P.X, p := CategoryTheory.CategoryStruct.id P.X, idem := ⋯ }.p
(CategoryTheory.CategoryStruct.comp P.p P.p) =
P.p |
Std.DTreeMap.Internal.Impl.get!_eq_getValueCast! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [instBEq : BEq α] [inst : Ord α] [inst_1 : Std.LawfulBEqOrd α] [Std.TransOrd α]
[inst_3 : Std.LawfulEqOrd α] {k : α} [inst_4 : Inhabited (β k)] {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get! k = Std.Internal.List.getValueCast! k t.toListModel |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.sheafedSpace_pullback_fst_of_right | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (f : X ⟶ Z)
(g : Y ⟶ Z) [H : AlgebraicGeometry.SheafedSpace.IsOpenImmersion f],
AlgebraicGeometry.SheafedSpace.IsOpenImmersion (CategoryTheory.Limits.pullback.fst g f) |
CategoryTheory.FreeBicategory.comp_def | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.FreeBicategory.Hom.comp f g = CategoryTheory.CategoryStruct.comp f g |
Pi.smulZeroClass | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
(α : Type u_1) → {n : (i : I) → Zero (f i)} → [(i : I) → SMulZeroClass α (f i)] → SMulZeroClass α ((i : I) → f i) |
Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit_emptyWithCapacity_list_cons | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {hd : α} {tl : List α},
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit Std.DHashMap.Internal.Raw₀.emptyWithCapacity (hd :: tl)) =
↑(Std.DHashMap.Internal.Raw₀.Const.insertManyIfNewUnit
(Std.DHashMap.Internal.Raw₀.emptyWithCapacity.insertIfNew hd ()) tl) |
Fin.partialProd_contractNth | Mathlib.Algebra.BigOperators.Fin | ∀ {G : Type u_3} [inst : Monoid G] {n : ℕ} (g : Fin (n + 1) → G) (a : Fin (n + 1)),
Fin.partialProd (a.contractNth (fun x1 x2 => x1 * x2) g) = Fin.partialProd g ∘ a.succ.succAbove |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.