name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
RingHom.isStandardSmoothOfRelativeDimension_stableUnderCompositionWithLocalizationAway | Mathlib.RingTheory.RingHom.StandardSmooth | ∀ (n : ℕ),
RingHom.StableUnderCompositionWithLocalizationAway fun {R S} [CommRing R] [CommRing S] =>
RingHom.IsStandardSmoothOfRelativeDimension n |
OpenPartialHomeomorph.map_extend_nhdsWithin | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H} {s : Set M} {y : M},
y ∈ f.source →
Filter.map (↑(f.extend I)) (nhdsWithin y s) = nhdsWithin (↑(f.extend I) y) (↑(f.extend I).symm ⁻¹' s ∩ Set.range ↑I) |
MeasurableSpace.separatesPoints_def | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | ∀ {α : Type u_1} [inst : MeasurableSpace α] [hs : MeasurableSpace.SeparatesPoints α] {x y : α},
(∀ (s : Set α), MeasurableSet s → x ∈ s → y ∈ s) → x = y |
iSup_or | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] {p q : Prop} {s : p ∨ q → α},
⨆ (x : p ∨ q), s x = (⨆ (i : p), s ⋯) ⊔ ⨆ (j : q), s ⋯ |
LowerSet.Iic_ne_bot | Mathlib.Order.UpperLower.Principal | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, LowerSet.Iic a ≠ ⊥ |
FormalMultilinearSeries.ofScalars_norm_eq_mul | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : SeminormedRing E]
[inst_2 : NormedAlgebra 𝕜 E] (c : ℕ → 𝕜) (n : ℕ),
‖FormalMultilinearSeries.ofScalars E c n‖ = ‖c n‖ * ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 n E‖ |
Rat.HeightOneSpectrum.adicCompletion.padicEquiv._proof_2 | Mathlib.NumberTheory.Padics.HeightOneSpectrum | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : Algebra R ℚ] [inst_2 : IsIntegralClosure R ℤ ℚ]
[inst_3 : IsDedekindDomain R] [inst_4 : IsFractionRing R ℚ] (v : IsDedekindDomain.HeightOneSpectrum R) (r : ℚ),
((UniformSpace.Completion.mapRingEquiv
(WithVal.congr (IsDedekindDomain.HeightOneSpectrum.valuation ℚ v)
(Rat.padicValuation ↑(Rat.HeightOneSpectrum.primesEquiv v)) (RingEquiv.refl ℚ))
⋯ ⋯).trans
Padic.withValRingEquiv).toFun
((algebraMap ℚ (IsDedekindDomain.HeightOneSpectrum.adicCompletion ℚ v)) r) =
(algebraMap ℚ ℚ_[↑(Rat.HeightOneSpectrum.primesEquiv v)]) r |
ModelWithCorners.Boundaryless.recOn | Mathlib.Geometry.Manifold.IsManifold.Basic | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{motive : I.Boundaryless → Sort u} →
(t : I.Boundaryless) → ((range_eq_univ : Set.range ↑I = Set.univ) → motive ⋯) → motive t |
IndepMatroid._sizeOf_1 | Mathlib.Combinatorics.Matroid.IndepAxioms | {α : Type u_2} → [SizeOf α] → IndepMatroid α → ℕ |
Lean.mkErrorStringWithPos | Lean.Message | String →
Lean.Position →
String →
optParam (Option Lean.Position) none → optParam (Option String) none → optParam (Option Lean.Name) none → String |
Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems.recOn | Lean.Elab.Tactic.Do.Attr | {motive : Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems → Sort u} →
(t : Lean.Elab.Tactic.Do.SpecAttr.SpecTheorems) →
((specs : Lean.Meta.DiscrTree Lean.Elab.Tactic.Do.SpecAttr.SpecTheorem) →
(erased : Lean.PHashSet Lean.Elab.Tactic.Do.SpecAttr.SpecProof) → motive { specs := specs, erased := erased }) →
motive t |
CategoryTheory.Limits.biprod.braiding_map_braiding | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {W X Y Z : C} (f : W ⟶ Y) (g : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.braiding X W).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.map f g)
(CategoryTheory.Limits.biprod.braiding Y Z).hom) =
CategoryTheory.Limits.biprod.map g f |
CategoryTheory.ShortComplex.RightHomologyData.ofIsLimitKernelFork_p | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) (hf : S.f = 0) (c : CategoryTheory.Limits.KernelFork S.g)
(hc : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.ShortComplex.RightHomologyData.ofIsLimitKernelFork S hf c hc).p =
CategoryTheory.CategoryStruct.id S.X₂ |
Simps.ProjectionRule.casesOn | Mathlib.Tactic.Simps.Basic | {motive : Simps.ProjectionRule → Sort u} →
(t : Simps.ProjectionRule) →
((oldName : Lean.Name) →
(oldStx : Lean.Syntax) →
(newName : Lean.Name) →
(newStx : Lean.Syntax) → motive (Simps.ProjectionRule.rename oldName oldStx newName newStx)) →
((a : Lean.Name) → (a_1 : Lean.Syntax) → motive (Simps.ProjectionRule.add a a_1)) →
((a : Lean.Name) → (a_1 : Lean.Syntax) → motive (Simps.ProjectionRule.erase a a_1)) →
((a : Lean.Name) → (a_1 : Lean.Syntax) → motive (Simps.ProjectionRule.prefix a a_1)) → motive t |
CategoryTheory.Limits.IsLimit.liftConeMorphism_hom | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F} (h : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.Cone F), (h.liftConeMorphism s).hom = h.lift s |
AlgebraicGeometry.morphismRestrict_id | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens),
CategoryTheory.CategoryStruct.id X ∣_ U =
CategoryTheory.CategoryStruct.id ↑((TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X).base).obj U) |
CategoryTheory.PreGaloisCategory.evaluation_aut_bijective_of_isGalois | Mathlib.CategoryTheory.Galois.GaloisObjects | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) [CategoryTheory.PreGaloisCategory.FiberFunctor F] (A : C)
[CategoryTheory.PreGaloisCategory.IsGalois A] (a : (F.obj A).obj),
Function.Bijective fun f => (CategoryTheory.ConcreteCategory.hom (F.map f.hom)) a |
String.Slice.Pos.prev.congr_simp | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} (pos pos_1 : s.Pos) (e_pos : pos = pos_1) (h : pos ≠ s.startPos), pos.prev h = pos_1.prev ⋯ |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.parseFirstByte_eq_done_iff | Init.Data.String.Decode | ∀ {b : UInt8}, ByteArray.utf8DecodeChar?.parseFirstByte b = ByteArray.utf8DecodeChar?.FirstByte.done ↔ b &&& 128 = 0 |
_private.Mathlib.Data.BitVec.0.BitVec.toFin_injective.match_1_1 | Mathlib.Data.BitVec | ∀ {n : ℕ} (motive : (x x_1 : BitVec n) → x.toFin = x_1.toFin → Prop) (x x_1 : BitVec n) (x_2 : x.toFin = x_1.toFin),
(∀ (val : ℕ) (isLt isLt_1 : val < 2 ^ n), motive { toFin := ⟨val, isLt⟩ } { toFin := ⟨val, isLt_1⟩ } ⋯) →
motive x x_1 x_2 |
DirectedOn.fst | Mathlib.Order.Directed | ∀ {α : Type u} {β : Type v} {r : α → α → Prop} {r₂ : β → β → Prop} {d : Set (α × β)},
DirectedOn (fun p q => r p.1 q.1 ∧ r₂ p.2 q.2) d → DirectedOn (fun x1 x2 => r x1 x2) (Prod.fst '' d) |
IsTopologicalAddGroup.toHSpace | Mathlib.Topology.Homotopy.HSpaces | (M : Type u) → [inst : AddZeroClass M] → [inst_1 : TopologicalSpace M] → [ContinuousAdd M] → HSpace M |
Set.Finite.iInf_biSup_of_antitone | Mathlib.Data.Set.Finite.Lattice | ∀ {ι : Type u_1} {ι' : Type u_2} {α : Type u_3} [inst : Preorder ι'] [Nonempty ι'] [IsDirectedOrder ι']
[inst_3 : Order.Coframe α] {s : Set ι},
s.Finite → ∀ {f : ι → ι' → α}, (∀ i ∈ s, Antitone (f i)) → ⨅ j, ⨆ i ∈ s, f i j = ⨆ i ∈ s, ⨅ j, f i j |
Lean.instBEqMessageSeverity | Lean.Message | BEq Lean.MessageSeverity |
CategoryTheory.ShortComplex.FunctorEquivalence.functor | Mathlib.Algebra.Homology.ShortComplex.FunctorEquivalence | (J : Type u_1) →
(C : Type u_2) →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] →
CategoryTheory.Functor (CategoryTheory.ShortComplex (CategoryTheory.Functor J C))
(CategoryTheory.Functor J (CategoryTheory.ShortComplex C)) |
ConcaveOn | Mathlib.Analysis.Convex.Function | (𝕜 : Type u_1) →
{E : Type u_2} →
{β : Type u_5} →
[Semiring 𝕜] →
[PartialOrder 𝕜] →
[AddCommMonoid E] → [AddCommMonoid β] → [PartialOrder β] → [SMul 𝕜 E] → [SMul 𝕜 β] → Set E → (E → β) → Prop |
ContMDiffCovariantDerivativeOn.affine_combination | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommGroup F]
[inst_7 : NormedSpace 𝕜 F] {V : M → Type u_6} [inst_8 : TopologicalSpace (Bundle.TotalSpace F V)]
[inst_9 : (x : M) → AddCommGroup (V x)] [inst_10 : (x : M) → Module 𝕜 (V x)]
[inst_11 : (x : M) → TopologicalSpace (V x)] [inst_12 : ∀ (x : M), IsTopologicalAddGroup (V x)]
[inst_13 : ∀ (x : M), ContinuousSMul 𝕜 (V x)] [inst_14 : FiberBundle F V] [inst_15 : IsManifold I 1 M]
[inst_16 : VectorBundle 𝕜 F V] {cov cov' : ((x : M) → V x) → (x : M) → TangentSpace I x →L[𝕜] V x} {u : Set M}
{f : M → 𝕜} {n : WithTop ℕ∞},
ContMDiffOn I (modelWithCornersSelf 𝕜 𝕜) n f u →
ContMDiffCovariantDerivativeOn F n cov u →
ContMDiffCovariantDerivativeOn F n cov' u →
ContMDiffCovariantDerivativeOn F n (fun σ => f • cov σ + (1 - f) • cov' σ) u |
Lean.Meta.Grind.instNonemptyState | Lean.Meta.Tactic.Grind.Types | Nonempty Lean.Meta.Grind.State |
Std.DTreeMap.instSliceableRcoSlice._auto_1 | Std.Data.DTreeMap.Slice | Lean.Syntax |
CategoryTheory.Adjunction.IsTriangulated.commShift._autoParam | Mathlib.CategoryTheory.Triangulated.Adjunction | Lean.Syntax |
_private.Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct.0.CategoryTheory.Limits.pointwiseProductCompEvaluation._simp_1 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G H : CategoryTheory.Functor C D} (α : F ⟶ G) (β : G ⟶ H) (X : C),
CategoryTheory.CategoryStruct.comp (α.app X) (β.app X) = (CategoryTheory.CategoryStruct.comp α β).app X |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.rescale_zero._simp_1_3 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {F : Sort u_1} {α : Sort u_2} {β : α → Sort u_3} [i : DFunLike F α β] {f g : F}, (f = g) = ∀ (x : α), f x = g x |
CategoryTheory.Functor.isLeftDerivedFunctor_iff_of_iso | Mathlib.CategoryTheory.Functor.Derived.LeftDerived | ∀ {C : Type u_1} {D : Type u_3} {H : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} D] [inst_2 : CategoryTheory.Category.{v_5, u_2} H]
(LF' LF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : L.comp LF ⟶ F) (α' : L.comp LF' ⟶ F) (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
(e : LF ≅ LF'),
CategoryTheory.CategoryStruct.comp (L.whiskerLeft e.hom) α' = α →
(LF.IsLeftDerivedFunctor α W ↔ LF'.IsLeftDerivedFunctor α' W) |
Aesop.InstMap.mk.injEq | Aesop.Forward.State | ∀ (map map_1 : Lean.PHashMap Aesop.SlotIndex (Aesop.EMap (Lean.PHashSet Aesop.Match × Lean.PHashSet Aesop.Hyp))),
({ map := map } = { map := map_1 }) = (map = map_1) |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balance!_eq_balanceₘ._proof_1_21 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (ls size : ℕ) (l r : Std.DTreeMap.Internal.Impl α β),
(l.Balanced ∧
r.Balanced ∧ (l.size + r.size ≤ 1 ∨ l.size ≤ 3 * r.size ∧ r.size ≤ 3 * l.size) ∧ size = l.size + 1 + r.size) ∧
(size + 0 ≤ 1 ∨ size ≤ 3 * 0 ∧ 0 ≤ 3 * size) ∧ ls = size + 1 + 0 →
0 > 3 * (l.size + 1 + r.size + 1 + 0) → False |
CategoryTheory.CommGrp.toMon | Mathlib.CategoryTheory.Monoidal.CommGrp_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.CommGrp C → CategoryTheory.Mon C |
_private.Init.Data.SInt.Lemmas.0.ISize.lt_of_le_of_ne._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : ISize}, (x = y) = (x.toInt = y.toInt) |
_private.Mathlib.Analysis.Real.Hyperreal.0.Hyperreal.tendsto_iff_forall._simp_1_3 | Mathlib.Analysis.Real.Hyperreal | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) = ((∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x) |
Array.isEqvAux.congr_simp | Init.Data.Array.DecidableEq | ∀ {α : Type u} (xs xs_1 : Array α) (e_xs : xs = xs_1) (ys ys_1 : Array α) (e_ys : ys = ys_1) (hsz : xs.size = ys.size)
(p p_1 : α → α → Bool),
p = p_1 → ∀ (i i_1 : ℕ) (e_i : i = i_1) (x : i ≤ xs.size), xs.isEqvAux ys hsz p i x = xs_1.isEqvAux ys_1 ⋯ p_1 i_1 ⋯ |
Ideal.Quotient.stabilizerQuotientInertiaEquiv | Mathlib.RingTheory.Invariant.Basic | {A : Type u_1} →
{B : Type u_2} →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
(G : Type u_3) →
[inst_3 : Group G] →
[Finite G] →
[inst_5 : MulSemiringAction G B] →
[SMulCommClass G A B] →
(P : Ideal A) →
(Q : Ideal B) →
[Q.IsPrime] →
[inst_8 : Q.LiesOver P] →
[Algebra.IsInvariant A B G] →
↥(MulAction.stabilizer G Q) ⧸ (Ideal.inertia G Q).subgroupOf (MulAction.stabilizer G Q) ≃*
(B ⧸ Q) ≃ₐ[A ⧸ P] B ⧸ Q |
TopologicalSpace.Opens.mem_map | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} {f : X ⟶ Y} {U : TopologicalSpace.Opens ↑Y} {x : ↑X},
x ∈ (TopologicalSpace.Opens.map f).obj U ↔ (TopCat.Hom.hom f) x ∈ U |
LieSubmodule.iInf_toSubmodule | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] {ι : Sort u_1} (p : ι → LieSubmodule R L M),
↑(⨅ i, p i) = ⨅ i, ↑(p i) |
_private.Lean.Elab.DocString.Builtin.Postponed.0.Lean.Doc.checkBlockPostponed._unsafe_rec | Lean.Elab.DocString.Builtin.Postponed | Lean.Name → Lean.Doc.Block Lean.ElabInline Lean.ElabBlock → Lean.Doc.CheckM✝ Unit |
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.normalize.processInaccessible | Lean.Elab.Match | Lean.Expr → Lean.Elab.Term.ToDepElimPattern.M Lean.Expr |
tsupport_smul_subset_right | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] {M : Type u_9} {α : Type u_10} [inst_1 : Zero α]
[inst_2 : SMulZeroClass M α] (f : X → M) (g : X → α), (tsupport fun x => f x • g x) ⊆ tsupport g |
NonemptyInterval.coe_subset_coe | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : NonemptyInterval α}, ↑s ⊆ ↑t ↔ s ≤ t |
_private.Lean.Elab.BuiltinDo.MatchExpr.0.Lean.Elab.Do.elabDoMatchExpr.elabDoMatchExprNoMeta.elabMatch._unary.eq_def | Lean.Elab.BuiltinDo.MatchExpr | ∀ (discr : Lean.Term) (alts : Lean.TSyntax `Lean.Parser.Term.matchExprAlts) (dec : Lean.Elab.Do.DoElemCont)
(_x : (_ : ℕ) ×' Array (Lean.TSyntax `Lean.Parser.Term.matchExprAlt)),
Lean.Elab.Do.elabDoMatchExpr.elabDoMatchExprNoMeta.elabMatch._unary✝ discr alts dec _x =
PSigma.casesOn _x fun i altsArr =>
if h : i < altsArr.size then
have __discr := altsArr[i];
if __discr.raw.isOfKind `Lean.Parser.Term.matchExprAlt = true then
have __discr_1 := __discr.raw.getArg 0;
have __discr_2 := __discr.raw.getArg 1;
have __discr_3 := __discr.raw.getArg 2;
have __discr := __discr.raw.getArg 3;
have seq := { raw := __discr };
have pattern := { raw := __discr_2 };
do
let vars ← liftM (Lean.Elab.Do.getExprPatternVarsEx pattern)
Lean.Elab.Do.checkMutVarsForShadowing vars
Lean.Elab.Do.doElabToSyntax (Lean.toMessageData "match_expr alternative " ++ Lean.toMessageData pattern)
(Lean.Elab.Do.elabDoSeq { raw := seq.raw } dec)
(fun rhs => do
let __do_lift ←
do
let info ← Lean.MonadRef.mkInfoFromRefPos
let _ ← Lean.getCurrMacroScope
let _ ← Lean.MonadQuotation.getContext
pure
{
raw :=
Lean.Syntax.node4 info `Lean.Parser.Term.matchExprAlt (Lean.Syntax.atom info "|")
pattern.raw (Lean.Syntax.atom info "=>") rhs.raw }
Lean.Elab.Do.elabDoMatchExpr.elabDoMatchExprNoMeta.elabMatch._unary✝¹ discr alts dec
⟨i + 1, altsArr.set i { raw := __do_lift.raw } h⟩)
seq.raw
else
have __discr := altsArr[i];
Lean.Elab.throwUnsupportedSyntax
else
have elseSeq := alts.raw[1][3];
Lean.Elab.Do.doElabToSyntax (Lean.toMessageData "match_expr else alternative")
(Lean.Elab.Do.elabDoSeq { raw := elseSeq } dec)
(fun rhs =>
have alts := { raw := alts.raw.modifyArg 0 fun node => node.setArgs (Lean.TSyntaxArray.raw altsArr) };
have alts := { raw := alts.raw.modifyArg 1 fun x => x.setArg 3 rhs.raw };
do
let __do_lift ← read
let mγ ← Lean.Elab.Do.mkMonadicType __do_lift.doBlockResultType
let __do_lift ←
do
let info ← Lean.MonadRef.mkInfoFromRefPos
let _ ← Lean.getCurrMacroScope
let _ ← Lean.MonadQuotation.getContext
pure
{
raw :=
Lean.Syntax.node4 info `Lean.Parser.Term.matchExpr (Lean.Syntax.atom info "match_expr")
discr.raw (Lean.Syntax.atom info "with") alts.raw }
liftM (Lean.Elab.Term.elabTerm __do_lift.raw (some mγ)))
elseSeq |
_private.Mathlib.Order.KonigLemma.0.exists_seq_forall_proj_of_forall_finite.match_1_17 | Mathlib.Order.KonigLemma | ∀ {α : ℕ → Type u_1},
let αs := (i : ℕ) × α i;
∀ (motive : αs → Prop) (x : αs), (∀ (i : ℕ) (a : α i), motive ⟨i, a⟩) → motive x |
Std.TreeMap.Raw.maxKeyD_eq_fallback | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = true → ∀ {fallback : α}, t.maxKeyD fallback = fallback |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary._proof_1 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ),
table.size ≤ pat.utf8ByteSize → ∀ guess < table.size, { byteIdx := guess } < pat.rawEndPos |
Lean.Server.instToJsonGoToKind | Lean.Server.GoTo | Lean.ToJson Lean.Server.GoToKind |
Array.mapFinIdx_push | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {a : α} {f : (i : ℕ) → α → i < (xs.push a).size → β},
(xs.push a).mapFinIdx f = (xs.mapFinIdx fun i a_1 h => f i a_1 ⋯).push (f xs.size a ⋯) |
Classical.propDecidable.match_1 | Init.Classical | ∀ (a : Prop) (motive : a ∨ ¬a → Prop) (x : a ∨ ¬a), (∀ (h : a), motive ⋯) → (∀ (h : ¬a), motive ⋯) → motive x |
_private.Init.Data.Vector.Lemmas.0.Vector.mapM.go.eq_def | Init.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} {n : ℕ} [inst : Monad m] (f : α → m β) (xs : Vector α n)
(k : ℕ) (h : k ≤ n) (acc : Vector β k),
Vector.mapM.go✝ f xs k h acc =
if h' : k < n then do
let __do_lift ← f xs[k]
Vector.mapM.go✝¹ f xs (k + 1) ⋯ (acc.push __do_lift)
else pure (Vector.cast ⋯ acc) |
Estimator.fstInst | Mathlib.Deprecated.Estimator | {α : Type u_1} →
{ε : Type u_2} →
{β : Type u_3} →
[inst : PartialOrder α] →
[inst_1 : PartialOrder β] →
[DecidableLT α] →
[∀ (p : α × β), WellFoundedGT { q // q ≤ p }] →
(a : Thunk α) → (b : Thunk β) → (i : Estimator (a.prod b) ε) → Estimator a (Estimator.fst (a.prod b) ε) |
Preorder.continuous_restrictLe | Mathlib.Topology.PreorderRestrict | ∀ {α : Type u_1} [inst : Preorder α] {X : α → Type u_2} [inst_1 : (i : α) → TopologicalSpace (X i)] (a : α),
Continuous (Preorder.restrictLe a) |
_private.Mathlib.NumberTheory.Divisors.0.Nat.divisorsAntidiagonal_eq_prod_filter_of_le._proof_1_9 | Mathlib.NumberTheory.Divisors | ∀ (n1 n2 : ℕ), ¬n1 * n2 = 0 → 0 < n2 |
Lean.Meta.Grind.CongrTheoremCacheKey.mk.inj | Lean.Meta.Tactic.Grind.Types | ∀ {f : Lean.Expr} {numArgs : ℕ} {f_1 : Lean.Expr} {numArgs_1 : ℕ},
{ f := f, numArgs := numArgs } = { f := f_1, numArgs := numArgs_1 } → f = f_1 ∧ numArgs = numArgs_1 |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.collectUsedFVars._sparseCasesOn_1 | Lean.Elab.Structure | {motive : Lean.Elab.Command.Structure.StructFieldDefault → Sort u} →
(t : Lean.Elab.Command.Structure.StructFieldDefault) →
((value : Lean.Expr) → motive (Lean.Elab.Command.Structure.StructFieldDefault.optParam value)) →
(Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.preprocess.norm.match_1 | Lean.Meta.SynthInstance | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) → ((f a : Lean.Expr) → motive (f.app a)) → ((x : Lean.Expr) → motive x) → motive e |
Polynomial.coeff_X_mul_zero | Mathlib.Algebra.Polynomial.Coeff | ∀ {R : Type u} [inst : Semiring R] (p : Polynomial R), (Polynomial.X * p).coeff 0 = 0 |
QuadraticMap.associated_isOrtho._simp_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {Q : QuadraticMap R M N} [inst_5 : Invertible 2] {x y : M},
LinearMap.IsOrtho (QuadraticMap.associated Q) x y = Q.IsOrtho x y |
disjoint_inf_sdiff | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y : α} [inst : GeneralizedBooleanAlgebra α], Disjoint (x ⊓ y) (x \ y) |
Lean.Meta.Simp.ignoreEquations | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Name → Lean.CoreM Bool |
String.Legacy.Iterator.mk | Init.Data.String.Iterator | String → String.Pos.Raw → String.Legacy.Iterator |
CentroidHom.centerStarEmbedding._proof_2 | Mathlib.Algebra.Star.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocSemiring α], SubsemiringClass (Subsemiring (CentroidHom α)) (CentroidHom α) |
_private.Init.Data.SInt.Bitwise.0.Int8.xor_left_inj._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) |
Option.instDecidableEq._proof_1 | Init.Data.Option.Basic | ∀ {α : Type u_1}, none = none |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Take.0.Std.IterM.step_take.match_3.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Take | ∀ (motive : ℕ → Sort u_1) (k : ℕ) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match k.succ with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_2 k |
OpenPartialHomeomorph.isManifold_singleton | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {n : WithTop ℕ∞}
{M : Type u_4} [inst_4 : TopologicalSpace M] (e : OpenPartialHomeomorph M H) (h : e.source = Set.univ),
IsManifold I n M |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_erase_self._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
GroupTopology.instCompleteLattice._proof_3 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u_1} [inst : Group α] (a b c : GroupTopology α), a ≤ c → b ≤ c → SemilatticeSup.sup a b ≤ c |
Subalgebra.algebraicClosure_eq_integralClosure | Mathlib.RingTheory.Algebraic.Integral | ∀ (S : Type u_2) [inst : CommRing S] {K : Type u_4} [inst_1 : Field K] [inst_2 : Algebra K S],
Subalgebra.algebraicClosure K S = integralClosure K S |
Lean.Doc.output | Lean.Elab.DocString.Builtin | Lean.Ident →
optParam (Option (Lean.Doc.WithSyntax Lean.MessageSeverity)) none →
Lean.StrLit → Lean.Doc.DocM (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) |
_private.Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn.0.MeasureTheory.SignedMeasure.existsNatOneDivLTMeasure_of_not_negative | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Hahn | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : MeasureTheory.SignedMeasure α} {i : Set α},
¬MeasureTheory.VectorMeasure.restrict s i ≤ MeasureTheory.VectorMeasure.restrict 0 i →
∃ n, MeasureTheory.SignedMeasure.ExistsOneDivLT✝ s i n |
IO.FS.Handle.putStrLn | Init.System.IO | IO.FS.Handle → String → IO Unit |
Std.HashMap.getElem!_filterMap | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] [inst_2 : Inhabited γ] {f : α → β → Option γ} {k : α},
(Std.HashMap.filterMap f m)[k]! = (m[k]?.pbind fun x_2 h' => f (m.getKey k ⋯) x_2).get! |
CategoryTheory.ShortComplex.LeftHomologyMapData.quasiIso_iff | Mathlib.Algebra.Homology.ShortComplex.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] {φ : S₁ ⟶ S₂}
{h₁ : S₁.LeftHomologyData} {h₂ : S₂.LeftHomologyData} (γ : CategoryTheory.ShortComplex.LeftHomologyMapData φ h₁ h₂),
CategoryTheory.ShortComplex.QuasiIso φ ↔ CategoryTheory.IsIso γ.φH |
Mathlib.Tactic.DeprecateTo.mkDeprecationStx | Mathlib.Tactic.DeprecateTo | Lean.TSyntax `ident → Lean.Name → optParam (Option String) none → Lean.Elab.Command.CommandElabM (Lean.TSyntax `command) |
Pell.exists_iff_not_isSquare | Mathlib.NumberTheory.Pell | ∀ {d : ℤ}, 0 < d → ((∃ x y, x ^ 2 - d * y ^ 2 = 1 ∧ y ≠ 0) ↔ ¬IsSquare d) |
Std.Time.ZonedDateTime._sizeOf_1 | Std.Time.Zoned.ZonedDateTime | Std.Time.ZonedDateTime → ℕ |
Subgroup.FG.pi | Mathlib.GroupTheory.Finiteness | ∀ {ι : Type u_5} [Finite ι] {G : ι → Type u_6} [inst : (i : ι) → Group (G i)] {P : (i : ι) → Subgroup (G i)},
(∀ (i : ι), (P i).FG) → (Subgroup.pi Set.univ P).FG |
AddSubgroup.equivOp | Mathlib.Algebra.Group.Subgroup.MulOpposite | {G : Type u_2} → [inst : AddGroup G] → (H : AddSubgroup G) → ↥H ≃ ↥H.op |
CategoryTheory.Bicategory.prod_Hom | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C] (X Y : B × C),
(X ⟶ Y) = ((X.1 ⟶ Y.1) × (X.2 ⟶ Y.2)) |
SkewMonoidAlgebra.support_single_mul_subset | Mathlib.Algebra.SkewMonoidAlgebra.Support | ∀ {k : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : Semiring k] [inst_2 : MulSemiringAction G k]
(f : SkewMonoidAlgebra k G) [inst_3 : DecidableEq G] (r : k) (a : G),
(SkewMonoidAlgebra.single a r * f).support ⊆ Finset.image (fun x => a * x) f.support |
Std.HashMap.Raw.get!_diff | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] [inst_4 : Inhabited β],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁ \ m₂).get! k = if k ∈ m₂ then default else m₁.get! k |
_private.Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt.0.SummationFilter.symmetricIcc_eq_symmetricIoo_int._simp_1_5 | Mathlib.Topology.Algebra.InfiniteSum.ConditionalInt | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.size_insertUnit | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (units : Array (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)))
(assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment) (b : Bool)
(l : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)),
(Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.insertUnit (units, assignments, b) l).2.1.size = assignments.size |
InnerProductSpace.HarmonicOnNhd.continuousOn | Mathlib.Analysis.InnerProductSpace.Harmonic.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F] {f : E → F} {s : Set E},
InnerProductSpace.HarmonicOnNhd f s → ContinuousOn f s |
PolynomialModule.smul_single_apply | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (i : ℕ)
(f : Polynomial R) (m : M) (n : ℕ), (f • (PolynomialModule.single R i) m) n = if i ≤ n then f.coeff (n - i) • m else 0 |
ProbabilityTheory.Kernel.iIndepFun.indepFun_add_left₀ | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α} {β : Type u_8} {m : MeasurableSpace β} [inst : Add β]
[MeasurableAdd₂ β] {f : ι → Ω → β},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
(∀ (i : ι), AEMeasurable (f i) (μ.bind ⇑κ)) →
∀ (i j k : ι), i ≠ k → j ≠ k → ProbabilityTheory.Kernel.IndepFun (f i + f j) (f k) κ μ |
CompleteDistribLattice.MinimalAxioms.inf_sSup_le_iSup_inf | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} (self : CompleteDistribLattice.MinimalAxioms α) (a : α) (s : Set α), a ⊓ sSup s ≤ ⨆ b ∈ s, a ⊓ b |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.card_badVertices_le | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} (G : SimpleGraph α) [inst : DecidableRel G.Adj] {ε : ℝ} {s t : Finset α},
2 * ε ≤ ↑(G.edgeDensity s t) → G.IsUniform ε s t → ↑(SimpleGraph.badVertices✝ G ε s t).card ≤ ↑s.card * ε |
_private.Init.Grind.ToIntLemmas.0.Lean.Grind.IntInterval.lo?.match_1.eq_1 | Init.Grind.ToIntLemmas | ∀ (motive : Lean.Grind.IntInterval → Sort u_1) (lo hi : ℤ)
(h_1 : (lo hi : ℤ) → motive (Lean.Grind.IntInterval.co lo hi))
(h_2 : (lo : ℤ) → motive (Lean.Grind.IntInterval.ci lo)) (h_3 : (hi : ℤ) → motive (Lean.Grind.IntInterval.io hi))
(h_4 : Unit → motive Lean.Grind.IntInterval.ii),
(match Lean.Grind.IntInterval.co lo hi with
| Lean.Grind.IntInterval.co lo hi => h_1 lo hi
| Lean.Grind.IntInterval.ci lo => h_2 lo
| Lean.Grind.IntInterval.io hi => h_3 hi
| Lean.Grind.IntInterval.ii => h_4 ()) =
h_1 lo hi |
AlgebraicGeometry.instGeometricallyReducedSndScheme | Mathlib.AlgebraicGeometry.Geometrically.Reduced | ∀ {X Y S : AlgebraicGeometry.Scheme} (f : X ⟶ S) (g : Y ⟶ S) [AlgebraicGeometry.GeometricallyReduced f],
AlgebraicGeometry.GeometricallyReduced (CategoryTheory.Limits.pullback.snd f g) |
CongruenceSubgroup.strictWidthInfty_Gamma | Mathlib.NumberTheory.ModularForms.Cusps | ∀ (N : ℕ) [NeZero N],
(Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N)).strictWidthInfty = ↑N |
Lean.Omega.IntList.dot_mod_gcd_left | Init.Omega.IntList | ∀ (xs ys : Lean.Omega.IntList), xs.dot ys % ↑xs.gcd = 0 |
Set.Ico_disjoint_Ico._simp_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type v} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Disjoint (Set.Ico a₁ a₂) (Set.Ico b₁ b₂) = (min a₂ b₂ ≤ max a₁ b₁) |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.step₁.mid | Mathlib.Algebra.Homology.Factorizations.CM5a | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
CochainComplex C ℤ → CochainComplex C ℤ → [CategoryTheory.EnoughInjectives C] → ℤ → CochainComplex C ℤ |
Multiset.sum.eq_1 | Mathlib.Algebra.BigOperators.Group.Multiset.Defs | ∀ {M : Type u_3} [inst : AddCommMonoid M], Multiset.sum = Multiset.foldr (fun x1 x2 => x1 + x2) 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.