name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Turing.ToPartrec.stepRet.eq_def | Mathlib.Computability.TuringMachine.Config | ∀ (x : Turing.ToPartrec.Cont) (x_1 : List ℕ),
Turing.ToPartrec.stepRet x x_1 =
match x, x_1 with
| Turing.ToPartrec.Cont.halt, v => Turing.ToPartrec.Cfg.halt v
| Turing.ToPartrec.Cont.cons₁ fs as k, v => Turing.ToPartrec.stepNormal fs (Turing.ToPartrec.Cont.cons₂ v k) as
| Turing.ToPartrec.Cont.cons₂ ... | null | true |
MeasurableEquiv.curry_apply | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ (ι : Type u_6) (κ : Type u_7) (X : Type u_8) [inst : MeasurableSpace X] (a : ι × κ → X) (a_1 : ι) (a_2 : κ),
(MeasurableEquiv.curry ι κ X) a a_1 a_2 = a (a_1, a_2) | null | true |
Prod.instCompleteAtomicBooleanAlgebra._proof_9 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteAtomicBooleanAlgebra α] [inst_1 : CompleteAtomicBooleanAlgebra β]
(x : α × β), x ⊓ xᶜ ≤ ⊥ | null | false |
Polynomial.le_gaussNorm | Mathlib.RingTheory.Polynomial.GaussNorm | ∀ {R : Type u_1} {F : Type u_2} [inst : Semiring R] [inst_1 : FunLike F R ℝ] (v : F) {c : ℝ} (p : Polynomial R)
[ZeroHomClass F R ℝ] [NonnegHomClass F R ℝ], 0 ≤ c → ∀ (i : ℕ), v (p.coeff i) * c ^ i ≤ Polynomial.gaussNorm v c p | null | true |
Function.Injective.mulOneClass._proof_2 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_2} {M₂ : Type u_1} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : MulOneClass M₂] (f : M₁ → M₂),
f 1 = 1 → (∀ (x y : M₁), f (x * y) = f x * f y) → ∀ (x : M₁), f (x * 1) = f x | null | false |
Std.ExtDHashMap.getKey?_modify | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α] {k k' : α}
{f : β k → β k}, (m.modify k f).getKey? k' = if (k == k') = true then if k ∈ m then some k else none else m.getKey? k' | null | true |
String.Pos.get?_eq_some_get | Init.Data.String.Lemmas.Slice | ∀ {s : String} {p : s.Pos} (h : p ≠ s.endPos), p.get? = some (p.get h) | null | true |
WeierstrassCurve.toCharTwoNF_spec | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {F : Type u_2} [inst : Field F] [CharP F 2] (W : WeierstrassCurve F) [inst_2 : DecidableEq F],
(W.toCharTwoNF • W).IsCharTwoNF | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.toBitVec_eq_of_isInvalidContinuationByte_eq_false | Init.Data.String.Decode | ∀ {b : UInt8},
ByteArray.utf8DecodeChar?.isInvalidContinuationByte b = false → b.toBitVec = 2#2 ++ BitVec.setWidth 6 b.toBitVec | null | true |
inf_sup_self | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : Lattice α] {a b : α}, a ⊓ (a ⊔ b) = a | null | true |
Lean.Lsp.LeanIdentifier.mk._flat_ctor | Lean.Data.Lsp.Internal | Lean.Name → Lean.Name → Bool → Lean.Lsp.LeanIdentifier | null | false |
CategoryTheory.Preadditive.epi_of_cokernel_zero | Mathlib.CategoryTheory.Preadditive.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C} {f : X ⟶ Y}
[inst_2 : CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.parallelPair f 0)],
CategoryTheory.Limits.cokernel.π f = 0 → CategoryTheory.Epi f | null | true |
MonCat.ofHom_hom | Mathlib.Algebra.Category.MonCat.Basic | ∀ {M N : MonCat} (f : M ⟶ N), MonCat.ofHom (MonCat.Hom.hom f) = f | null | true |
_private.Lean.Meta.WHNF.0.Lean.Meta.whnfCore.go._unsafe_rec | Lean.Meta.WHNF | Lean.Expr → Lean.MetaM Lean.Expr | null | false |
ZMod.ringEquivOfPrime | Mathlib.Data.ZMod.Basic | (R : Type u_1) → [inst : Ring R] → [inst_1 : Fintype R] → {p : ℕ} → Nat.Prime p → Fintype.card R = p → ZMod p ≃+* R | The unique ring isomorphism between `ZMod p` and a ring `R` of cardinality a prime `p`.
If you need any property of this isomorphism, first of all use `ringEquivOfPrime_eq_ringEquiv`
below (after `have : CharP R p := ...`) and deduce it by the results about `ZMod.ringEquiv`. | true |
ZMod.ringEquivCongr._proof_1 | Mathlib.Data.ZMod.Basic | ∀ (m n : ℕ) (h : m + 1 = n + 1) (a b : ZMod (m + 1)),
(finCongr h).toFun (a * b) = (finCongr h).toFun a * (finCongr h).toFun b | null | false |
isotypicComponents | Mathlib.RingTheory.SimpleModule.Isotypic | (R : Type u_2) →
(M : Type u) → [inst : Ring R] → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → Set (Submodule R M) | The set of all (nontrivial) isotypic components of a module. | true |
Bundle.Trivialization.liftCM.eq_1 | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {Z : Type u_4} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F] {proj : Z → B}
[inst_2 : TopologicalSpace Z] (T : Bundle.Trivialization F proj),
T.liftCM = { toFun := fun ex => ⟨T.lift ↑ex.1 ↑ex.2, ⋯⟩, continuous_toFun := ⋯ } | null | true |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.insertMany_list_eq_empty_iff._simp_1_1 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [Std.TransCmp cmp],
(t = ∅) = (t.isEmpty = true) | null | false |
_private.Std.Sat.CNF.Dimacs.0.Std.Sat.CNF.DimacsState.numClauses._default | Std.Sat.CNF.Dimacs | ℕ | null | false |
System.Uri.UriEscape.letterF | Init.System.Uri | UInt8 | null | true |
CategoryTheory.FreeBicategory.mk_associator_hom | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] {a b c d : CategoryTheory.FreeBicategory B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
Quot.mk CategoryTheory.FreeBicategory.Rel (CategoryTheory.FreeBicategory.Hom₂.associator f g h) =
(CategoryTheory.Bicategory.associator f g h).hom | null | true |
Lean.Meta.LazyDiscrTree.instInhabitedKey | Lean.Meta.LazyDiscrTree | Inhabited Lean.Meta.LazyDiscrTree.Key | null | true |
Aesop.SearchM.State.mk._flat_ctor | Aesop.Search.SearchM | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.Iteration → Q → Bool → Aesop.SearchM.State Q | null | false |
_private.Mathlib.Tactic.Simps.Basic.0.NameStruct.mk.inj | Mathlib.Tactic.Simps.Basic | ∀ {parent : Lean.Name} {components : List String} {parent_1 : Lean.Name} {components_1 : List String},
{ parent := parent, components := components } = { parent := parent_1, components := components_1 } →
parent = parent_1 ∧ components = components_1 | null | true |
WeierstrassCurve.Projective.dblZ_ne_zero_of_Y_ne' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} [NoZeroDivisors R] {P Q : Fin 3 → R},
W'.Equation P →
W'.Equation Q → P 2 ≠ 0 → Q 2 ≠ 0 → P 0 * Q 2 = Q 0 * P 2 → P 1 * Q 2 ≠ W'.negY Q * P 2 → W'.dblZ P ≠ 0 | null | true |
_private.Std.Time.Zoned.Database.TZdb.0.Std.Time.Database.TZdb.localRules.match_1 | Std.Time.Zoned.Database.TZdb | (motive : Option String → Sort u_1) →
(x : Option String) → ((id : String) → motive (some id)) → ((x : Option String) → motive x) → motive x | null | false |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.eval_single_add'._simp_1_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ {G : Type u_1} [inst : Add G] [IsLeftCancelAdd G] (a : G) {b c : G}, (a + b = a + c) = (b = c) | null | false |
Dioph.diophFn_vec_comp1 | Mathlib.NumberTheory.Dioph | ∀ {n : ℕ} {S : Set (Vector3 ℕ n.succ)},
Dioph S → ∀ {f : Vector3 ℕ n → ℕ}, Dioph.DiophFn f → Dioph {v | Vector3.cons (f v) v ∈ S} | null | true |
EuclideanGeometry.Sphere.self_mem_orthRadius | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : EuclideanGeometry.Sphere P) (p : P), p ∈ s.orthRadius p | null | true |
RingHom.map_adjugate | Mathlib.LinearAlgebra.Matrix.Adjugate | ∀ {n : Type v} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type u_1} {S : Type u_2} [inst_2 : CommRing R]
[inst_3 : CommRing S] (f : R →+* S) (M : Matrix n n R), f.mapMatrix M.adjugate = (f.mapMatrix M).adjugate | null | true |
_private.Mathlib.Computability.Language.0.Language.kstar_eq_iSup_pow._simp_1_2 | Mathlib.Computability.Language | ∀ {α : Type u_1} {ι : Sort v} {l : ι → Language α} {x : List α}, (x ∈ ⨆ i, l i) = ∃ i, x ∈ l i | null | false |
Multiset.mem_Ioc._simp_1 | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b x : α},
(x ∈ Multiset.Ioc a b) = (a < x ∧ x ≤ b) | null | false |
Lean.Meta.Grind.AC.MonadGetStruct.ctorIdx | Lean.Meta.Tactic.Grind.AC.Util | {m : Type → Type} → Lean.Meta.Grind.AC.MonadGetStruct m → ℕ | null | false |
_private.Mathlib.Analysis.Normed.Affine.AddTorsorBases.0.AffineBasis.centroid_mem_interior_convexHull._simp_1_2 | Mathlib.Analysis.Normed.Affine.AddTorsorBases | ∀ {α : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ},
(0 < ↑n) = (0 < n) | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.index_union_eq._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Std.PRange.UpwardEnumerable.succMany_eq_get | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] {n : ℕ} {a : α},
Std.PRange.succMany n a = (Std.PRange.succMany? n a).get ⋯ | null | true |
Lean.Expr.NumApps.State.casesOn | Lean.Util.NumApps | {motive : Lean.Expr.NumApps.State → Sort u} →
(t : Lean.Expr.NumApps.State) →
((visited : Lean.PtrSet Lean.Expr) →
(counters : Lean.NameMap ℕ) → motive { visited := visited, counters := counters }) →
motive t | null | false |
Dyadic.blt.eq_3 | Init.Data.Dyadic.Basic | ∀ (n k : ℤ) (hn : n % 2 = 1), (Dyadic.ofOdd n k hn).blt Dyadic.zero = decide (n < 0) | null | true |
Lean.Elab.Visibility.noConfusionType | Lean.Elab.DeclModifiers | Sort v✝ → Lean.Elab.Visibility → Lean.Elab.Visibility → Sort v✝ | null | true |
max_zero_add_max_neg_zero_eq_abs_self | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] (a : G),
max a 0 + max (-a) 0 = |a| | null | true |
Polynomial.ofFn._proof_1 | Mathlib.Algebra.Polynomial.OfFn | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : DecidableEq R] (n : ℕ) (x y : Fin n → R),
{ toFinsupp := (List.ofFn (x + y)).toFinsupp } =
{ toFinsupp := (List.ofFn x).toFinsupp } + { toFinsupp := (List.ofFn y).toFinsupp } | null | false |
Equiv.nonUnitalNonAssocRing._proof_3 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalNonAssocRing β] (x y : α),
e (e.symm (e x * e y)) = e x * e y | null | false |
PresheafOfModules.ofPresheaf_map | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : CategoryTheory.Functor Cᵒᵖ Ab) [inst_1 : (X : Cᵒᵖ) → Module ↑(R.obj X) ↑(M.obj X)]
(map_smul :
∀ ⦃X Y : Cᵒᵖ⦄ (f : X ⟶ Y) (r : ↑(R.obj X)) (m : ↑(M.obj X)),
(CategoryTheory.ConcreteCategory.hom (M.map ... | null | true |
GetElem.casesOn | Init.GetElem | {coll : Type u} →
{idx : Type v} →
{elem : Type w} →
{valid : coll → idx → Prop} →
{motive : GetElem coll idx elem valid → Sort u_1} →
(t : GetElem coll idx elem valid) →
((getElem : (xs : coll) → (i : idx) → valid xs i → elem) → motive { getElem := getElem }) → motive t | null | false |
Equiv.Perm.extendDomain_one | Mathlib.Algebra.Group.End | ∀ {α : Type u_4} {β : Type u_5} {p : β → Prop} [inst : DecidablePred p] (f : α ≃ Subtype p),
Equiv.Perm.extendDomain 1 f = 1 | null | true |
TopCat.prodIsoProd_hom_snd | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat),
CategoryTheory.CategoryStruct.comp (X.prodIsoProd Y).hom TopCat.prodSnd = CategoryTheory.Limits.prod.snd | null | true |
Lean.Elab.Do.DoElemContKind.noConfusion | Lean.Elab.Do.Basic | {P : Sort v✝} → {x y : Lean.Elab.Do.DoElemContKind} → x = y → Lean.Elab.Do.DoElemContKind.noConfusionType P x y | null | false |
MeasureTheory.Measure.ae_ae_eq_curry_of_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [MeasureTheory.SFinite ν] {γ : Type u_4} {f g : α × β → γ},
f =ᵐ[μ.prod ν] g → ∀ᵐ (x : α) ∂μ, Function.curry f x =ᵐ[ν] Function.curry g x | null | true |
DirectLimit.Ring.lift._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] (G : ι → Type u_3) {T : ⦃i j : ι⦄ → i ≤ j → Type u_4}
(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 : (i : ι) → NonAssocSemiring (G i)] (P : Type u_2) [inst_3 : NonAssocSemiring P] (g : (i : ι) → G i →+* P),
(∀ (... | null | false |
CategoryTheory.Bicategory.mateEquiv_symm_apply' | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {c d e f : B} {g : c ⟶ e} {h : d ⟶ f} {l₁ : c ⟶ d} {r₁ : d ⟶ c}
{l₂ : e ⟶ f} {r₂ : f ⟶ e} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂)
(β : CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.Catego... | null | true |
Int.Linear.Poly.divAll.eq_def | Init.Data.Int.Linear | ∀ (k : ℤ) (x : Int.Linear.Poly),
Int.Linear.Poly.divAll k x =
match x with
| Int.Linear.Poly.num k' => k' % k == 0
| Int.Linear.Poly.add k' v p => k' % k == 0 && Int.Linear.Poly.divAll k p | null | true |
Lean.ScopedEnvExtension.StateStack.recOn | Lean.ScopedEnvExtension | {α β σ : Type} →
{motive : Lean.ScopedEnvExtension.StateStack α β σ → Sort u} →
(t : Lean.ScopedEnvExtension.StateStack α β σ) →
((stateStack : List (Lean.ScopedEnvExtension.State σ)) →
(scopedEntries : Lean.ScopedEnvExtension.ScopedEntries β) →
(newEntries : List (Lean.ScopedEnvExtens... | null | false |
_private.Mathlib.RingTheory.Multiplicity.0.Nat.finiteMultiplicity_iff.match_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {b : ℕ} (motive : (a : ℕ) → (∀ (n : ℕ), a ^ n ∣ b) → a ≠ 0 → a ≠ 1 → a ≤ 1 → Prop) (a : ℕ) (h : ∀ (n : ℕ), a ^ n ∣ b)
(ha : a ≠ 0) (ha1 : a ≠ 1) (x : a ≤ 1),
(∀ (h : ∀ (n : ℕ), 0 ^ n ∣ b) (ha : 0 ≠ 0) (ha1 : 0 ≠ 1) (x : 0 ≤ 1), motive 0 h ha ha1 x) →
(∀ (h : ∀ (n : ℕ), 1 ^ n ∣ b) (ha : 1 ≠ 0) (ha1 : 1 ≠ 1) (x... | null | false |
Mathlib.Tactic._aux_Mathlib_Tactic_SplitIfs___elabRules_Mathlib_Tactic_splitIfs_1 | Mathlib.Tactic.SplitIfs | Lean.Elab.Tactic.Tactic | null | false |
norm_le_norm_div_add | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedGroup E] (a b : E), ‖a‖ ≤ ‖a / b‖ + ‖b‖ | null | true |
NonemptyInterval.length_nonneg | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_2} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α] (s : NonemptyInterval α),
0 ≤ s.length | null | true |
MeasureTheory.AnalyticSet.preimage | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {X : Type u_3} {Y : Type u_4} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [PolishSpace X] [T2Space Y]
{s : Set Y}, MeasureTheory.AnalyticSet s → ∀ {f : X → Y}, Continuous f → MeasureTheory.AnalyticSet (f ⁻¹' s) | Preimage of an analytic set is an analytic set. | true |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_16 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → 0 < (x :: y :: tail).length | null | false |
instMulActionSemiHomClassMulActionHom | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} (φ : M → N) (X : Type u_5) [inst : SMul M X] (Y : Type u_6) [inst_1 : SMul N Y],
MulActionSemiHomClass (X →ₑ[φ] Y) φ X Y | null | true |
ProbabilityTheory.Kernel.coe_mk | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (f : α → MeasureTheory.Measure β)
(hf : Measurable f), ⇑{ toFun := f, measurable' := hf } = f | null | true |
CommGroupWithZero.instNormalizedGCDMonoid._proof_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] {x y : G₀},
x ≠ 0 →
y ≠ 0 →
↑(if h : x * y = 0 then 1 else (Units.mk0 (x * y) h)⁻¹) =
↑((if h : x = 0 then 1 else (Units.mk0 x h)⁻¹) * if h : y = 0 then 1 else (Units.mk0 y h)⁻¹) | null | false |
List.attach_reverse | Init.Data.List.Attach | ∀ {α : Type u_1} {xs : List α},
xs.reverse.attach =
List.map
(fun x =>
match x with
| ⟨x, h⟩ => ⟨x, ⋯⟩)
xs.attach.reverse | null | true |
_private.Std.Http.Data.Body.Length.0.Std.Http.Body.instReprLength.repr.match_1 | Std.Http.Data.Body.Length | (motive : Std.Http.Body.Length → Sort u_1) →
(x : Std.Http.Body.Length) →
(Unit → motive Std.Http.Body.Length.chunked) → ((a : ℕ) → motive (Std.Http.Body.Length.fixed a)) → motive x | null | false |
AlgebraicGeometry.Scheme.Hom.normalizationDiagramMap._proof_1 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U V : (TopologicalSpace.Opens ↥Y)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (Y.presheaf.map i)
(CommRingCat.ofHom
(algebraMap ↑(Y.presheaf.obj (Opposite.op (Opposite.unop V)))
↥(integralClosure ↑(Y.presheaf.obj (Opposite.op (Opposite.uno... | null | false |
AlgebraicGeometry.Scheme.Cover.gluedCover._proof_4 | Mathlib.AlgebraicGeometry.Gluing | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (i j k : 𝒰.I₀),
CategoryTheory.Limits.HasPullback (CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f j))
(CategoryTheory.Limits.pullback.fst (𝒰.f i) (𝒰.f k)) | null | false |
MeasureTheory.VectorMeasure.equivMeasure_symm_apply | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α),
MeasureTheory.VectorMeasure.equivMeasure.symm μ = μ.toENNRealVectorMeasure | null | true |
ProofWidgets.RefreshComponent.RpcEncodablePacket.state._@.ProofWidgets.Component.RefreshComponent.1995342541._hygCtx._hyg.1 | ProofWidgets.Component.RefreshComponent | ProofWidgets.RefreshComponent.RpcEncodablePacket✝ → Lean.Json | null | false |
CommHopfAlgCat.isoMk._proof_4 | Mathlib.Algebra.Category.CommHopfAlgCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} {x : CommRing X} {x_1 : CommRing Y} {x_2 : HopfAlgebra R X}
{x_3 : HopfAlgebra R Y} (e : X ≃ₐc[R] Y),
CategoryTheory.CategoryStruct.comp (CommHopfAlgCat.ofHom ↑e.symm) (CommHopfAlgCat.ofHom ↑e) =
CategoryTheory.CategoryStruct.id { X := Y, commRing := x_1, ho... | null | false |
Dynamics.dynEntourage_univ | Mathlib.Dynamics.TopologicalEntropy.DynamicalEntourage | ∀ {X : Type u_1} {T : X → X} {n : ℕ}, Dynamics.dynEntourage T Set.univ n = Set.univ | null | true |
IsLowerSet.compl | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LE α] {s : Set α}, IsLowerSet s → IsUpperSet sᶜ | null | true |
Lean.Parser.Tactic.appendConfig | Init.Meta.Defs | Lean.Syntax → Lean.Syntax → Lean.TSyntax `Lean.Parser.Tactic.optConfig | Appends two tactic configurations.
The configurations can be `Lean.Parser.Tactic.optConfig`, `Lean.Parser.Tactic.config`,
or these wrapped in null nodes (for example because the syntax is `(config)?`).
| true |
RightCancelSemigroup.toSemigroup | Mathlib.Algebra.Group.Defs | {G : Type u} → [self : RightCancelSemigroup G] → Semigroup G | null | true |
BoxIntegral.Prepartition.mem_disjUnion._simp_1 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι} {π₁ π₂ : BoxIntegral.Prepartition I} (H : Disjoint π₁.iUnion π₂.iUnion),
(J ∈ π₁.disjUnion π₂ H) = (J ∈ π₁ ∨ J ∈ π₂) | null | false |
Std.DHashMap.Internal.AssocList.cons.injEq | Std.Data.DHashMap.Internal.AssocList.Basic | ∀ {α : Type u} {β : α → Type v} (key : α) (value : β key) (tail : Std.DHashMap.Internal.AssocList α β) (key_1 : α)
(value_1 : β key_1) (tail_1 : Std.DHashMap.Internal.AssocList α β),
(Std.DHashMap.Internal.AssocList.cons key value tail = Std.DHashMap.Internal.AssocList.cons key_1 value_1 tail_1) =
(key = key_1 ... | null | true |
Subfield.extendScalars_self | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {L : Type u_2} [inst : Field L] (F : Subfield L), Subfield.extendScalars ⋯ = ⊥ | null | true |
Subspace.quotAnnihilatorEquiv._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} [inst : Field K], RingHomCompTriple (RingHom.id K) (RingHom.id K) (RingHom.id K) | null | false |
Disjoint.exists_open_convexes | Mathlib.Topology.Algebra.Module.LocallyConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [ZeroLEOneClass 𝕜] [inst_3 : AddCommGroup E]
[inst_4 : Module 𝕜 E] [inst_5 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E]
[LocallyConvexSpace 𝕜 E] {s t : Set E},
Disjoint s t →
Convex 𝕜 s →
IsCo... | In a locally convex space, every two disjoint convex sets such that one is compact and the other
is closed admit disjoint convex open neighborhoods. | true |
MeasureTheory.diracProbaEquiv.congr_simp | Mathlib.MeasureTheory.Measure.DiracProba | ∀ {X : Type u_1} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : OpensMeasurableSpace X]
[inst_3 : T0Space X], MeasureTheory.diracProbaEquiv = MeasureTheory.diracProbaEquiv | null | true |
HomologicalComplex.HomologySequence.snakeInput._proof_33 | Mathlib.Algebra.Homology.HomologySequence | 2 < 3 + 1 | null | false |
Mathlib.Deriving.Fintype.«_aux_Mathlib_Tactic_DeriveFintype___macroRules_Mathlib_Deriving_Fintype_termDerive_fintype%__1» | Mathlib.Tactic.DeriveFintype | Lean.Macro | The term elaborator `derive_fintype% α` tries to synthesize a `Fintype α` instance
using all the assumptions in the local context; this can be useful, for example, if one
needs an extra `DecidableEq` instance. It works only if `α` is an inductive
type that `proxy_equiv% α` can handle. The elaborator makes use of the
ex... | false |
_private.Lean.Elab.DocString.0.Lean.Doc.InternalState.mk.injEq | Lean.Elab.DocString | ∀ (footnotes : Std.HashMap String (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)))
(urls : Std.HashMap String (Lean.Doc.Ref✝ String))
(footnotes_1 : Std.HashMap String (Lean.Doc.Ref✝ (Lean.Doc.Inline Lean.ElabInline)))
(urls_1 : Std.HashMap String (Lean.Doc.Ref✝ String)),
({ footnotes := footnotes, urls := ur... | null | true |
CategoryTheory.Limits.ReflectsLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` reflects limits if
whenever the image of a cone over some `K : J ⥤ C` under `F` is a limit cone in `D`,
the cone was already a limit cone in `C`.
Note that we do not assume a priori that `D` actually has any limits.
| true |
Matroid.uniqueBaseOn_isBase_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E B I : Set α}, I ⊆ E → ((Matroid.uniqueBaseOn I E).IsBase B ↔ B = I) | null | true |
ascPochhammer_zero | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (S : Type u) [inst : Semiring S], ascPochhammer S 0 = 1 | null | true |
Matroid.Indep.exists_insert_of_not_maximal | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) ⦃I B : Set α⦄,
M.Indep I → ¬Maximal M.Indep I → Maximal M.Indep B → ∃ x ∈ B \ I, M.Indep (insert x I) | This is the same as `Indep.exists_insert_of_not_isBase`, but phrased so that
it is defeq to the augmentation axiom for independent sets. | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_268 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
CategoryTheory.Limits.hasPullback_unop_iff_hasPushout._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᵒᵖ} (f : X ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.HasPullback f.unop g.unop = CategoryTheory.Limits.HasPushout f g | null | false |
and_imp_left_iff_true | Init.PropLemmas | ∀ {P Q : Prop}, P ∧ Q → P ↔ True | null | true |
LieModule.iSupIndep_genWeightSpace | Mathlib.Algebra.Lie.Weights.Basic | ∀ (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] [IsDomain R] [Module.IsTorsionFree R M],
iSupIndep fun χ => Lie... | Lie module weight spaces are independent.
See also `LieModule.iSupIndep_genWeightSpace'`. | true |
Lean.Meta.Cases.Context.recOn | Lean.Meta.Tactic.Cases | {motive : Lean.Meta.Cases.Context → Sort u} →
(t : Lean.Meta.Cases.Context) →
((inductiveVal : Lean.InductiveVal) →
(nminors : ℕ) →
(majorDecl : Lean.LocalDecl) →
(majorTypeFn : Lean.Expr) →
(majorTypeArgs majorTypeIndices : Array Lean.Expr) →
motive
... | null | false |
Submodule.comapSubtypeEquivOfLe._proof_3 | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (x : ↥(Submodule.comap q.subtype p)), ↑x ∈ Submodule.comap q.subtype p | null | false |
AddGrpCat.instConcreteCategoryAddMonoidHomCarrier._proof_2 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddGrpCat} (f : X ⟶ Y), { hom' := f.hom' } = f | null | false |
FractionalIdeal.coeIdeal_mul._simp_1 | Mathlib.RingTheory.FractionalIdeal.Basic | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
(I J : Ideal R), ↑I * ↑J = ↑(I * J) | null | false |
Aesop.TreeM.Context.mk.noConfusion | Aesop.Tree.TreeM | {P : Sort u} →
{currentIteration : Aesop.Iteration} →
{ruleSet : Aesop.LocalRuleSet} →
{currentIteration' : Aesop.Iteration} →
{ruleSet' : Aesop.LocalRuleSet} →
{ currentIteration := currentIteration, ruleSet := ruleSet } =
{ currentIteration := currentIteration', ruleSet := ... | null | false |
Sym2.diagElemEquiv._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x : { a // a.IsDiag }), (↑x).IsDiag | null | false |
CategoryTheory.ShortComplex.LeftHomologyMapData.compatibilityOfZerosOfIsColimitCokernelCofork._proof_3 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (hg : S.g = 0) (c : CategoryTheory.Limits.CokernelCofork S.f)
(hc : CategoryTheory.Limits.IsColimit c),
CategoryTheory.CategoryStruct.comp (Category... | null | false |
Std.IterM.DefaultConsumers.forIn'_eq_forIn'._unary | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type w'} {α β : Type w} [inst : Std.Iterator α m β] {n : Type x → Type x'} [inst_1 : Monad n]
[LawfulMonad n] {lift : (γ : Type w) → (δ : Type x) → (γ → n δ) → m γ → n δ} {γ : Type x} {P Q : β → Prop}
(Pl : β → γ → ForInStep γ → Prop) {f : (b : β) → P b → (c : γ) → n (Subtype (Pl b c))}
{g : (b : ... | null | false |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IicProdIoc_preimage._simp_1_2 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} {f : (i : ι) → α i},
(f ∈ s.pi t) = ∀ i ∈ s, f i ∈ t i | null | false |
FormalMultilinearSeries.applyComposition_ones | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : CommRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F]
[inst_3 : Module 𝕜 E] [inst_4 : Module 𝕜 F] [inst_5 : TopologicalSpace E] [inst_6 : TopologicalSpace F]
[inst_7 : IsTopologicalAddGroup E] [inst_8 : ContinuousConstSMul 𝕜 E] [inst_9 : IsTopolo... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.