ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: QuadraticMap.polar_neg_right
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
A : Type u_7
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : AddCommGroup N
inst✝¹ : Module R M
inst✝ : Module R N
Q : QuadraticMap R M N
x y : M
⊢ polar (⇑Q) x (-y) = -polar (⇑Q) x y
state_after: no goals
tactic: rw [← neg_one_smul R y, polar_smul_right, neg_one_smul]
Theorem: Computation.orElse_empty
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ (HOrElse.hOrElse c fun x => empty α) = c
state_after: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ IsBisimulation fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁
tactic: apply eq_of_bisim (fun c₁ c₂ => (c₂ <|> empty α) = c₁) _ rfl
state_before: α : Type u
β : Type v
γ : Type w
c : Computation α
⊢ IsBisimulation fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁
state_after: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) s'.destruct s.destruct
tactic: intro s' s h
state_before: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) s'.destruct s.destruct
state_after: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) (HOrElse.hOrElse s fun x => empty α).destruct
    s.destruct
tactic: rw [← h]
state_before: α : Type u
β : Type v
γ : Type w
c s' s : Computation α
h : (HOrElse.hOrElse s fun x => empty α) = s'
⊢ BisimO (fun c₁ c₂ => (HOrElse.hOrElse c₂ fun x => empty α) = c₁) (HOrElse.hOrElse s fun x => empty α).destruct
    s.destruct
state_after: case h2
α : Type u
β : Type v
γ : Type w
c s' s✝ : Computation α
h : (HOrElse.hOrElse s✝ fun x => empty α) = s'
s : Computation α
⊢ (HOrElse.hOrElse s fun x => (empty α).think) = HOrElse.hOrElse s fun x => empty α
tactic: apply recOn s <;> intro s <;> rw [think_empty] <;> simp
state_before: case h2
α : Type u
β : Type v
γ : Type w
c s' s✝ : Computation α
h : (HOrElse.hOrElse s✝ fun x => empty α) = s'
s : Computation α
⊢ (HOrElse.hOrElse s fun x => (empty α).think) = HOrElse.hOrElse s fun x => empty α
state_after: no goals
tactic: rw [← think_empty]
Theorem: ONote.fastGrowingε₀_one
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: ⊢ fastGrowingε₀ 1 = 2
state_after: no goals
tactic: simp [fastGrowingε₀, show oadd 0 1 0 = 1 from rfl]
Theorem: FreeGroup.Red.append_append_left_iff
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L✝ L₁ L₂ L₃ L₄ : List (α × Bool)
p : α × Bool
L : List (α × Bool)
⊢ Red (p :: L ++ L₁) (p :: L ++ L₂) ↔ Red L₁ L₂
state_after: no goals
tactic: simp [append_append_left_iff L, cons_cons_iff]
Theorem: Associates.factors_eq_some_iff_ne_zero
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
⊢ (∃ s, a.factors = ↑s) ↔ a ≠ 0
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
⊢ a.factors ≠ ⊤ ↔ a ≠ 0
tactic: simp_rw [@eq_comm _ a.factors, ← WithTop.ne_top_iff_exists]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : Associates α
⊢ a.factors ≠ ⊤ ↔ a ≠ 0
state_after: no goals
tactic: exact factors_eq_top_iff_zero.not
Theorem: DFinsupp.zipWith_single_single
File: Mathlib/Data/DFinsupp/Basic.lean

Proof steps:
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
i : ι
b₁ : β₁ i
b₂ : β₂ i
⊢ zipWith f hf (single i b₁) (single i b₂) = single i (f i b₁ b₂)
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
i : ι
b₁ : β₁ i
b₂ : β₂ i
j : ι
⊢ (zipWith f hf (single i b₁) (single i b₂)) j = (single i (f i b₁ b₂)) j
tactic: ext j
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
i : ι
b₁ : β₁ i
b₂ : β₂ i
j : ι
⊢ (zipWith f hf (single i b₁) (single i b₂)) j = (single i (f i b₁ b₂)) j
state_after: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
i : ι
b₁ : β₁ i
b₂ : β₂ i
j : ι
⊢ f j ((single i b₁) j) ((single i b₂) j) = (single i (f i b₁ b₂)) j
tactic: rw [zipWith_apply]
state_before: case h
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
i : ι
b₁ : β₁ i
b₂ : β₂ i
j : ι
⊢ f j ((single i b₁) j) ((single i b₂) j) = (single i (f i b₁ b₂)) j
state_after: case h.inl
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
i : ι
b₁ : β₁ i
b₂ : β₂ i
⊢ f i ((single i b₁) i) ((single i b₂) i) = (single i (f i b₁ b₂)) i

