name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
RootPairing.RootPositiveForm.posForm._proof_5 | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {S : Type u_1} [inst : CommRing S], RingHomSurjective (RingHom.id S) |
_private.Init.Data.String.Basic.0.String.Pos.ofSliceTo_sliceTo._simp_1_1 | Init.Data.String.Basic | ∀ {s : String} {x y : s.Pos}, (x = y) = (x.offset = y.offset) |
Std.DHashMap.Const.get!_inter_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α}, k ∉ m₂ → Std.DHashMap.Const.get! (m₁.inter m₂) k = default |
Std.TreeMap.minKey_le_minKey_erase | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{he : (t.erase k).isEmpty = false}, (cmp (t.minKey ⋯) ((t.erase k).minKey he)).isLE = true |
contDiffGroupoid_prod | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : 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] {E' : Type u_5} {H' : Type u_6}
[inst_4 : NormedAddCommGroup E'] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : TopologicalSpace H']
{I : ModelWithCorners 𝕜 E H} {I' : ModelWithCorners 𝕜 E' H'} {e : OpenPartialHomeomorph H H}
{e' : OpenPartialHomeomorph H' H'},
e ∈ contDiffGroupoid n I → e' ∈ contDiffGroupoid n I' → e.prod e' ∈ contDiffGroupoid n (I.prod I') |
LinOrd.hom_comp | Mathlib.Order.Category.LinOrd | ∀ {X Y Z : LinOrd} (f : X ⟶ Y) (g : Y ⟶ Z),
LinOrd.Hom.hom (CategoryTheory.CategoryStruct.comp f g) = (LinOrd.Hom.hom g).comp (LinOrd.Hom.hom f) |
_private.Mathlib.Data.Num.Basic.0.PosNum.sqrtAux._unsafe_rec | Mathlib.Data.Num.Basic | PosNum → Num → Num → Num |
_private.Mathlib.Util.WhatsNew.0.Mathlib.WhatsNew.whatsNew.match_1 | Mathlib.Util.WhatsNew | (motive : Lean.Name × Lean.ConstantInfo → Sort u_1) →
(x : Lean.Name × Lean.ConstantInfo) → ((c : Lean.Name) → (i : Lean.ConstantInfo) → motive (c, i)) → motive x |
Set.piecewise_preimage | Mathlib.Data.Set.Piecewise | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) [inst : (j : α) → Decidable (j ∈ s)] (f g : α → β) (t : Set β),
s.piecewise f g ⁻¹' t = s.ite (f ⁻¹' t) (g ⁻¹' t) |
Submodule.hasDistribPointwiseNeg._proof_3 | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] (S : Submodule R A),
(-S).toAddSubmonoid = -S.toAddSubmonoid |
Polynomial.normUnit_X | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] [inst_1 : NoZeroDivisors R] [inst_2 : NormalizationMonoid R],
normUnit Polynomial.X = 1 |
ProofWidgets.FilterDetailsProps.recOn | ProofWidgets.Component.FilterDetails | {motive : ProofWidgets.FilterDetailsProps → Sort u} →
(t : ProofWidgets.FilterDetailsProps) →
((summary filtered all : ProofWidgets.Html) →
(initiallyFiltered : Bool) →
motive { summary := summary, filtered := filtered, all := all, initiallyFiltered := initiallyFiltered }) →
motive t |
CategoryTheory.Limits.functorCategoryHasLimitsOfShape | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.Functor K C) |
AddSubsemigroup.prod_eq_top_iff | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Add M] [inst_1 : Add N] [Nonempty M] [Nonempty N] {s : AddSubsemigroup M}
{t : AddSubsemigroup N}, s.prod t = ⊤ ↔ s = ⊤ ∧ t = ⊤ |
WeierstrassCurve.Jacobian.Point.toAffineAddEquiv_symm_apply | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] (W : WeierstrassCurve.Jacobian F) [inst_1 : DecidableEq F] (a : W.toAffine.Point),
(WeierstrassCurve.Jacobian.Point.toAffineAddEquiv W).symm a = WeierstrassCurve.Jacobian.Point.fromAffine a |
Lean.Server.Snapshots.Snapshot.mk.injEq | Lean.Server.Snapshots | ∀ (stx : Lean.Syntax) (mpState : Lean.Parser.ModuleParserState) (cmdState : Lean.Elab.Command.State)
(stx_1 : Lean.Syntax) (mpState_1 : Lean.Parser.ModuleParserState) (cmdState_1 : Lean.Elab.Command.State),
({ stx := stx, mpState := mpState, cmdState := cmdState } =
{ stx := stx_1, mpState := mpState_1, cmdState := cmdState_1 }) =
(stx = stx_1 ∧ mpState = mpState_1 ∧ cmdState = cmdState_1) |
Lean.CodeAction.CommandCodeActionEntry.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActionEntry} →
t = t' → Lean.CodeAction.CommandCodeActionEntry.noConfusionType P t t' |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.done.noConfusion | Lean.Meta.Tactic.Grind.Intro | {P : Sort u} →
{goal goal' : Lean.Meta.Grind.Goal} →
Lean.Meta.Grind.IntroResult.done✝ goal = Lean.Meta.Grind.IntroResult.done✝¹ goal' → (goal = goal' → P) → P |
HurwitzZeta.hurwitzZetaEven_apply_zero | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle), HurwitzZeta.hurwitzZetaEven a 0 = if a = 0 then -1 / 2 else 0 |
Lean.Elab.Command.instInhabitedPreElabHeaderResult | Lean.Elab.MutualInductive | Inhabited Lean.Elab.Command.PreElabHeaderResult |
ComplexShape.embeddingDown'Add._proof_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {A : Type u_1} [inst : AddCommSemigroup A] [inst_1 : IsRightCancelAdd A] (a b i₁ i₂ : A),
(ComplexShape.down' a).Rel i₁ i₂ ↔ (ComplexShape.down' a).Rel ((fun x => x + b) i₁) ((fun x => x + b) i₂) |
instTransIff | Init.Core | Trans Iff Iff Iff |
CategoryTheory.Limits.hasPullback_op_iff_hasPushout | 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.op g.op ↔ CategoryTheory.Limits.HasPushout f g |
Real.sinc_apply | Mathlib.Analysis.SpecialFunctions.Trigonometric.Sinc | ∀ {x : ℝ}, Real.sinc x = if x = 0 then 1 else Real.sin x / x |
Nucleus.instFrame._proof_4 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (s : Set (Nucleus X)) (a : Nucleus X), (∀ b ∈ s, a ≤ b) → a ≤ sInf s |
iSup_symmDiff_iSup_le | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : CompleteBooleanAlgebra α] {f g : ι → α},
symmDiff (⨆ i, f i) (⨆ i, g i) ≤ ⨆ i, symmDiff (f i) (g i) |
_private.Mathlib.Algebra.GroupWithZero.Invertible.0.invertibleDiv._simp_1 | Mathlib.Algebra.GroupWithZero.Invertible | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c |
Filter.le_map₂_iff | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {h : Filter γ},
h ≤ Filter.map₂ m f g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → Set.image2 m s t ∈ h |
Set.image_val_sUnion | Mathlib.Data.Set.Subset | ∀ {α : Type u_2} {A : Set α} {T : Set (Set ↑A)}, Subtype.val '' ⋃₀ T = ⋃₀ {x | ∃ B ∈ T, Subtype.val '' B = x} |
Numbering.prefixedEquiv._proof_4 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] (s : Finset X), Fintype.card ↥s ≤ Fintype.card X |
Subgroup.transferTransversal | Mathlib.GroupTheory.Transfer | {G : Type u_1} → [inst : Group G] → (H : Subgroup G) → G → H.LeftTransversal |
AddAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {N : AddSubgroup G} [N.Normal] (a : X),
AddAction.IsBlock G (AddAction.orbit (↥N) a) |
Matrix.instPartialOrder | Mathlib.Analysis.Matrix.Order | {𝕜 : Type u_1} → {n : Type u_2} → [RCLike 𝕜] → PartialOrder (Matrix n n 𝕜) |
UniformOnFun.instPseudoEMetricSpace._proof_5 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : PseudoEMetricSpace β] [inst_1 : Finite ↑𝔖],
uniformity (UniformOnFun α β 𝔖) = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} |
ArithmeticFunction.instModule | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} →
{M : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] → [Module R M] → Module (ArithmeticFunction R) (ArithmeticFunction M) |
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Defs___unexpand_Algebra_linearMap_2 | Mathlib.Algebra.Algebra.Defs | Lean.PrettyPrinter.Unexpander |
MvPolynomial.aeval_expand | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ) {A : Type u_5} [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] (f : σ → A) (φ : MvPolynomial σ R),
(MvPolynomial.aeval f) ((MvPolynomial.expand p) φ) = (MvPolynomial.aeval (f ^ p)) φ |
_private.Mathlib.Data.Bool.Basic.0.Bool.injective_iff._proof_1_1 | Mathlib.Data.Bool.Basic | ∀ {α : Sort u_1} {f : Bool → α}, f false ≠ f true → ∀ (x y : Bool), f x = f y → x = y |
_private.Mathlib.LinearAlgebra.Pi.0.LinearEquiv.piOptionEquivProd._simp_1 | Mathlib.LinearAlgebra.Pi | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.regularity.match_1_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x z w : ZFSet.{u_1}) (motive : w ∈ x ∧ w ∈ z → Prop) (x_1 : w ∈ x ∧ w ∈ z),
(∀ (wx : w ∈ x) (wz : w ∈ z), motive ⋯) → motive x_1 |
Monotone.antitone_iterate_of_map_le | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x : α}, Monotone f → f x ≤ x → Antitone fun n => f^[n] x |
lift_rank_range_le | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Cardinal.lift.{v, v'} (Module.rank R ↥f.range) ≤ Cardinal.lift.{v', v} (Module.rank R M) |
Nat.lt | Init.Prelude | ℕ → ℕ → Prop |
_private.Mathlib.Computability.TMToPartrec.0.Turing.PartrecToTM2.trNormal.match_1.eq_3 | Mathlib.Computability.TMToPartrec | ∀ (motive : Turing.ToPartrec.Code → Turing.PartrecToTM2.Cont' → Sort u_1) (k : Turing.PartrecToTM2.Cont')
(h_1 : (k : Turing.PartrecToTM2.Cont') → motive Turing.ToPartrec.Code.zero' k)
(h_2 : (k : Turing.PartrecToTM2.Cont') → motive Turing.ToPartrec.Code.succ k)
(h_3 : (k : Turing.PartrecToTM2.Cont') → motive Turing.ToPartrec.Code.tail k)
(h_4 : (f fs : Turing.ToPartrec.Code) → (k : Turing.PartrecToTM2.Cont') → motive (f.cons fs) k)
(h_5 : (f g : Turing.ToPartrec.Code) → (k : Turing.PartrecToTM2.Cont') → motive (f.comp g) k)
(h_6 : (f g : Turing.ToPartrec.Code) → (k : Turing.PartrecToTM2.Cont') → motive (f.case g) k)
(h_7 : (f : Turing.ToPartrec.Code) → (k : Turing.PartrecToTM2.Cont') → motive f.fix k),
(match Turing.ToPartrec.Code.tail, k with
| Turing.ToPartrec.Code.zero', k => h_1 k
| Turing.ToPartrec.Code.succ, k => h_2 k
| Turing.ToPartrec.Code.tail, k => h_3 k
| f.cons fs, k => h_4 f fs k
| f.comp g, k => h_5 f g k
| f.case g, k => h_6 f g k
| f.fix, k => h_7 f k) =
h_3 k |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic.0.IsIntegral.of_pow.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {x : B} {n : ℕ}
(motive : IsIntegral R (x ^ n) → Prop) (hx : IsIntegral R (x ^ n)),
(∀ (p : Polynomial R) (hmonic : p.Monic) (heval : Polynomial.eval₂ (algebraMap R B) (x ^ n) p = 0), motive ⋯) →
motive hx |
CategoryTheory.MonObj.mk | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
(one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
(mul : CategoryTheory.MonoidalCategoryStruct.tensorObj X X ⟶ X) →
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight one X) mul =
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).hom)
CategoryTheory.MonObj.one_mul._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X one) mul =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom)
CategoryTheory.MonObj.mul_one._autoParam →
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight mul X) mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X X X).hom
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X mul)
mul))
CategoryTheory.MonObj.mul_assoc._autoParam →
CategoryTheory.MonObj X |
Lean.Server.Ilean.rec | Lean.Server.References | {motive : Lean.Server.Ilean → Sort u} →
((version : ℕ) →
(module : Lean.Name) →
(directImports : Array Lean.Lsp.ImportInfo) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) →
motive
{ version := version, module := module, directImports := directImports, references := references,
decls := decls }) →
(t : Lean.Server.Ilean) → motive t |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.exists_isBasis.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) (X : Set α) (motive : (∃ J, M.IsBasis J X ∧ ∅ ⊆ J) → Prop)
(x : ∃ J, M.IsBasis J X ∧ ∅ ⊆ J), (∀ (w : Set α) (hI : M.IsBasis w X) (right : ∅ ⊆ w), motive ⋯) → motive x |
Set.LeftInvOn.image_inter | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {f : α → β} {f' : β → α},
Set.LeftInvOn f' f s → f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s |
Filter.Germ.LiftRel._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (r : β → γ → Prop) (_f : α → β) (_g : α → γ) (_f' : α → β)
(_g' : α → γ),
(l.germSetoid β) _f _f' →
(l.germSetoid γ) _g _g' → (∀ᶠ (x : α) in l, r (_f x) (_g x)) = ∀ᶠ (x : α) in l, r (_f' x) (_g' x) |
ContinuousMultilinearMap.currySumEquiv._proof_11 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (G' : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G']
[inst_2 : NormedSpace 𝕜 G'], SMulCommClass 𝕜 𝕜 G' |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance.eq_def | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : String.Slice) (patByte : UInt8) (table : Array ℕ) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (guess : ℕ) (hg : guess < table.size),
String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝ pat patByte table ht h guess hg =
if pat.getUTF8Byte { byteIdx := guess } ⋯ = patByte then ⟨guess + 1, ⋯⟩
else
if h₀ : guess = 0 then ⟨0, ⋯⟩
else
have this := ⋯;
String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝¹ pat patByte table ht h table[guess - 1] ⋯ |
CategoryTheory.Limits.image.lift_mk_comp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasImage g] (h : Y ⟶ CategoryTheory.Limits.image g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) (CategoryTheory.Limits.image.ι g) =
CategoryTheory.CategoryStruct.comp f g →
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) (CategoryTheory.Limits.image.ι g) =
CategoryTheory.CategoryStruct.comp f g |
CategoryTheory.Limits.coprod.braiding_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
(P Q : C),
(CategoryTheory.Limits.coprod.braiding P Q).inv =
CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl |
PNat.XgcdType.flip_z | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.z = u.w |
LieSubmodule.mem_map_of_mem | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup M']
[inst_6 : Module R M'] [inst_7 : LieRingModule L M'] {f : M →ₗ⁅R,L⁆ M'} {N : LieSubmodule R L M} {m : M},
m ∈ N → f m ∈ LieSubmodule.map f N |
Sum.smul_inl | Mathlib.Algebra.Group.Action.Sum | ∀ {M : Type u_1} {α : Type u_3} {β : Type u_4} [inst : SMul M α] [inst_1 : SMul M β] (a : M) (b : α),
a • Sum.inl b = Sum.inl (a • b) |
RingEquiv.ofHomInv_symm_apply | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] (f : R →+* S) (g : S →+* R)
(h₁ : f.comp g = RingHom.id S) (h₂ : g.comp f = RingHom.id R) (a : S), (RingEquiv.ofRingHom f g h₁ h₂).symm a = g a |
CategoryTheory.Limits.limitIsoLimitCurryCompLim | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
(G : CategoryTheory.Functor (J × K) C) →
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape K C] →
[inst_4 :
CategoryTheory.Limits.HasLimit
((CategoryTheory.Functor.curry.obj G).comp CategoryTheory.Limits.lim)] →
CategoryTheory.Limits.limit G ≅
CategoryTheory.Limits.limit ((CategoryTheory.Functor.curry.obj G).comp CategoryTheory.Limits.lim) |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryToUnit._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
⦃X_1 Y : CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)⦄ (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({ obj := fun Y => CategoryTheory.Over.mk (CategoryTheory.SemiCartesianMonoidalCategory.snd Y.left X),
map := fun {Y Z} g =>
CategoryTheory.Over.homMk (CategoryTheory.MonoidalCategoryStruct.whiskerRight g.left X) ⋯,
map_id := ⋯, map_comp := ⋯ }.comp
(CategoryTheory.Over.map f)).map
f_1)
(CategoryTheory.Over.homMk (CategoryTheory.SemiCartesianMonoidalCategory.fst Y.left X) ⋯) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.homMk (CategoryTheory.SemiCartesianMonoidalCategory.fst X_1.left X) ⋯)
((CategoryTheory.Functor.id (CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C))).map f_1) |
_private.Lean.Compiler.ExternAttr.0.Lean.isExternC._sparseCasesOn_2 | Lean.Compiler.ExternAttr | {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.Mathlib.Data.List.Cycle.0.Cycle.Subsingleton.congr._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {s : Cycle α}, s.Subsingleton = (s.length ≤ 1) |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.ApproximatesLinearOn.norm_fderiv_sub_le._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {t : Set β} {a : α} {x : β}, (x ∈ a • t) = ∃ y ∈ t, a • y = x |
cantorSequence_eq_self_sub_sum_cantorToTernary | Mathlib.Topology.Instances.CantorSet | ∀ (x : ℝ) (n : ℕ),
(cantorSequence x).get n = (x - ∑ i ∈ Finset.range n, Real.ofDigitsTerm (cantorToTernary x).get i) * 3 ^ n |
Batteries.UnionFind.equiv_empty._simp_1 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ}, Batteries.UnionFind.empty.Equiv a b = (a = b) |
instMetricSpaceEmpty._proof_5 | Mathlib.Topology.MetricSpace.Defs | ∀ (x x : Empty), 0 = 0 |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.isPrimitiveRoot_exp_of_isCoprime._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (↑n * x) |
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)
{i j : ℕ} (hij : j + 1 = i) (z : (Fin i → G) →₀ ↑X.X₃.V)
(hz : (CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains X.X₃).d i j)) z = 0)
(y : (Fin i → G) →₀ ↑X.X₂.V),
(CategoryTheory.ConcreteCategory.hom ((groupHomology.chainsMap (MonoidHom.id G) X.g).f i)) y = z →
∀ (x : (Fin j → G) →₀ ↑X.X₁.V)
(hx :
(Finsupp.mapRange.linearMap (ModuleCat.Hom.hom X.f.hom)) x =
(CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains X.X₂).d i j)) y),
(CategoryTheory.ConcreteCategory.hom (groupHomology.δ hX i j hij))
((CategoryTheory.ConcreteCategory.hom (groupHomology.π X.X₃ i)) (groupHomology.cyclesMk i j ⋯ z ⋯)) =
(CategoryTheory.ConcreteCategory.hom (groupHomology.π X.X₁ j)) (groupHomology.cyclesMkOfCompEqD hX hx) |
Std.DTreeMap.Internal.Impl.WF.casesOn | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{β : α → Type v} {a : Std.DTreeMap.Internal.Impl α β} (t : a.WF),
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} (a : t.Balanced) (a_1 : ∀ [Std.TransOrd α], t.Ordered),
motive t ⋯) →
(∀ {x : α → Type v}, motive Std.DTreeMap.Internal.Impl.empty ⋯) →
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced} {k : α} {v : x k} (a : t.WF),
motive (Std.DTreeMap.Internal.Impl.insert k v t h).impl ⋯) →
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced} {k : α} {v : x k} (a : t.WF),
motive (Std.DTreeMap.Internal.Impl.insertIfNew k v t h).impl ⋯) →
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced} {k : α} (a : t.WF),
motive (Std.DTreeMap.Internal.Impl.erase k t h).impl ⋯) →
(∀ {x : α → Type v} [inst_1 : Std.LawfulEqOrd α] {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced}
{k : α} {f : Option (x k) → Option (x k)} (a : t.WF),
motive (Std.DTreeMap.Internal.Impl.alter k f t h).impl ⋯) →
(∀ {x : Type v} {t : Std.DTreeMap.Internal.Impl α fun x_1 => x} {h : t.Balanced} {k : α}
{f : Option x → Option x} (a : t.WF),
motive (Std.DTreeMap.Internal.Impl.Const.alter k f t h).impl ⋯) →
(∀ {x : α → Type v} [inst_1 : Std.LawfulEqOrd α] {t : Std.DTreeMap.Internal.Impl α x} {k : α}
{f : x k → x k} (a : t.WF), motive (Std.DTreeMap.Internal.Impl.modify k f t) ⋯) →
(∀ {x : Type v} {t : Std.DTreeMap.Internal.Impl α fun x_1 => x} {k : α} {f : x → x} (a : t.WF),
motive (Std.DTreeMap.Internal.Impl.Const.modify k f t) ⋯) →
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced} {k : α} {v : x k}
(a : t.WF), motive (Std.DTreeMap.Internal.Impl.containsThenInsert k v t h).2.impl ⋯) →
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced} {k : α} {v : x k}
(a : t.WF), motive (Std.DTreeMap.Internal.Impl.containsThenInsertIfNew k v t h).2.impl ⋯) →
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} {h : t.Balanced}
{f : (a : α) → x a → Bool} (a : t.WF),
motive (Std.DTreeMap.Internal.Impl.filter f t h).impl ⋯) →
(∀ {x : α → Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α x} {f : (a : α) → x a → x a → x a}
{h : t₁.Balanced} [inst_1 : Std.LawfulEqOrd α] (a : t₁.WF),
motive (Std.DTreeMap.Internal.Impl.mergeWith f t₁ t₂ h).impl ⋯) →
(∀ {x : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x_1 => x} {f : α → x → x → x}
{h : t₁.Balanced} (a : t₁.WF),
motive (Std.DTreeMap.Internal.Impl.Const.mergeWith f t₁ t₂ h).impl ⋯) →
(∀ {x : α → Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α x} {h : t₁.Balanced}
(a : t₁.WF), motive (t₁.inter t₂ h) ⋯) →
motive a t |
CategoryTheory.Limits.WalkingMulticospan.functorExt.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
(motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u_3) →
(j : CategoryTheory.Limits.WalkingMulticospan J) →
((i : J.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((i : J.R) → motive (CategoryTheory.Limits.WalkingMulticospan.right i)) → motive j |
_private.Lean.Data.Options.0.Lean.Options.mk.inj | Lean.Data.Options | ∀ {map : Lean.NameMap Lean.DataValue} {hasTrace : Bool} {map_1 : Lean.NameMap Lean.DataValue} {hasTrace_1 : Bool},
{ map := map, hasTrace := hasTrace } = { map := map_1, hasTrace := hasTrace_1 } → map = map_1 ∧ hasTrace = hasTrace_1 |
Turing.TM2to1.StAct.casesOn | Mathlib.Computability.TuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{motive : Turing.TM2to1.StAct K Γ σ k → Sort u} →
(t : Turing.TM2to1.StAct K Γ σ k) →
((a : σ → Γ k) → motive (Turing.TM2to1.StAct.push a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.peek a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct.pop a)) → motive t |
UInt16.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin UInt16.size), (UInt16.ofFin x).toNat = ↑x |
MeasureTheory.Measure.WeaklyRegular.recOn | Mathlib.MeasureTheory.Measure.Regular | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : μ.WeaklyRegular → Sort u} →
(t : μ.WeaklyRegular) →
([toOuterRegular : μ.OuterRegular] → (innerRegular : μ.InnerRegularWRT IsClosed IsOpen) → motive ⋯) →
motive t |
LinearIsometry.comp_continuous_iff._simp_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_5} {E₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂) {α : Type u_11} [inst_6 : TopologicalSpace α] {g : α → E},
Continuous (⇑f ∘ g) = Continuous g |
CategoryTheory.ShortComplex.toCyclesNatTrans | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasKernels C] →
[inst_3 : CategoryTheory.Limits.HasCokernels C] →
CategoryTheory.ShortComplex.π₁ ⟶ CategoryTheory.ShortComplex.cyclesFunctor C |
LieAlgebra.SpecialLinear.val_single | Mathlib.Algebra.Lie.Classical | ∀ {n : Type u_1} {R : Type u₂} [inst : DecidableEq n] [inst_1 : CommRing R] [inst_2 : Fintype n] (i j : n) (h : i ≠ j)
(r : R), ↑((LieAlgebra.SpecialLinear.single i j h) r) = Matrix.single i j r |
Task.get | Init.Core | {α : Type u} → Task α → α |
FinPartOrd._sizeOf_1 | Mathlib.Order.Category.FinPartOrd | FinPartOrd → ℕ |
geom_sum_mul_of_le_one | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [AddLeftReflectLE R] [AddLeftMono R]
[ExistsAddOfLE R] [inst_5 : Sub R] [OrderedSub R] {x : R},
x ≤ 1 → ∀ (n : ℕ), (∑ i ∈ Finset.range n, x ^ i) * (1 - x) = 1 - x ^ n |
AlgebraicGeometry.instIsOpenImmersionMapScheme | Mathlib.AlgebraicGeometry.Morphisms.OpenImmersion | ∀ {X Y X' Y' : AlgebraicGeometry.Scheme} (f : X ⟶ X') (g : Y ⟶ Y') [AlgebraicGeometry.IsOpenImmersion f]
[AlgebraicGeometry.IsOpenImmersion g], AlgebraicGeometry.IsOpenImmersion (CategoryTheory.Limits.coprod.map f g) |
cfc_nonneg_of_predicate._simp_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} [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] [inst_9 : LE A]
[inst_10 : ContinuousFunctionalCalculus R A fun x => 0 ≤ x] {f : R → R} {a : A}, (0 ≤ cfc f a) = True |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.of_eq.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char}
(motive :
(x : Substring.Raw) →
x.str.toList = l ++ m ++ r →
x.startPos.byteIdx = String.utf8Len l → x.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Prop)
(x : Substring.Raw) (x_1 : x.str.toList = l ++ m ++ r) (x_2 : x.startPos.byteIdx = String.utf8Len l)
(x_3 : x.stopPos.byteIdx = String.utf8Len l + String.utf8Len m),
(∀ (s : String)
(h :
{ str := s, startPos := { byteIdx := String.utf8Len l },
stopPos := { byteIdx := String.utf8Len l + String.utf8Len m } }.str.toList =
l ++ m ++ r),
motive
{ str := s, startPos := { byteIdx := String.utf8Len l },
stopPos := { byteIdx := String.utf8Len l + String.utf8Len m } }
h ⋯ ⋯) →
motive x x_1 x_2 x_3 |
CochainComplex.mappingCone.trianglehMapOfHomotopy_hom₂ | 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₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁}
{φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂}
(H : Homotopy (CategoryTheory.CategoryStruct.comp φ₁ b) (CategoryTheory.CategoryStruct.comp a φ₂)),
(CochainComplex.mappingCone.trianglehMapOfHomotopy H).hom₂ = (HomotopyCategory.quotient C (ComplexShape.up ℤ)).map b |
Std.TreeSet.get!_ofList_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.ofList l cmp).get! k' = k |
WithZero.decidableEq | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_1} → [DecidableEq α] → DecidableEq (WithZero α) |
Lean.Compiler.LCNF.CodeDecl.collectUsed | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.CodeDecl pu → optParam Lean.FVarIdHashSet ∅ → Lean.FVarIdHashSet |
Function.Injective.isLeftCancelAdd | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Add M₂] [IsLeftCancelAdd M₂] (f : M₁ → M₂),
Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → IsLeftCancelAdd M₁ |
List.toFinset_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s : List α) (p : α → Bool),
(List.filter p s).toFinset = {x ∈ s.toFinset | p x = true} |
PartENat.casesOn' | Mathlib.Data.Nat.PartENat | ∀ {P : PartENat → Prop} (a : PartENat), P ⊤ → (∀ (n : ℕ), P ↑n) → P a |
Aesop.Frontend.instInhabitedPriority.default | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority |
Real.sin_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), Real.sin (x + ↑n * (2 * Real.pi)) = Real.sin x |
UInt8.pow.match_1 | Init.Data.UInt.Basic | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n |
_private.Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem.0.ValueDistribution.abs_characteristic_sub_characteristic_shift_le._simp_1_2 | Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c |
ZFSet.diff | Mathlib.SetTheory.ZFC.Basic | ZFSet.{u} → ZFSet.{u} → ZFSet.{u} |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝¹) →
motive Lean.Meta.PreprocessKind.noMVars✝ →
motive Lean.Meta.PreprocessKind.mvarsNoOutputParams✝ →
motive Lean.Meta.PreprocessKind.mvarsOutputParams✝ → motive t |
AdicCompletion.liftAlgHom._proof_2 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_1} [inst : CommRing S] (I : Ideal S) {m : ℕ}, (I ^ m).IsTwoSided |
CategoryTheory.createsColimitOfFullyFaithfulOfLift' | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
[F.Full] →
[F.Faithful] →
{l : CategoryTheory.Limits.Cocone (K.comp F)} →
CategoryTheory.Limits.IsColimit l →
(c : CategoryTheory.Limits.Cocone K) → (F.mapCocone c ≅ l) → CategoryTheory.CreatesColimit K F |
Con.commMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : CommMagma M] → (c : Con M) → CommMagma c.Quotient |
_private.Init.Data.List.MapIdx.0.List.mapFinIdx._proof_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (as as_1 : List α) (acc : Array β),
as_1.length + 1 + acc.size = as.length → ¬acc.size < as.length → False |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.