name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Equiv.boolEquivPUnitSumPUnit._proof_1 | Mathlib.Logic.Equiv.Sum | ∀ (b : Bool),
Sum.elim (fun x => false) (fun x => true) ((fun b => Bool.casesOn b (Sum.inl PUnit.unit) (Sum.inr PUnit.unit)) b) = b |
Antivary.of_inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Antivary f g⁻¹ → Monovary f g |
CategoryTheory.PreservesPullbacksOfInclusions.rec | Mathlib.CategoryTheory.Extensive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] →
{motive : CategoryTheory.PreservesPullbacksOfInclusions F → Sort u} →
([preservesPullbackInl :
∀ {X Y Z : C} (f : Z ⟶ X ⨿ Y),
CategoryTheory.Limits.PreservesLimit
(CategoryTheory.Limits.cospan CategoryTheory.Limits.coprod.inl f) F] →
motive ⋯) →
(t : CategoryTheory.PreservesPullbacksOfInclusions F) → motive t |
_private.Mathlib.Analysis.Convex.Between.0.sbtw_neg_iff._simp_1_1 | Mathlib.Analysis.Convex.Between | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a : G), -a = 0 - a |
RatFunc.liftRingHom_ofFractionRing_algebraMap | Mathlib.FieldTheory.RatFunc.Basic | ∀ {L : Type u_2} {R : Type u_3} [inst : Field L] [inst_1 : CommRing R] (φ : Polynomial R →+* L)
(hφ : nonZeroDivisors (Polynomial R) ≤ Submonoid.comap φ (nonZeroDivisors L)) (x : Polynomial R),
(RatFunc.liftRingHom φ hφ) { toFractionRing := (algebraMap (Polynomial R) (FractionRing (Polynomial R))) x } = φ x |
Std.Sat.AIG.mkGateCached.go._proof_1 | Std.Sat.AIG.Cached | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (decls : Array (Std.Sat.AIG.Decl α))
(cache : Std.Sat.AIG.Cache α decls) (hdag : Std.Sat.AIG.IsDAG α decls) (hzero : 0 < decls.size)
(hconst : decls[0] = Std.Sat.AIG.Decl.false)
(input : { decls := decls, cache := cache, hdag := hdag, hzero := hzero, hconst := hconst }.BinaryInput),
input.lhs.gate < { decls := decls, cache := cache, hdag := hdag, hzero := hzero, hconst := hconst }.decls.size |
List.card_toFinset | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), l.toFinset.card = l.dedup.length |
WittVector.IsocrystalHom._sizeOf_1 | Mathlib.RingTheory.WittVector.Isocrystal | {p : ℕ} →
{inst : Fact (Nat.Prime p)} →
{k : Type u_1} →
{inst_1 : CommRing k} →
{inst_2 : CharP k p} →
{inst_3 : PerfectRing k p} →
{V : Type u_2} →
{inst_4 : AddCommGroup V} →
{inst_5 : WittVector.Isocrystal p k V} →
{V₂ : Type u_3} →
{inst_6 : AddCommGroup V₂} →
{inst_7 : WittVector.Isocrystal p k V₂} →
[SizeOf k] → [SizeOf V] → [SizeOf V₂] → WittVector.IsocrystalHom p k V V₂ → ℕ |
Polynomial.Monic.eq_one_of_isUnit | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → IsUnit p → p = 1 |
Matroid.emptyOn_isBase_iff._simp_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {B : Set α}, (Matroid.emptyOn α).IsBase B = (B = ∅) |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.simplify | Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr | Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.RingM Lean.Meta.Grind.Arith.CommRing.EqCnstr |
cfc_star_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R A p] (a : A),
autoParam (p a) _auto_373✝ → cfc (fun x => star x) a = star a |
_private.Mathlib.Order.RelSeries.0.RelSeries.append_assoc._simp_1_1 | Mathlib.Order.RelSeries | ∀ {m k n : ℕ}, (m + n = k + n) = (m = k) |
Function.Surjective.distribMulActionLeft | Mathlib.Algebra.GroupWithZero.Action.End | {R : Type u_6} →
{S : Type u_7} →
{M : Type u_8} →
[inst : Monoid R] →
[inst_1 : AddMonoid M] →
[inst_2 : DistribMulAction R M] →
[inst_3 : Monoid S] →
[inst_4 : SMul S M] →
(f : R →* S) → Function.Surjective ⇑f → (∀ (c : R) (x : M), f c • x = c • x) → DistribMulAction S M |
CategoryTheory.StructuredArrow.map₂IsoPreEquivalenceInverseCompProj._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
{T : CategoryTheory.Functor C D} {S : CategoryTheory.Functor D E} {T' : CategoryTheory.Functor C E} (d : D) (e : E)
(u : e ⟶ S.obj d) (α : T.comp S ⟶ T') (x : CategoryTheory.StructuredArrow d T),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.StructuredArrow.map₂ u α).obj x).hom
(T'.map (CategoryTheory.Iso.refl ((CategoryTheory.StructuredArrow.map₂ u α).obj x).right).hom) =
(((CategoryTheory.StructuredArrow.preEquivalence T (CategoryTheory.StructuredArrow.mk u)).inverse.comp
((CategoryTheory.StructuredArrow.proj (CategoryTheory.StructuredArrow.mk u)
(CategoryTheory.StructuredArrow.pre e T S)).comp
(CategoryTheory.StructuredArrow.map₂ (CategoryTheory.CategoryStruct.id e) α))).obj
x).hom |
WithTop.toDual_symm | Mathlib.Order.WithBot | ∀ {α : Type u_1}, WithTop.toDual.symm = WithBot.ofDual |
StarSubalgebra.topologicalClosure._proof_2 | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[inst_7 : IsTopologicalSemiring A] (s : StarSubalgebra R A), 1 ∈ s.topologicalClosure.carrier |
Digraph.mk.sizeOf_spec | Mathlib.Combinatorics.Digraph.Basic | ∀ {V : Type u_1} [inst : SizeOf V] (Adj : V → V → Prop), sizeOf { Adj := Adj } = 1 |
CategoryTheory.ShiftMkCore.assoc_hom_app._autoParam | Mathlib.CategoryTheory.Shift.Basic | Lean.Syntax |
SMulPosReflectLE.lift | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : SMul α β] [inst_4 : SMul α γ] (f : β → γ) [inst_5 : Zero β] [inst_6 : Zero γ] [SMulPosReflectLE α γ],
(∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂) → (∀ (a : α) (b : β), f (a • b) = a • f b) → f 0 = 0 → SMulPosReflectLE α β |
Nat.smallSchroder | Mathlib.Combinatorics.Enumerative.Schroder | ℕ → ℕ |
CategoryTheory.prod.leftUnitor_isEquivalence | Mathlib.CategoryTheory.Products.Unitor | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C], (CategoryTheory.prod.leftUnitor C).IsEquivalence |
εNFA.ctorIdx | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → ℕ |
DirectSum.decompose_one | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜],
(DirectSum.decompose 𝒜) 1 = 1 |
Std.TreeMap.Raw.contains_map | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
{f : α → β → γ} {k : α}, t.WF → (Std.TreeMap.Raw.map f t).contains k = t.contains k |
Lean.Meta.RecursorUnivLevelPos.ctorElim | Lean.Meta.RecursorInfo | {motive : Lean.Meta.RecursorUnivLevelPos → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.RecursorUnivLevelPos) →
ctorIdx = t.ctorIdx → Lean.Meta.RecursorUnivLevelPos.ctorElimType ctorIdx → motive t |
Associated.dvd_iff_dvd_left | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, Associated a b → (a ∣ c ↔ b ∣ c) |
hasStrictFDerivAt_zero | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (x : E), HasStrictFDerivAt 0 0 x |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.m._default | Std.Time.Format.Basic | Option Std.Time.Minute.Ordinal |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_union_Ioc_union_Ioc_cycle._proof_1_1 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α},
Set.Ioc a b ∪ Set.Ioc b c ∪ Set.Ioc c a = Set.Ioc (min a (min b c)) (max a (max b c)) |
Lean.Lsp.instToJsonDocumentChange.match_1 | Lean.Data.Lsp.Basic | (motive : Lean.Lsp.DocumentChange → Sort u_1) →
(x : Lean.Lsp.DocumentChange) →
((x : Lean.Lsp.CreateFile) → motive (Lean.Lsp.DocumentChange.create x)) →
((x : Lean.Lsp.RenameFile) → motive (Lean.Lsp.DocumentChange.rename x)) →
((x : Lean.Lsp.DeleteFile) → motive (Lean.Lsp.DocumentChange.delete x)) →
((x : Lean.Lsp.TextDocumentEdit) → motive (Lean.Lsp.DocumentChange.edit x)) → motive x |
Booleanisation.instSemilatticeInf._proof_3 | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (x x_1 x_2 : Booleanisation α), x ≤ x_1 → x ≤ x_2 → x ≤ x_1 ⊓ x_2 |
Lean.AxiomVal.casesOn | Lean.Declaration | {motive : Lean.AxiomVal → Sort u} →
(t : Lean.AxiomVal) →
((toConstantVal : Lean.ConstantVal) →
(isUnsafe : Bool) → motive { toConstantVal := toConstantVal, isUnsafe := isUnsafe }) →
motive t |
Monoid.CoprodI.Word.consRecOn._proof_3 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (m : (i : ι) × M i) (w : List ((i : ι) × M i))
(h1 : ∀ l ∈ m :: w, l.snd ≠ 1) (h2 : List.IsChain (fun l l' => l.fst ≠ l'.fst) (m :: w)),
{ toList := w, ne_one := ⋯, chain_ne := ⋯ }.fstIdx ≠ some m.fst |
ChainComplex.toSingle₀Equiv._proof_6 | Mathlib.Algebra.Homology.Single | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] (C : ChainComplex V ℕ) (X : V)
(φ : C ⟶ (ChainComplex.single₀ V).obj X),
(fun f => HomologicalComplex.mkHomToSingle ↑f ⋯) ((fun φ => ⟨φ.f 0, ⋯⟩) φ) = φ |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.Clause.of_maxLiteral_eq_some._simp_1_3 | Std.Sat.CNF.RelabelFin | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b |
CategoryTheory.Quiv.equivOfIso._proof_2 | Mathlib.CategoryTheory.Category.Quiv | ∀ {V W : CategoryTheory.Quiv} (e : V ≅ W) (X : ↑W),
(CategoryTheory.CategoryStruct.comp e.inv e.hom).obj X = (CategoryTheory.CategoryStruct.id W).obj X |
Irrational.of_pow | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (n : ℕ), Irrational (x ^ n) → Irrational x |
Matrix.frobenius_norm_replicateCol | Mathlib.Analysis.Matrix.Normed | ∀ {n : Type u_4} {α : Type u_5} {ι : Type u_7} [inst : Fintype n] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : n → α), ‖Matrix.replicateCol ι v‖ = ‖WithLp.toLp 2 v‖ |
Algebra.leftMulMatrix_complex | Mathlib.RingTheory.Complex | ∀ (z : ℂ), (Algebra.leftMulMatrix Complex.basisOneI) z = !![z.re, -z.im; z.im, z.re] |
NumberField.InfinitePlace.mult_isComplex | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (w : { w // w.IsComplex }), (↑w).mult = 2 |
Std.HashSet.contains_toList | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
m.toList.contains k = m.contains k |
_private.Mathlib.Topology.Baire.Lemmas.0.dense_of_mem_residual.match_1_1 | Mathlib.Topology.Baire.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (motive : (∃ t ⊆ s, IsGδ t ∧ Dense t) → Prop)
(x : ∃ t ⊆ s, IsGδ t ∧ Dense t), (∀ (w : Set X) (hts : w ⊆ s) (left : IsGδ w) (hd : Dense w), motive ⋯) → motive x |
String.Pos.Raw.isValidUTF8_extract_iff | Init.Data.String.Basic | ∀ {s : String} (p₁ p₂ : String.Pos.Raw),
p₁ ≤ p₂ →
p₂ ≤ s.rawEndPos →
((s.toByteArray.extract p₁.byteIdx p₂.byteIdx).IsValidUTF8 ↔
p₁ = p₂ ∨ String.Pos.Raw.IsValid s p₁ ∧ String.Pos.Raw.IsValid s p₂) |
MeasureTheory.Measure.LebesgueDecomposition.zero_mem_measurableLE | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
0 ∈ MeasureTheory.Measure.LebesgueDecomposition.measurableLE μ ν |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.CastKind | Mathlib.Tactic.Translate.TagUnfoldBoundary | Type |
MvPolynomial.homEquiv._proof_1 | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {S : Type u_1} {σ : Type u_2} [inst : CommRing S] (f : σ → S) (x : σ),
(fun f => ⇑f ∘ MvPolynomial.X) ((fun f => MvPolynomial.eval₂Hom (Int.castRingHom S) f) f) x = f x |
LawfulMonadStateOf.get_bind_map_set | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α : Type u_1} (f : σ → PUnit.{u_1 + 1} → α),
(do
let s ← get
f s <$> set s) =
do
let __do_lift ← get
pure (f __do_lift PUnit.unit) |
ergodic_vadd_of_denseRange_nsmul | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {X : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : MeasurableSpace X] [BorelSpace X] {M : Type u_3}
[inst_4 : AddMonoid M] [inst_5 : TopologicalSpace M] [inst_6 : AddAction M X] [ContinuousVAdd M X] {g : M},
(DenseRange fun x => x • g) →
∀ (μ : MeasureTheory.Measure X) [MeasureTheory.IsFiniteMeasure μ] [μ.InnerRegular] [ErgodicVAdd M X μ],
Ergodic (fun x => g +ᵥ x) μ |
FiniteField.frobeniusAlgEquivOfAlgebraic | Mathlib.FieldTheory.Finite.Basic | (K : Type u_1) →
[inst : Field K] →
[Fintype K] → (L : Type u_3) → [inst_2 : Field L] → [inst_3 : Algebra K L] → [Algebra.IsAlgebraic K L] → Gal(L/K) |
List.rtakeWhile_concat | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (p : α → Bool) (l : List α) (x : α),
List.rtakeWhile p (l ++ [x]) = if p x = true then List.rtakeWhile p l ++ [x] else [] |
Module.Basis.ofIsCoprimeDifferentIdeal | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | (A : Type u_1) →
(B : Type u_2) →
{K : Type u_3} →
{L : Type u_4} →
[inst : CommRing A] →
[inst_1 : Field K] →
[inst_2 : Algebra A K] →
[IsFractionRing A K] →
[inst_4 : CommRing B] →
[inst_5 : Field L] →
[inst_6 : Algebra B L] →
[inst_7 : Algebra A L] →
[inst_8 : Algebra K L] →
[FiniteDimensional K L] →
[inst_10 : IsScalarTower A K L] →
(R₁ : Type u_5) →
(R₂ : Type u_6) →
[inst_11 : CommRing R₁] →
[inst_12 : CommRing R₂] →
[IsDomain R₁] →
[inst_14 : Algebra A R₁] →
[inst_15 : Algebra A R₂] →
[inst_16 : Algebra R₁ B] →
[inst_17 : Algebra R₂ B] →
[inst_18 : Algebra R₁ L] →
[inst_19 : Algebra R₂ L] →
[IsScalarTower A R₁ L] →
[IsScalarTower R₁ B L] →
[IsScalarTower R₂ B L] →
[Module.Finite A R₂] →
{F₁ F₂ : IntermediateField K L} →
[inst_24 : Algebra R₁ ↥F₁] →
[inst_25 : Algebra R₂ ↥F₂] →
[Module.IsTorsionFree R₁ ↥F₁] →
[IsScalarTower A (↥F₂) L] →
[IsScalarTower A R₂ ↥F₂] →
[IsScalarTower R₁ (↥F₁) L] →
[IsScalarTower R₂ (↥F₂) L] →
[Algebra.IsSeparable K ↥F₂] →
[Algebra.IsSeparable (↥F₁) L] →
[inst_33 : IsDomain A] →
[inst_34 : IsDedekindDomain B] →
[inst_35 : IsDedekindDomain R₁] →
[inst_36 : IsDedekindDomain R₂] →
[IsFractionRing B L] →
[IsFractionRing R₁ ↥F₁] →
[IsFractionRing R₂ ↥F₂] →
[IsIntegrallyClosed A] →
[IsIntegralClosure B R₁
L] →
[Module.IsTorsionFree
R₁ B] →
[Module.IsTorsionFree
R₂ B] →
⋯ |
CategoryTheory.MonoidalCategory.DayFunctor.equiv._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (V : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (X : CategoryTheory.MonoidalCategory.DayFunctor C V),
(CategoryTheory.CategoryStruct.id X).natTrans = CategoryTheory.CategoryStruct.id X.functor |
OreLocalization.instMonoidWithZero._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : MonoidWithZero R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(x : OreLocalization S R), x * 0 = 0 |
Lean.Elab.HeaderProcessedSnapshot.mk.sizeOf_spec | Lean.Elab.DefView | ∀ (toSnapshot : Lean.Language.Snapshot) (view : Lean.Elab.DefViewElabHeaderData) (state : Lean.Elab.Term.SavedState)
(tacStx? : Option Lean.Syntax) (tacSnap? : Option (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))
(bodyStx : Lean.Syntax) (bodySnap : Lean.Language.SnapshotTask (Option Lean.Elab.BodyProcessedSnapshot))
(moreSnaps : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)),
sizeOf
{ toSnapshot := toSnapshot, view := view, state := state, tacStx? := tacStx?, tacSnap? := tacSnap?,
bodyStx := bodyStx, bodySnap := bodySnap, moreSnaps := moreSnaps } =
1 + sizeOf toSnapshot + sizeOf view + sizeOf state + sizeOf tacStx? + sizeOf tacSnap? + sizeOf bodyStx +
sizeOf bodySnap +
sizeOf moreSnaps |
CliffordAlgebra.foldr'Aux._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Fold | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), SMulCommClass R R (CliffordAlgebra Q) |
_private.Init.Data.Dyadic.Basic.0.Rat.toDyadic.match_1.splitter | Init.Data.Dyadic.Basic | (motive : ℤ → Sort u_1) →
(prec : ℤ) → ((n : ℕ) → motive (Int.ofNat n)) → ((n : ℕ) → motive (Int.negSucc n)) → motive prec |
BitVec.reduceDiv | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc |
Std.Iter.toArray.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α β : Type w} [inst : Std.Iterator α Id β] (it : Std.Iter β), it.toArray = it.toIterM.toArray.run |
Nat.minFac_eq | Mathlib.Data.Nat.Prime.Defs | ∀ (n : ℕ), n.minFac = if 2 ∣ n then 2 else n.minFacAux 3 |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ushiftRight_of_lt._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, 0 < n → n ≤ w → ¬(w - n).succ ≤ w → False |
Real.iteratedDerivWithin_cos_Icc | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ (n : ℕ) {a b : ℝ},
a < b → ∀ {x : ℝ}, x ∈ Set.Icc a b → iteratedDerivWithin n Real.cos (Set.Icc a b) x = iteratedDeriv n Real.cos x |
Algebra.Generators.Hom.mk.inj | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S}
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} {inst_3 : CommRing R'}
{inst_4 : CommRing S'} {inst_5 : Algebra R' S'} {P' : Algebra.Generators R' S' ι'} {inst_6 : Algebra S S'}
{val : ι → P'.Ring} {aeval_val : ∀ (i : ι), (MvPolynomial.aeval P'.val) (val i) = (algebraMap S S') (P.val i)}
{val_1 : ι → P'.Ring} {aeval_val_1 : ∀ (i : ι), (MvPolynomial.aeval P'.val) (val_1 i) = (algebraMap S S') (P.val i)},
{ val := val, aeval_val := aeval_val } = { val := val_1, aeval_val := aeval_val_1 } → val = val_1 |
Lean.PrettyPrinter.Parenthesizer.categoryParser.parenthesizer.match_1 | Lean.PrettyPrinter.Parenthesizer | (motive : List Lean.PrettyPrinter.CategoryParenthesizer → Sort u_1) →
(x : List Lean.PrettyPrinter.CategoryParenthesizer) →
((p : Lean.PrettyPrinter.CategoryParenthesizer) →
(tail : List Lean.PrettyPrinter.CategoryParenthesizer) → motive (p :: tail)) →
((x : List Lean.PrettyPrinter.CategoryParenthesizer) → motive x) → motive x |
Lean.Meta.Grind.propagateDIte | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator |
CategoryTheory.Bicategory.whiskerLeft_hom_inv_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ≅ h) (k : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g k) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight η.hom k))
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.whiskerRight η.inv k)) h_1) =
h_1 |
IsTensorProduct.equiv_apply | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} [inst : CommSemiring R] {M₁ : Type u_2} {M₂ : Type u_3} {M : Type u_4} [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R M] {f : M₁ →ₗ[R] M₂ →ₗ[R] M} (h : IsTensorProduct f) (a : TensorProduct R M₁ M₂),
h.equiv a = (TensorProduct.lift f) a |
Lean.Elab.Term.Do.ToTerm.Context.mk.injEq | Lean.Elab.Do.Legacy | ∀ (m returnType : Lean.Syntax) (uvars : Array Lean.Elab.Term.Do.Var) (kind : Lean.Elab.Term.Do.ToTerm.Kind)
(m_1 returnType_1 : Lean.Syntax) (uvars_1 : Array Lean.Elab.Term.Do.Var) (kind_1 : Lean.Elab.Term.Do.ToTerm.Kind),
({ m := m, returnType := returnType, uvars := uvars, kind := kind } =
{ m := m_1, returnType := returnType_1, uvars := uvars_1, kind := kind_1 }) =
(m = m_1 ∧ returnType = returnType_1 ∧ uvars = uvars_1 ∧ kind = kind_1) |
_private.Mathlib.InformationTheory.KullbackLeibler.Basic.0.InformationTheory.toReal_klDiv_smul_right._simp_1_4 | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
SemiNormedGrp.instCoeSortType | Mathlib.Analysis.Normed.Group.SemiNormedGrp | CoeSort SemiNormedGrp (Type u_1) |
Mathlib.Meta.NormNum.isInt_add | Mathlib.Tactic.NormNum.Basic | ∀ {α : Type u_1} [inst : Ring α] {f : α → α → α} {a b : α} {a' b' c : ℤ},
f = HAdd.hAdd →
Mathlib.Meta.NormNum.IsInt a a' →
Mathlib.Meta.NormNum.IsInt b b' → a'.add b' = c → Mathlib.Meta.NormNum.IsInt (f a b) c |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.comp_injOn.match_1_1 | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_2} {X : Type u_1} [inst : TopologicalSpace X] {f : ι → Set X} (x : X)
(motive : (∃ t ∈ nhds x, {i | (f i ∩ t).Nonempty}.Finite) → Prop)
(x_1 : ∃ t ∈ nhds x, {i | (f i ∩ t).Nonempty}.Finite),
(∀ (t : Set X) (htx : t ∈ nhds x) (htf : {i | (f i ∩ t).Nonempty}.Finite), motive ⋯) → motive x_1 |
_private.Mathlib.Order.Cover.0.Pi.covBy_iff_exists_left_eq._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) |
ZNum.pred | Mathlib.Data.Num.Basic | ZNum → ZNum |
MeasureTheory.Measure.addHaarMeasure_eq_iff | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [SecondCountableTopology G]
(K₀ : TopologicalSpace.PositiveCompacts G) (μ : MeasureTheory.Measure G) [MeasureTheory.SigmaFinite μ]
[μ.IsAddLeftInvariant], MeasureTheory.Measure.addHaarMeasure K₀ = μ ↔ μ ↑K₀ = 1 |
Composition.ones | Mathlib.Combinatorics.Enumerative.Composition | (n : ℕ) → Composition n |
TopologicalSpace.Closeds.complOrderIso | Mathlib.Topology.Sets.Closeds | (α : Type u_2) → [inst : TopologicalSpace α] → TopologicalSpace.Closeds α ≃o (TopologicalSpace.Opens α)ᵒᵈ |
AddSubmonoid.gciMapComap.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective ⇑f),
AddSubmonoid.gciMapComap hf = ⋯.toGaloisCoinsertion ⋯ |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.cmp.match_1.eq_6 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → PosNum → Sort u_1) (a b : PosNum) (h_1 : Unit → motive PosNum.one PosNum.one)
(h_2 : (x : PosNum) → motive x PosNum.one) (h_3 : (x : PosNum) → motive PosNum.one x)
(h_4 : (a b : PosNum) → motive a.bit0 b.bit0) (h_5 : (a b : PosNum) → motive a.bit0 b.bit1)
(h_6 : (a b : PosNum) → motive a.bit1 b.bit0) (h_7 : (a b : PosNum) → motive a.bit1 b.bit1),
(match a.bit1, b.bit0 with
| PosNum.one, PosNum.one => h_1 ()
| x, PosNum.one => h_2 x
| PosNum.one, x => h_3 x
| a.bit0, b.bit0 => h_4 a b
| a.bit0, b.bit1 => h_5 a b
| a.bit1, b.bit0 => h_6 a b
| a.bit1, b.bit1 => h_7 a b) =
h_6 a b |
CategoryTheory.Coreflective.mk.noConfusion | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{L : CategoryTheory.Functor C D} →
{P : Sort u} →
{toFull : L.Full} →
{toFaithful : L.Faithful} →
{R : CategoryTheory.Functor D C} →
{adj : L ⊣ R} →
{toFull' : L.Full} →
{toFaithful' : L.Faithful} →
{R' : CategoryTheory.Functor D C} →
{adj' : L ⊣ R'} →
{ toFull := toFull, toFaithful := toFaithful, R := R, adj := adj } =
{ toFull := toFull', toFaithful := toFaithful', R := R', adj := adj' } →
(R ≍ R' → adj ≍ adj' → P) → P |
GenLoop.fromLoop_coe | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N)
(p : LoopSpace (↑(GenLoop { j // j ≠ i } X x)) GenLoop.const),
↑(GenLoop.fromLoop i p) =
({ toFun := Subtype.val, continuous_toFun := ⋯ }.comp p.toContinuousMap).uncurry.comp ↑(Cube.splitAt i) |
Set.ne_univ_iff_exists_notMem | Mathlib.Data.Set.Basic | ∀ {α : Type u_1} (s : Set α), s ≠ Set.univ ↔ ∃ a, a ∉ s |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.add_lt_aleph0_iff.match_1_1 | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}} (motive : a < Cardinal.aleph0 ∧ b < Cardinal.aleph0 → Prop)
(x : a < Cardinal.aleph0 ∧ b < Cardinal.aleph0),
(∀ (h1 : a < Cardinal.aleph0) (h2 : b < Cardinal.aleph0), motive ⋯) → motive x |
Algebra.PreSubmersivePresentation.baseChange | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(T : Type u_1) →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
Algebra.PreSubmersivePresentation R S ι σ →
Algebra.PreSubmersivePresentation T (TensorProduct R T S) ι σ |
GrpCat.hasLimitsOfShape | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] [Small.{u, v} J],
CategoryTheory.Limits.HasLimitsOfShape J GrpCat |
ShrinkingLemma.PartialRefinement.noConfusionType | Mathlib.Topology.ShrinkingLemma | Sort u →
{ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
ShrinkingLemma.PartialRefinement u s p →
{ι' : Type u_1} →
{X' : Type u_2} →
[inst' : TopologicalSpace X'] →
{u' : ι' → Set X'} →
{s' : Set X'} → {p' : Set X' → Prop} → ShrinkingLemma.PartialRefinement u' s' p' → Sort u |
ContinuousLinearMap.toBilinForm_inj | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜 : Type u_2} {E : Type u_5} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] (L₁ L₂ : E →L[𝕜] E →L[𝕜] 𝕜), L₁.toBilinForm = L₂.toBilinForm ↔ L₁ = L₂ |
CategoryTheory.CostructuredArrow.faithful_map₂ | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V : B}
{F : CategoryTheory.Functor C A} {G : CategoryTheory.Functor D B} (α : F.comp U ⟶ S.comp G) (β : G.obj T ⟶ V)
[F.Faithful], (CategoryTheory.CostructuredArrow.map₂ α β).Faithful |
CategoryTheory.Pretriangulated.Triangle.epi₁ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles, T.mor₂ = 0 → CategoryTheory.Epi T.mor₁ |
IsPrimitiveRoot.ne_one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → 1 < k → ζ ≠ 1 |
Ordinal.IsFundamentalSequence.strict_mono | Mathlib.SetTheory.Cardinal.Cofinality | ∀ {a o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{u}},
a.IsFundamentalSequence o f → ∀ {i j : Ordinal.{u}} (hi : i < o) (hj : j < o), i < j → f i hi < f j hj |
WeierstrassCurve.Jacobian.baseChange_addXYZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W' : WeierstrassCurve.Jacobian R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsScalarTower R S B]
(f : A →ₐ[S] B) (P Q : Fin 3 → A),
(WeierstrassCurve.baseChange W' B).toJacobian.addXYZ (⇑f ∘ P) (⇑f ∘ Q) =
⇑f ∘ (WeierstrassCurve.baseChange W' A).toJacobian.addXYZ P Q |
Lean.Elab.Term.registerMVarErrorInfo | Lean.Elab.Term.TermElabM | Lean.Elab.Term.MVarErrorInfo → Lean.Elab.TermElabM Unit |
Cardinal.cantorFunctionAux_true | Mathlib.Analysis.Real.Cardinality | ∀ {c : ℝ} {f : ℕ → Bool} {n : ℕ}, f n = true → Cardinal.cantorFunctionAux c f n = c ^ n |
_private.Mathlib.LinearAlgebra.Pi.0.LinearMap.disjoint_single_single._simp_1_3 | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i |
Metric.edistLtTopSetoid._proof_2 | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {x y : α}, edist x y < ⊤ → edist y x < ⊤ |
List.mem_pi_toList | Mathlib.Data.FinEnum | ∀ {α : Type u_1} [inst : FinEnum α] {β : α → Type u_2} [inst_1 : (a : α) → FinEnum (β a)] (xs : List α)
(f : (a : α) → a ∈ xs → β a), f ∈ xs.pi fun x => FinEnum.toList (β x) |
IsAlgClosed.degree_eq_one_of_irreducible | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (k : Type u) [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, Irreducible p → p.degree = 1 |
_private.Mathlib.Order.Antisymmetrization.0.wellFoundedLT_antisymmetrization_iff._simp_1_1 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u) (r : α → α → Prop), IsWellFounded α r = WellFounded r |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.instDecidableEqCPUTimes.decEq.match_1 | Std.Internal.Async.System | (motive : Std.Internal.IO.Async.System.CPUTimes → Std.Internal.IO.Async.System.CPUTimes → Sort u_1) →
(x x_1 : Std.Internal.IO.Async.System.CPUTimes) →
((a a_1 a_2 a_3 a_4 b b_1 b_2 b_3 b_4 : Std.Time.Millisecond.Offset) →
motive { userTime := a, niceTime := a_1, systemTime := a_2, idleTime := a_3, interruptTime := a_4 }
{ userTime := b, niceTime := b_1, systemTime := b_2, idleTime := b_3, interruptTime := b_4 }) →
motive x x_1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.