case h.inr
ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝³ : DecidableEq ι
inst✝² : (i : ι) → Zero (β i)
s : Finset ι
x : (i : ↑↑s) → β ↑i
i✝ : ι
inst✝¹ : (i : ι) → Zero (β₁ i)
inst✝ : (i : ι) → Zero (β₂ i)
f : (i : ι) → β₁ i → β₂ i → β i
hf : ∀ (i : ι), f i 0 0 = 0
i : ι
b₁ : β₁ i
b₂ : β₂ i
j : ι
hij : i ≠ j
⊢ f j ((single i b₁) j) ((single i b₂) j) = (single i (f i b₁ b₂)) j
tactic: obtain rfl | hij := Decidable.eq_or_ne i j
Theorem: MeasureTheory.AECover.integral_tendsto_of_countably_generated
File: Mathlib/MeasureTheory/Integral/IntegralEqImproper.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
E : Type u_3
inst✝⁴ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
inst✝ : l.IsCountablyGenerated
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
hfi : Integrable f μ
h : Tendsto (fun i => ∫ (x : α), (φ i).indicator f x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))
⊢ Tendsto (fun i => ∫ (x : α) in φ i, f x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))
state_after: case h.e'_3.h
α : Type u_1
ι : Type u_2
E : Type u_3
inst✝⁴ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
inst✝ : l.IsCountablyGenerated
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
hfi : Integrable f μ
h : Tendsto (fun i => ∫ (x : α), (φ i).indicator f x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))
x✝ : ι
⊢ ∫ (x : α) in φ x✝, f x ∂μ = ∫ (x : α), (φ x✝).indicator f x ∂μ
tactic: convert h using 2
state_before: case h.e'_3.h
α : Type u_1
ι : Type u_2
E : Type u_3
inst✝⁴ : MeasurableSpace α
μ : Measure α
l : Filter ι
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace E
inst✝ : l.IsCountablyGenerated
φ : ι → Set α
hφ : AECover μ l φ
f : α → E
hfi : Integrable f μ
h : Tendsto (fun i => ∫ (x : α), (φ i).indicator f x ∂μ) l (𝓝 (∫ (x : α), f x ∂μ))
x✝ : ι
⊢ ∫ (x : α) in φ x✝, f x ∂μ = ∫ (x : α), (φ x✝).indicator f x ∂μ
state_after: no goals
tactic: rw [integral_indicator (hφ.measurableSet _)]
Theorem: TopologicalSpace.Closeds.iInf_def
File: Mathlib/Topology/Sets/Closeds.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
⊢ ⨅ i, s i = { carrier := ⋂ i, ↑(s i), closed' := ⋯ }
state_after: case h
ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
⊢ ↑(⨅ i, s i) = ↑{ carrier := ⋂ i, ↑(s i), closed' := ⋯ }
tactic: ext1
state_before: case h
ι✝ : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
ι : Sort u_4
s : ι → Closeds α
⊢ ↑(⨅ i, s i) = ↑{ carrier := ⋂ i, ↑(s i), closed' := ⋯ }
state_after: no goals
tactic: simp
Theorem: NonUnitalSubsemiring.prod_top
File: Mathlib/RingTheory/NonUnitalSubsemiring/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
inst✝⁴ : NonUnitalNonAssocSemiring R
M : Subsemigroup R
inst✝³ : NonUnitalNonAssocSemiring S
inst✝² : NonUnitalNonAssocSemiring T
F : Type u_1
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
s : NonUnitalSubsemiring R
x : R × S
⊢ x ∈ s.prod ⊤ ↔ x ∈ comap (NonUnitalRingHom.fst R S) s
state_after: no goals
tactic: simp [mem_prod, MonoidHom.coe_fst]
Theorem: integral_univ_inv_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean

Proof steps:
state_before: ⊢ π = π / 2 - -(π / 2)
state_after: no goals
tactic: ring
Theorem: MeasureTheory.Integrable.nnnorm_toL1
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hf : Integrable f μ
⊢ ↑‖toL1 f hf‖₊ = ∫⁻ (a : α), ↑‖f a‖₊ ∂μ
state_after: no goals
tactic: simpa [Integrable.toL1, eLpNorm, eLpNorm'] using ENNReal.coe_toNNReal hf.2.ne
Theorem: Nat.chineseRemainderOfList_lt_prod
File: Mathlib/Data/Nat/ChineseRemainder.lean

Proof steps:
state_before: ι : Type u_1
a s : ι → ℕ
l : List ι
co : List.Pairwise (Coprime on s) l
hs : ∀ i ∈ l, s i ≠ 0
⊢ ↑(chineseRemainderOfList a s l co) < (List.map s l).prod
state_after: no goals
tactic: cases l with
  | nil => simp
  | cons i l =>
    simp only [chineseRemainderOfList, List.map_cons, List.prod_cons]
    have : Coprime (s i) (l.map s).prod := by
      simp only [coprime_list_prod_right_iff, List.mem_map, forall_exists_index, and_imp,
        forall_apply_eq_imp_iff₂]
      intro j hj
      exact (List.pairwise_cons.mp co).1 j hj
    refine chineseRemainder_lt_mul this (a i) (chineseRemainderOfList a s l co.of_cons)
      (hs i (List.mem_cons_self _ l)) ?_
    simp only [ne_eq, List.prod_eq_zero_iff, List.mem_map, not_exists, not_and]
    intro j hj
    exact hs j (List.mem_cons_of_mem _ hj)
Theorem: uniformGroup_inf
File: Mathlib/Topology/Algebra/UniformGroup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
⊢ UniformGroup β
state_after: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
b : Bool
⊢ UniformGroup β
tactic: refine uniformGroup_iInf fun b => ?_
state_before: α : Type u_1
β : Type u_2
inst✝³ : UniformSpace α
inst✝² : Group α
inst✝¹ : UniformGroup α
inst✝ : Group β
u₁ u₂ : UniformSpace β
h₁ : UniformGroup β
h₂ : UniformGroup β
b : Bool
⊢ UniformGroup β
state_after: no goals
tactic: cases b <;> assumption
Theorem: CompleteSpace.fst_of_prod
File: Mathlib/Topology/UniformSpace/Cauchy.lean

Proof steps:
state_before: α : Type u
β : Type v
uniformSpace : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : CompleteSpace (α × β)
h : Nonempty β
f✝ : Filter α
hf : Cauchy f✝
y : β
a : α
b : β
hab : f✝ ×ˢ pure y ≤ 𝓝 (a, b)
⊢ f✝ ≤ 𝓝 a
state_after: no goals
tactic: simpa only [map_fst_prod, nhds_prod_eq] using map_mono (m := Prod.fst) hab
Theorem: WeierstrassCurve.Affine.equation_negAdd
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ W.Equation (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂)) (W.negAddY x₁ x₂ y₁ (W.slope x₁ x₂ y₁ y₂))
state_after: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ eval (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))
      (-((X - C x₁) * (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))) =
    0
tactic: rw [equation_add_iff, addPolynomial_slope h₁ h₂ hxy]
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ eval (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))
      (-((X - C x₁) * (X - C x₂) * (X - C (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))))) =
    0
