name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Batteries.Data.Array.Basic.0.Array.scanrMFast.loop._proof_1 | Batteries.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α) (start : USize), start.toNat ≤ as.size → start - 1 < start → (start - 1).toNat < as.size |
List.cyclicPermutations_ne_nil._simp_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u} (l : List α), (l.cyclicPermutations = []) = False |
CategoryTheory.MorphismProperty.ext | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (W W' : CategoryTheory.MorphismProperty C),
(∀ ⦃X Y : C⦄ (f : X ⟶ Y), W f ↔ W' f) → W = W' |
measurable_from_prod_countable_left' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
[Countable β] {f : α × β → γ},
(∀ (y : β), Measurable fun x => f (x, y)) →
(∀ (y y' : β) (x : α), y' ∈ measurableAtom y → f (x, y') = f (x, y)) → Measurable f |
CategoryTheory.Limits.SingleObj.Types.sections.equivFixedPoints._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.SingleObj | ∀ {M : Type u_2} [inst : Monoid M] (J : CategoryTheory.Functor (CategoryTheory.SingleObj M) (Type u_1)),
Function.RightInverse (fun p => ⟨fun x => ↑p, ⋯⟩) fun s => ⟨↑s (CategoryTheory.SingleObj.star M), ⋯⟩ |
Lean.Parser.withoutInfo | Lean.Parser.Basic | Lean.Parser.Parser → Lean.Parser.Parser |
mem_irreducibleComponent | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X}, x ∈ irreducibleComponent x |
Besicovitch.SatelliteConfig.inter | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] {N : ℕ} {τ : ℝ} (self : Besicovitch.SatelliteConfig α N τ),
∀ i < Fin.last N, dist (self.c i) (self.c (Fin.last N)) ≤ self.r i + self.r (Fin.last N) |
CategoryTheory.ProjectiveResolution.π_f_succ | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z) (n : ℕ),
P.π.f (n + 1) = 0 |
Algebra.Generators.CotangentSpace.compEquiv._proof_6 | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {S : Type u_1} [inst : CommRing S] {T : Type u_3} [inst_1 : CommRing T] [inst_2 : Algebra S T] {ι : Type u_2}
(Q : Algebra.Generators S T ι), SMulCommClass Q.toExtension.Ring T T |
Finset.Ico_union_Ico' | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : LocallyFiniteOrder α] {a b c d : α},
c ≤ b → a ≤ d → Finset.Ico a b ∪ Finset.Ico c d = Finset.Ico (min a c) (max b d) |
_private.Lean.PrettyPrinter.0.Lean.PrettyPrinter.ppConstNameWithInfos._sparseCasesOn_1 | Lean.PrettyPrinter | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
PUnit.sub_eq | Mathlib.Algebra.Group.PUnit | ∀ (x y : PUnit.{u_1 + 1}), x - y = PUnit.unit |
Subgroup.FiniteIndex | Mathlib.GroupTheory.Index | {G : Type u_1} → [inst : Group G] → Subgroup G → Prop |
CategoryTheory.Presieve.instHasPullbacksSingletonOfHasPullback | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : Y ⟶ X) (g : Z ⟶ X)
[CategoryTheory.Limits.HasPullback g f], (CategoryTheory.Presieve.singleton g).HasPullbacks f |
Nat.toArray_rcc_eq_singleton_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k m n : ℕ}, (m...=n).toArray = #[k] ↔ n = m ∧ m = k |
FirstOrder.Language.age.fg_substructure | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {S : L.Substructure M},
S.FG → { α := ↥S, str := inferInstance } ∈ L.age M |
Std.Tactic.BVDecide.BVPred.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Sort u → Std.Tactic.BVDecide.BVPred → Std.Tactic.BVDecide.BVPred → Sort u |
Function.Injective.completeBooleanAlgebra._proof_4 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : Min α] [inst_2 : LE α] [inst_3 : LT α] [inst_4 : Top α]
[inst_5 : Bot α] [inst_6 : Compl α] [inst_7 : HImp α] [inst_8 : SDiff α] [inst_9 : CompleteBooleanAlgebra β]
(f : α → β) (hf : Function.Injective f) (le : ∀ {x y : α}, f x ≤ f y ↔ x ≤ y) (lt : ∀ {x y : α}, f x < f y ↔ x < y)
(map_sup : ∀ (a b : α), f (a ⊔ b) = f a ⊔ f b) (map_inf : ∀ (a b : α), f (a ⊓ b) = f a ⊓ f b) (map_top : f ⊤ = ⊤)
(map_bot : f ⊥ = ⊥) (map_compl : ∀ (a : α), f aᶜ = (f a)ᶜ) (map_himp : ∀ (a b : α), f (a ⇨ b) = f a ⇨ f b)
(map_sdiff : ∀ (a b : α), f (a \ b) = f a \ f b) (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z |
Filter.mem_pi_of_mem | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} (i : ι) {s : Set (α i)},
s ∈ f i → Function.eval i ⁻¹' s ∈ Filter.pi f |
CategoryTheory.ShortComplex.cyclesFunctor_obj | 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]
(S : CategoryTheory.ShortComplex C), (CategoryTheory.ShortComplex.cyclesFunctor C).obj S = S.cycles |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.0.Equiv.Perm.closure_cycleType_eq_2_2_eq_alternatingGroup._proof_1_16 | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] ⦃g : Equiv.Perm α⦄ (a : α),
g.support = {a, g a, g (g a)} →
[a, g a, g (g a)].Nodup → ∀ (b c : α), b ∈ g.supportᶜ → c ∈ g.supportᶜ → b ≠ c → [b, c, g a, g (g a)].Nodup |
String.Slice.pos!_eq_pos | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p : String.Pos.Raw} (h : String.Pos.Raw.IsValidForSlice s p), s.pos! p = s.pos p h |
InverseSystem.pEquivOnLim._proof_2 | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_2} {F : ι → Type u_3} {X : ι → Type u_1} {i : ι} [inst : LinearOrder ι]
{f : ⦃i j : ι⦄ → i ≤ j → F j → F i} [inst_1 : SuccOrder ι]
{equivSucc : ⦃i : ι⦄ → ¬IsMax i → F (Order.succ i) ≃ F i × X i} [inst_2 : WellFoundedLT ι]
(hi : Order.IsSuccPrelimit i) (e : (j : ↑(Set.Iio i)) → InverseSystem.PEquivOn f equivSucc (Set.Iic ↑j))
(equivLim : F i ≃ ↑(InverseSystem.limit f i)) {i_1 : ι} (hsj : Order.succ i_1 ∈ Set.Iic i) (hj : ¬IsMax i_1)
(x : F ↑⟨Order.succ i_1, hsj⟩),
(InverseSystem.piEquivLim ⋯ equivLim hi ⟨Order.succ i_1, hsj⟩) x ⟨i_1, ⋯⟩ = ((equivSucc hj) x).2 |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme.0.AlgebraicGeometry.termSbo_ | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | Lean.ParserDescr |
EReal.div_zero | Mathlib.Data.EReal.Inv | ∀ {a : EReal}, a / 0 = 0 |
Aesop.EMap.mk.sizeOf_spec | Aesop.EMap | ∀ {α : Type u_1} [inst : SizeOf α] (rep : Lean.PArray (Option (Lean.Expr × α))) (idx : Lean.Meta.DiscrTree ℕ),
sizeOf { rep := rep, idx := idx } = 1 + sizeOf rep + sizeOf idx |
ProbabilityTheory.indepSets_singleton_iff | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s t : Set Ω},
ProbabilityTheory.IndepSets {s} {t} μ ↔ μ (s ∩ t) = μ s * μ t |
Set.Pairwise.insert_of_symmetric | Mathlib.Data.Set.Pairwise.Basic | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
s.Pairwise r → Symmetric r → (∀ b ∈ s, a ≠ b → r a b) → (insert a s).Pairwise r |
_private.Mathlib.NumberTheory.FLT.Three.0.FermatLastTheoremForThreeGen.Solution.lambda_not_dvd_y | Mathlib.NumberTheory.FLT.Three | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {hζ : IsPrimitiveRoot ζ 3} (S : FermatLastTheoremForThreeGen.Solution hζ)
[inst_1 : NumberField K] [IsCyclotomicExtension {3} ℚ K],
¬hζ.toInteger - 1 ∣ FermatLastTheoremForThreeGen.Solution.y✝ S |
_private.Mathlib.Tactic.Tauto.0.Mathlib.Tactic.Tauto.distribNotAt.match_1 | Mathlib.Tactic.Tauto | (motive : ℕ → List Lean.Expr → Sort u_1) →
(nIters : ℕ) →
(x : List Lean.Expr) →
((x : List Lean.Expr) → motive 0 x) →
((x : ℕ) → motive x []) →
((n : ℕ) → (fv : Lean.Expr) → (fvs : List Lean.Expr) → motive n.succ (fv :: fvs)) → motive nIters x |
Colex.exists._simp_1 | Mathlib.Order.Synonym | ∀ {α : Type u_1} {p : Colex α → Prop}, (∃ a, p a) = ∃ a, p (toColex a) |
CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork_retraction | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X : C} {f : X ⟶ X}
(hf : CategoryTheory.CategoryStruct.comp f f = f)
{c : CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.id X) f} (i : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.Limits.splitMonoOfIdempotentOfIsLimitFork C hf i).retraction =
i.lift (CategoryTheory.Limits.Fork.ofι f ⋯) |
MeasureTheory.AEEqFun.coeFn_add | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Add γ] [inst_3 : ContinuousAdd γ] (f g : α →ₘ[μ] γ), ↑(f + g) =ᵐ[μ] ↑f + ↑g |
AlgebraicGeometry.Scheme.Modules.fromTildeΓNatTrans | Mathlib.AlgebraicGeometry.Modules.Tilde | {R : CommRingCat} →
AlgebraicGeometry.moduleSpecΓFunctor.comp (AlgebraicGeometry.tilde.functor R) ⟶
CategoryTheory.Functor.id (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules |
derivWithin_intCast | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) [inst_3 : IntCast F] (z : ℤ), derivWithin (↑z) s = 0 |
ProofWidgets.LayoutKind.inline | ProofWidgets.Data.Html | ProofWidgets.LayoutKind |
ContinuousLinearMap.flip_smul | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_6} {G : Type u_8}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜₃]
[inst_6 : NormedSpace 𝕜 E] [inst_7 : NormedSpace 𝕜₂ F] [inst_8 : NormedSpace 𝕜₃ G] {σ₂₃ : 𝕜₂ →+* 𝕜₃} {σ₁₃ : 𝕜 →+* 𝕜₃}
[inst_9 : RingHomIsometric σ₂₃] [inst_10 : RingHomIsometric σ₁₃] (c : 𝕜₃) (f : E →SL[σ₁₃] F →SL[σ₂₃] G),
(c • f).flip = c • f.flip |
AddSubgroup.Commensurable.discreteTopology_iff | Mathlib.Topology.Algebra.IsUniformGroup.DiscreteSubgroup | ∀ {G : Type u_2} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{H K : AddSubgroup G}, H.Commensurable K → (DiscreteTopology ↥H ↔ DiscreteTopology ↥K) |
_private.Mathlib.Logic.Basic.0.exists_and_exists_comm.match_1_3 | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {P : α → Prop} {Q : β → Prop} (motive : (∃ a b, P a ∧ Q b) → Prop)
(x : ∃ a b, P a ∧ Q b), (∀ (a : α) (b : β) (ha : P a) (hb : Q b), motive ⋯) → motive x |
IsPrimitiveRoot.neg_one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} [inst : CommRing R] (p : ℕ) [Nontrivial R] [h : CharP R p], p ≠ 2 → IsPrimitiveRoot (-1) 2 |
AddLocalization.liftOn.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {S : AddSubmonoid M} {p : Sort u} (x : AddLocalization S) (f : M → ↥S → p)
(H : ∀ {a c : M} {b d : ↥S}, (AddLocalization.r S) (a, b) (c, d) → f a b = f c d),
x.liftOn f H = AddLocalization.rec f ⋯ x |
ContinuousLinearMapWOT.ext_dual_iff | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_4} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologicalAddGroup F]
[inst_9 : ContinuousConstSMul 𝕜₂ F] [H : SeparatingDual 𝕜₂ F] {A B : E →SWOT[σ] F},
A = B ↔ ∀ (x : E) (y : StrongDual 𝕜₂ F), y (A x) = y (B x) |
_private.Mathlib.RingTheory.TwoSidedIdeal.Operations.0.TwoSidedIdeal.mem_span_iff_mem_addSubgroup_closure_absorbing._simp_1_1 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (carrier : Set R) (zero_mem : 0 ∈ carrier)
(add_mem : ∀ {x y : R}, x ∈ carrier → y ∈ carrier → x + y ∈ carrier) (neg_mem : ∀ {x : R}, x ∈ carrier → -x ∈ carrier)
(mul_mem_left : ∀ {x y : R}, y ∈ carrier → x * y ∈ carrier)
(mul_mem_right : ∀ {x y : R}, x ∈ carrier → x * y ∈ carrier) (x : R),
(x ∈ TwoSidedIdeal.mk' carrier zero_mem add_mem neg_mem mul_mem_left mul_mem_right) = (x ∈ carrier) |
Turing.PartrecToTM2.move₂_ok | Mathlib.Computability.TMToPartrec | ∀ {p : Turing.PartrecToTM2.Γ' → Bool} {k₁ k₂ : Turing.PartrecToTM2.K'} {q : Turing.PartrecToTM2.Λ'}
{s : Option Turing.PartrecToTM2.Γ'} {L₁ : List Turing.PartrecToTM2.Γ'} {o : Option Turing.PartrecToTM2.Γ'}
{L₂ : List Turing.PartrecToTM2.Γ'} {S : Turing.PartrecToTM2.K' → List Turing.PartrecToTM2.Γ'},
k₁ ≠ Turing.PartrecToTM2.K'.rev ∧ k₂ ≠ Turing.PartrecToTM2.K'.rev ∧ k₁ ≠ k₂ →
S Turing.PartrecToTM2.K'.rev = [] →
Turing.PartrecToTM2.splitAtPred p (S k₁) = (L₁, o, L₂) →
StateTransition.Reaches₁ (Turing.TM2.step Turing.PartrecToTM2.tr)
{ l := some (Turing.PartrecToTM2.move₂ p k₁ k₂ q), var := s, stk := S }
{ l := some q, var := none,
stk := Function.update (Function.update S k₁ (o.elim id List.cons L₂)) k₂ (L₁ ++ S k₂) } |
Lean.Elab.Tactic.RCases.RCasesPatt.noConfusion | Lean.Elab.Tactic.RCases | {P : Sort u} →
{t t' : Lean.Elab.Tactic.RCases.RCasesPatt} → t = t' → Lean.Elab.Tactic.RCases.RCasesPatt.noConfusionType P t t' |
Filter.HasBasis.cauchySeq_iff | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {β : Type v} [uniformSpace : UniformSpace α] {γ : Sort u_1} [Nonempty β] [inst : SemilatticeSup β]
{u : β → α} {p : γ → Prop} {s : γ → SetRel α α},
(uniformity α).HasBasis p s →
(CauchySeq u ↔ ∀ (i : γ), p i → ∃ N, ∀ (m : β), N ≤ m → ∀ (n : β), N ≤ n → (u m, u n) ∈ s i) |
TypeVec.toSubtype._unsafe_rec | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : α.Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i x) }) (TypeVec.Subtype_ p) |
Lean.Compiler.LCNF.Code.return.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fvarId fvarId' : Lean.FVarId} →
Lean.Compiler.LCNF.Code.return fvarId = Lean.Compiler.LCNF.Code.return fvarId' → (fvarId = fvarId' → P) → P |
_private.Mathlib.SetTheory.ZFC.Rank.0.PSet.rank_insert._simp_1_2 | Mathlib.SetTheory.ZFC.Rank | ∀ {x y z : PSet.{u}}, (x ∈ insert y z) = (x.Equiv y ∨ x ∈ z) |
Equiv.Perm.IsThreeCycle | Mathlib.GroupTheory.Perm.Cycle.Type | {α : Type u_1} → [Fintype α] → [DecidableEq α] → Equiv.Perm α → Prop |
_private.Lean.Meta.Tactic.Grind.ProofUtil.0.Lean.Meta.Grind.mkLetOfMap.match_3 | Lean.Meta.Tactic.Grind.ProofUtil | (motive : MProd Lean.Expr ℕ → Sort u_1) →
(r : MProd Lean.Expr ℕ) → ((e : Lean.Expr) → (i : ℕ) → motive ⟨e, i⟩) → motive r |
WittVector.idIsPolyI' | Mathlib.RingTheory.WittVector.IsPoly | ∀ (p : ℕ), WittVector.IsPoly p fun x x_1 a => a |
Nat.Partrec.Code.pappAck.match_1 | Mathlib.Computability.Ackermann | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
PosPart.noConfusionType | Mathlib.Algebra.Notation | Sort u → {α : Type u_1} → PosPart α → {α' : Type u_1} → PosPart α' → Sort u |
Lean.Meta.Grind.NormalizePattern.State.recOn | Lean.Meta.Tactic.Grind.EMatchTheorem | {motive : Lean.Meta.Grind.NormalizePattern.State → Sort u} →
(t : Lean.Meta.Grind.NormalizePattern.State) →
((symbols : Array Lean.HeadIndex) →
(symbolSet : Std.HashSet Lean.HeadIndex) →
(bvarsFound : Std.HashSet ℕ) →
motive { symbols := symbols, symbolSet := symbolSet, bvarsFound := bvarsFound }) →
motive t |
Std.ExtDHashMap.Const.get_modify_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : β → β} {h : k ∈ Std.ExtDHashMap.Const.modify m k f},
Std.ExtDHashMap.Const.get (Std.ExtDHashMap.Const.modify m k f) k h = f (Std.ExtDHashMap.Const.get m k ⋯) |
Module.Relations.Solution.IsPresentation.desc.congr_simp | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution solution_1 : relations.Solution M} (e_solution : solution = solution_1)
(h : solution.IsPresentation) {N : Type v'} [inst_3 : AddCommGroup N] [inst_4 : Module A N]
(s s_1 : relations.Solution N), s = s_1 → h.desc s = ⋯.desc s_1 |
Std.DTreeMap.Internal.Impl.Const.maxKeyD_alter!_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).isEmpty = false →
∀ {fallback : α},
(Std.DTreeMap.Internal.Impl.Const.alter! k f t).maxKeyD fallback = k ↔
(f (Std.DTreeMap.Internal.Impl.Const.get? t k)).isSome = true ∧ ∀ k' ∈ t, (compare k' k).isLE = true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal.0.IsCyclotomicExtension.Rat.«term𝒑» | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | Lean.ParserDescr |
FloatArray.map | Batteries.Data.FloatArray | FloatArray → (Float → Float) → FloatArray |
_private.Mathlib.Algebra.Module.ZLattice.Summable.0.ZLattice.sum_piFinset_Icc_rpow_le._simp_1_9 | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n |
_aux_Mathlib_Data_Fintype_Sets___elabRules_finsetStx_1 | Mathlib.Data.Fintype.Sets | Lean.Elab.Term.TermElab |
PartENat.natCast_lt_top._simp_1 | Mathlib.Data.Nat.PartENat | ∀ (x : ℕ), (↑x < ⊤) = True |
CategoryTheory.Subobject.instLattice._proof_1 | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasImages C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] {B : C} (a b : CategoryTheory.Subobject B),
a ≤ SemilatticeSup.sup a b |
CategoryTheory.CatEnrichedOrdinary.instCategoryHom._proof_2 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.EnrichedOrdinaryCategory CategoryTheory.Cat C] {X Y : CategoryTheory.CatEnrichedOrdinary C}
{X_1 Y_1 : X ⟶ Y} (f : X_1 ⟶ Y_1), CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X_1) f = f |
CategoryTheory.Abelian.LeftResolution.karoubi.π | Mathlib.Algebra.Homology.LeftResolution.Reduced | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{ι : CategoryTheory.Functor C A} →
(Λ : CategoryTheory.Abelian.LeftResolution ι) →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive A] →
[ι.Additive] →
(CategoryTheory.Abelian.LeftResolution.karoubi.F Λ).comp
((CategoryTheory.Idempotents.functorExtension₂ C A).obj ι) ⟶
CategoryTheory.Functor.id (CategoryTheory.Idempotents.Karoubi A) |
HomologicalComplex.eval._proof_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (c : ComplexShape ι) (i : ι) (X : HomologicalComplex V c),
(CategoryTheory.CategoryStruct.id X).f i = CategoryTheory.CategoryStruct.id (X.X i) |
SimpleGraph.not_isCompleteMultipartite_iff_exists_isPathGraph3Compl | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {α : Type u} {G : SimpleGraph α}, ¬G.IsCompleteMultipartite ↔ ∃ v w₁ w₂, G.IsPathGraph3Compl v w₁ w₂ |
Set.Subsingleton.countable | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Subsingleton → s.Countable |
QuadraticMap.Isometry.ofEq | Mathlib.LinearAlgebra.QuadraticForm.Isometry | {R : Type u_1} →
{M₁ : Type u_3} →
{N : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M₁] → [inst_4 : Module R N] → {Q₁ Q₂ : QuadraticMap R M₁ N} → Q₁ = Q₂ → Q₁ →qᵢ Q₂ |
Equiv.Perm.apply_mem_support | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, f x ∈ f.support ↔ x ∈ f.support |
PeriodPair.derivWeierstrassPExcept_def | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ (L : PeriodPair) (l₀ : ↥L.lattice) (z : ℂ),
L.derivWeierstrassPExcept (↑l₀) z = L.derivWeierstrassP z + 2 / (z - ↑l₀) ^ 3 |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get!_empty._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
FreeAddMagma.length | Mathlib.Algebra.Free | {α : Type u} → FreeAddMagma α → ℕ |
ContDiffWithinAt.mul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {x : E} {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
[inst_4 : NormedAlgebra 𝕜 𝔸] {s : Set E} {f g : E → 𝔸},
ContDiffWithinAt 𝕜 n f s x → ContDiffWithinAt 𝕜 n g s x → ContDiffWithinAt 𝕜 n (fun x => f x * g x) s x |
Finset.mem_attachFin._simp_1 | Mathlib.Data.Finset.Fin | ∀ {n : ℕ} {s : Finset ℕ} (h : ∀ m ∈ s, m < n) {a : Fin n}, (a ∈ s.attachFin h) = (↑a ∈ s) |
Lean.Compiler.LCNF.Code.isDecl | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Bool |
CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimIso._proof_1 | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {α : Type u_1}
[CategoryTheory.Limits.HasColimitsOfShape (CategoryTheory.Discrete α) C]
(F : CategoryTheory.Functor (CategoryTheory.Discrete α) C), CategoryTheory.Limits.HasColimit F |
CategoryTheory.Sieve.functorPullback_monotone | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) (X : C), Monotone (CategoryTheory.Sieve.functorPullback F) |
exists_orderEmbedding_covby_of_forall_covby_finite | Mathlib.Order.KonigLemma | ∀ {α : Type u_1} [inst : PartialOrder α] [IsStronglyAtomic α] {b : α},
(∀ (a : α), {x | a ⋖ x}.Finite) → (Set.Ici b).Infinite → ∃ f, f 0 = b ∧ ∀ (i : ℕ), f i ⋖ f (i + 1) |
_private.Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable.0.aestronglyMeasurable_union_iff._simp_1_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {p : Bool → Prop}, (∀ (b : Bool), p b) = (p false ∧ p true) |
himp_inf_le | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a b : α}, (a ⇨ b) ⊓ a ≤ b |
isMulTorsionFree_iff_not_isOfFinOrder | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : CommGroup G], IsMulTorsionFree G ↔ ∀ ⦃a : G⦄, a ≠ 1 → ¬IsOfFinOrder a |
_private.Mathlib.Data.List.Induction.0.List.reverseRec_concat._proof_1_58 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x : α) (xs : List α) (head : α) (tail : List α),
head :: tail = xs → ¬(head :: (tail ++ [x])).dropLast ++ [(head :: (tail ++ [x])).getLast ⋯].dropLast = [] |
Topology.IsLocallyConstructible.preimage_of_isOpenEmbedding | Mathlib.Topology.Constructible | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set Y},
Topology.IsLocallyConstructible s → Topology.IsOpenEmbedding f → Topology.IsLocallyConstructible (f ⁻¹' s) |
CoalgCat.forget₂_obj | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u} [inst : CommRing R] (X : CoalgCat R),
(CategoryTheory.forget₂ (CoalgCat R) (ModuleCat R)).obj X = ModuleCat.of R ↑X.toModuleCat |
Lean.Server.References.ParentDecl._sizeOf_inst | Lean.Server.References | SizeOf Lean.Server.References.ParentDecl |
toIocMod_eq_sub | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) (a b : α), toIocMod hp a b = toIocMod hp 0 (b - a) + a |
_private.Lean.Meta.Constructions.BRecOn.0.Lean.buildBelowMinorPremise.go._unsafe_rec | Lean.Meta.Constructions.BRecOn | Lean.Level → Array Lean.Expr → Array Lean.Expr → List Lean.Expr → Lean.MetaM Lean.Expr |
Std.Net.SocketAddressV4._sizeOf_1 | Std.Net.Addr | Std.Net.SocketAddressV4 → ℕ |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.PendingField.ctorIdx | Lean.Elab.StructInst | Lean.Elab.Term.StructInst.PendingField✝ → ℕ |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.densityProcess_mono_kernel_left._simp_1_2 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {a b : ENNReal}, (a / b = ⊤) = (a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤) |
Turing.FinTM2.casesOn | Mathlib.Computability.TMComputable | {motive : Turing.FinTM2 → Sort u} →
(t : Turing.FinTM2) →
({K : Type} →
[kDecidableEq : DecidableEq K] →
[kFin : Fintype K] →
(k₀ k₁ : K) →
(Γ : K → Type) →
(Λ : Type) →
(main : Λ) →
[ΛFin : Fintype Λ] →
(σ : Type) →
(initialState : σ) →
[σFin : Fintype σ] →
[Γk₀Fin : Fintype (Γ k₀)] →
(m : Λ → Turing.TM2.Stmt Γ Λ σ) →
motive
{ K := K, kDecidableEq := kDecidableEq, kFin := kFin, k₀ := k₀, k₁ := k₁, Γ := Γ,
Λ := Λ, main := main, ΛFin := ΛFin, σ := σ, initialState := initialState,
σFin := σFin, Γk₀Fin := Γk₀Fin, m := m }) →
motive t |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.abstractGroundMismatches?.goCore._sparseCasesOn_4 | Lean.Meta.Tactic.Grind.ProveEq | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
(Nat.hasNotBit 2048 t.ctorIdx → motive t) → motive t |
SpecializingMap.stableUnderSpecialization_range | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
SpecializingMap f → StableUnderSpecialization (Set.range f) |
OrderMonoidHom._sizeOf_inst | Mathlib.Algebra.Order.Hom.Monoid | (α : Type u_6) →
(β : Type u_7) →
{inst : Preorder α} →
{inst_1 : Preorder β} →
{inst_2 : MulOneClass α} → {inst_3 : MulOneClass β} → [SizeOf α] → [SizeOf β] → SizeOf (α →*o β) |
Module.finBasisOfFinrankEq | Mathlib.LinearAlgebra.Dimension.Free | (R : Type u) →
(M : Type v) →
[inst : Semiring R] →
[StrongRankCondition R] →
[inst_2 : AddCommMonoid M] →
[inst_3 : Module R M] →
[Module.Free R M] → [Module.Finite R M] → {n : ℕ} → Module.finrank R M = n → Module.Basis (Fin n) R M |
LinearMap.toDistribMulActionHom | Mathlib.Algebra.Module.LinearMap.Defs | {R : Type u_1} →
{S : Type u_5} →
{M : Type u_8} →
{M₃ : Type u_11} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : Module R M] → [inst_5 : Module S M₃] → {σ : R →+* S} → (M →ₛₗ[σ] M₃) → M →ₑ+[↑σ] M₃ |
_private.Lean.Meta.Tactic.Cbv.Util.0.Lean.Meta.Tactic.Cbv.isNatValue | Lean.Meta.Tactic.Cbv.Util | Lean.Expr → Bool |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.