state_after: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ -((W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - x₁) * (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - x₂) *
        (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) =
    0
tactic: eval_simp
state_before: R : Type u
inst✝¹ : CommRing R
W✝ : Affine R
F : Type u
inst✝ : Field F
W : Affine F
x₁ x₂ y₁ y₂ : F
h₁ : W.Equation x₁ y₁
h₂ : W.Equation x₂ y₂
hxy : x₁ = x₂ → y₁ ≠ W.negY x₂ y₂
⊢ -((W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - x₁) * (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - x₂) *
        (W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂) - W.addX x₁ x₂ (W.slope x₁ x₂ y₁ y₂))) =
    0
state_after: no goals
tactic: rw [neg_eq_zero, sub_self, mul_zero]
Theorem: LieModule.chainTop_neg
File: Mathlib/Algebra/Lie/Weights/Chain.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ chainTop (-α) β = chainBot α β
state_after: case h
R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
x✝ : L
⊢ (chainTop (-α) β) x✝ = (chainBot α β) x✝
tactic: ext
state_before: case h
R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
x✝ : L
⊢ (chainTop (-α) β) x✝ = (chainBot α β) x✝
state_after: no goals
tactic: simp
Theorem: NormedSpace.exp_continuousMap_eq
File: Mathlib/Analysis/SpecialFunctions/ContinuousFunctionalCalculus/ExpLog.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
⊢ exp 𝕜 f = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ }
state_after: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
⊢ (exp 𝕜 f) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
tactic: ext a
state_before: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
⊢ (exp 𝕜 f) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
state_after: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
⊢ (∑' (n : ℕ), (expSeries 𝕜 C(α, 𝕜) n) fun x => f) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
tactic: simp only [Function.comp_apply, NormedSpace.exp, FormalMultilinearSeries.sum]
state_before: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
⊢ (∑' (n : ℕ), (expSeries 𝕜 C(α, 𝕜) n) fun x => f) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
state_after: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
h_sum : Summable fun n => (expSeries 𝕜 C(α, 𝕜) n) fun x => f
⊢ (∑' (n : ℕ), (expSeries 𝕜 C(α, 𝕜) n) fun x => f) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
tactic: have h_sum := NormedSpace.expSeries_summable (𝕂 := 𝕜) f
state_before: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
h_sum : Summable fun n => (expSeries 𝕜 C(α, 𝕜) n) fun x => f
⊢ (∑' (n : ℕ), (expSeries 𝕜 C(α, 𝕜) n) fun x => f) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
state_after: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
h_sum : Summable fun n => (expSeries 𝕜 C(α, 𝕜) n) fun x => f
⊢ ∑' (i : ℕ), ((↑i.factorial)⁻¹ • f ^ i) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
tactic: simp_rw [← ContinuousMap.tsum_apply h_sum a, NormedSpace.expSeries_apply_eq]
state_before: case h
𝕜 : Type u_1
α : Type u_2
inst✝² : RCLike 𝕜
inst✝¹ : TopologicalSpace α
inst✝ : CompactSpace α
f : C(α, 𝕜)
a : α
h_sum : Summable fun n => (expSeries 𝕜 C(α, 𝕜) n) fun x => f
⊢ ∑' (i : ℕ), ((↑i.factorial)⁻¹ • f ^ i) a = { toFun := exp 𝕜 ∘ ⇑f, continuous_toFun := ⋯ } a
state_after: no goals
tactic: simp [NormedSpace.exp_eq_tsum]
Theorem: Multiset.count_replicate
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s : Multiset α
a b : α
n : ℕ
⊢ count a (replicate n b) = if a = b then n else 0
state_after: case h.e'_2
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s : Multiset α
a b : α
n : ℕ
⊢ count a (replicate n b) = List.count a (List.replicate n b)
tactic: convert List.count_replicate a b n
state_before: case h.e'_2
α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s : Multiset α
a b : α
n : ℕ
⊢ count a (replicate n b) = List.count a (List.replicate n b)
state_after: no goals
tactic: rw [← coe_count, coe_replicate]
Theorem: DirichletCharacter.eval_modulus_sub
File: Mathlib/NumberTheory/DirichletCharacter/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommMonoidWithZero R
n : ℕ
χ : DirichletCharacter R n
x : ZMod n
⊢ χ (↑n - x) = χ (-x)
state_after: no goals
tactic: simp
Theorem: smul_pos_iff_of_pos_right
File: Mathlib/Algebra/Order/Module/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
a a₁ a₂ : α
b b₁ b₂ : β
inst✝⁶ : Zero α
inst✝⁵ : Zero β
inst✝⁴ : SMulWithZero α β
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : SMulPosStrictMono α β
inst✝ : SMulPosReflectLT α β
hb : 0 < b
⊢ 0 < a • b ↔ 0 < a
state_after: no goals
tactic: simpa only [zero_smul] using smul_lt_smul_iff_of_pos_right hb (a₁ := 0) (a₂ := a)
Theorem: IsSl2Triple.HasPrimitiveVectorWith.mk'
File: Mathlib/Algebra/Lie/Sl2.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
h e f : L
inst✝ : NoZeroSMulDivisors ℤ M
t : IsSl2Triple h e f
m : M
μ ρ : R
hm : m ≠ 0
hm' : ⁅h, m⁆ = μ • m
he : ⁅e, m⁆ = ρ • m
⊢ ⁅e, m⁆ = 0
state_after: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
h e f : L
inst✝ : NoZeroSMulDivisors ℤ M
t : IsSl2Triple h e f
m : M
μ ρ : R
hm : m ≠ 0
hm' : ⁅h, m⁆ = μ • m
he : ⁅e, m⁆ = ρ • m
⊢ 2 • ⁅e, m⁆ = 0
tactic: suffices 2 • ⁅e, m⁆ = 0 by simpa using this
state_before: R : Type u_1
L : Type u_2
M : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
h e f : L
inst✝ : NoZeroSMulDivisors ℤ M
t : IsSl2Triple h e f
m : M
μ ρ : R
hm : m ≠ 0
hm' : ⁅h, m⁆ = μ • m
he : ⁅e, m⁆ = ρ • m
⊢ 2 • ⁅e, m⁆ = 0
state_after: no goals
tactic: rw [← nsmul_lie, ← t.lie_h_e_nsmul, lie_lie, hm', lie_smul, he, lie_smul, hm',
      smul_smul, smul_smul, mul_comm ρ μ, sub_self]
Theorem: MeasureTheory.eLpNorm_restrict_eq_of_support_subset
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
f : α → F
hsf : Function.support f ⊆ s
⊢ eLpNorm f p (μ.restrict s) = eLpNorm f p μ
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
f : α → F
hsf : Function.support f ⊆ s
hp0 : p = 0
⊢ eLpNorm f p (μ.restrict s) = eLpNorm f p μ

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
f : α → F
hsf : Function.support f ⊆ s
hp0 : ¬p = 0
⊢ eLpNorm f p (μ.restrict s) = eLpNorm f p μ
tactic: by_cases hp0 : p = 0
state_before: case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
f : α → F
hsf : Function.support f ⊆ s
hp0 : ¬p = 0
⊢ eLpNorm f p (μ.restrict s) = eLpNorm f p μ
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
f : α → F
hsf : Function.support f ⊆ s
hp0 : ¬p = 0
hp_top : p = ⊤
⊢ eLpNorm f p (μ.restrict s) = eLpNorm f p μ

case neg
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
s : Set α
f : α → F
hsf : Function.support f ⊆ s
hp0 : ¬p = 0
hp_top : ¬p = ⊤
⊢ eLpNorm f p (μ.restrict s) = eLpNorm f p μ
tactic: by_cases hp_top : p = ∞
Theorem: Filter.HasBasis.uniformEmbedding_iff'
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
ι : Sort u_1
ι' : Sort u_2
p : ι → Prop
p' : ι' → Prop
s : ι → Set (α × α)
s' : ι' → Set (β × β)
h : (𝓤 α).HasBasis p s
h' : (𝓤 β).HasBasis p' s'
f : α → β
⊢ UniformEmbedding f ↔
    Injective f ∧
      (∀ (i : ι'), p' i → ∃ j, p j ∧ ∀ (x y : α), (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
        ∀ (j : ι), p j → ∃ i, p' i ∧ ∀ (x y : α), (f x, f y) ∈ s' i → (x, y) ∈ s j
state_after: no goals
tactic: rw [uniformEmbedding_iff, and_comm, h.uniformInducing_iff h']