ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: inner_orthogonalProjection_left_eq_right
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
u v : E
⊢ ⟪↑((orthogonalProjection K) u), v⟫_𝕜 = ⟪u, ↑((orthogonalProjection K) v)⟫_𝕜
state_after: no goals
tactic: rw [← inner_orthogonalProjection_eq_of_mem_left, inner_orthogonalProjection_eq_of_mem_right]
Theorem: reflection_orthogonal_apply
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
⊢ (reflection Kᗮ) v = -(reflection K) v
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
⊢ 2 • v - 2 • ↑((orthogonalProjection K) v) - v = v - 2 • ↑((orthogonalProjection K) v)
tactic: simp [reflection_apply]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
v : E
⊢ 2 • v - 2 • ↑((orthogonalProjection K) v) - v = v - 2 • ↑((orthogonalProjection K) v)
state_after: no goals
tactic: abel
Theorem: Monoid.Coprod.fst_prod_snd
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : Monoid M
inst✝ : Monoid N
⊢ fst.prod snd = toProd
state_after: no goals
tactic: ext1 <;> rfl
Theorem: succ_mersenne
File: Mathlib/NumberTheory/LucasLehmer.lean

Proof steps:
state_before: k : ℕ
⊢ mersenne k + 1 = 2 ^ k
state_after: k : ℕ
⊢ 1 ≤ 2 ^ k
tactic: rw [mersenne, tsub_add_cancel_of_le]
state_before: k : ℕ
⊢ 1 ≤ 2 ^ k
state_after: no goals
tactic: exact one_le_pow_of_one_le (by norm_num) k
Theorem: quotient_norm_eq_zero_iff
File: Mathlib/Analysis/Normed/Group/Quotient.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
⊢ ‖(mk' S) m‖ = 0 ↔ m ∈ closure ↑S
state_after: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
⊢ (↑S).Nonempty
tactic: rw [mk'_apply, norm_mk, ← mem_closure_iff_infDist_zero]
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
m : M
⊢ (↑S).Nonempty
state_after: no goals
tactic: exact ⟨0, S.zero_mem⟩
Theorem: NumberField.mixedEmbedding.normAtPlace_real
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean

Proof steps:
state_before: K : Type u_1
inst✝ : Field K
w : InfinitePlace K
c : ℝ
⊢ (normAtPlace w) (fun x => c, fun x => ↑c) = |c|
state_after: no goals
tactic: rw [show ((fun _ ↦ c, fun _ ↦ c) : (E K)) = c • 1 by ext <;> simp, normAtPlace_smul, map_one,
    mul_one]
Theorem: Ordinal.one_CNF
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

Proof steps:
state_before: o : Ordinal.{u_1}
ho : o ≠ 0
⊢ CNF 1 o = [(0, o)]
state_after: no goals
tactic: simp [CNF_ne_zero ho]
Theorem: PowerSeries.trunc_coe_eq_self
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

Proof steps:
state_before: R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
⊢ trunc n ↑f = f
state_after: R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
⊢ ↑(trunc n ↑f) = ↑f
tactic: rw [← Polynomial.coe_inj]
state_before: R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
⊢ ↑(trunc n ↑f) = ↑f
state_after: case h
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
⊢ (coeff R m) ↑(trunc n ↑f) = (coeff R m) ↑f
tactic: ext m
state_before: case h
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
⊢ (coeff R m) ↑(trunc n ↑f) = (coeff R m) ↑f
state_after: case h
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
⊢ (if m < n then (coeff R m) ↑f else 0) = (coeff R m) ↑f
tactic: rw [coeff_coe, coeff_trunc]
state_before: case h
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
⊢ (if m < n then (coeff R m) ↑f else 0) = (coeff R m) ↑f
state_after: case h.isTrue
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
h✝ : m < n
⊢ (coeff R m) ↑f = (coeff R m) ↑f

case h.isFalse
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
h✝ : ¬m < n
⊢ 0 = (coeff R m) ↑f
tactic: split
state_before: case h.isTrue
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
h✝ : m < n
⊢ (coeff R m) ↑f = (coeff R m) ↑f

case h.isFalse
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
h✝ : ¬m < n
⊢ 0 = (coeff R m) ↑f
state_after: case h.isFalse
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
h✝ : ¬m < n
⊢ 0 = (coeff R m) ↑f
tactic: case isTrue h => rfl
state_before: case h.isFalse
R✝ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
n : ℕ
f : R[X]
hn : f.natDegree < n
m : ℕ
h✝ : ¬m < n
⊢ 0 = (coeff R m) ↑f
state_after: no goals
tactic: case isFalse h =>
    rw [not_lt] at h
    rw [coeff_coe]; symm
    exact coeff_eq_zero_of_natDegree_lt <| lt_of_lt_of_le hn h
Theorem: aemeasurable_union_iff
File: Mathlib/MeasureTheory/Measure/AEMeasurable.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
R : Type u_6
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
f g : α → β
μ ν : Measure α
s t : Set α
⊢ AEMeasurable f (μ.restrict (s ∪ t)) ↔ AEMeasurable f (μ.restrict s) ∧ AEMeasurable f (μ.restrict t)
state_after: no goals
tactic: simp only [union_eq_iUnion, aemeasurable_iUnion_iff, Bool.forall_bool, cond, and_comm]
Theorem: antivaryOn_inv_right
File: Mathlib/Algebra/Order/Monovary.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : OrderedCommGroup α
inst✝ : OrderedCommGroup β
s : Set ι
f f₁ f₂ : ι → α
g g₁ g₂ : ι → β
⊢ AntivaryOn f g⁻¹ s ↔ MonovaryOn f g s
state_after: no goals
tactic: simpa [MonovaryOn, AntivaryOn] using forall₂_swap
Theorem: Matrix.mem_unitaryGroup_iff
File: Mathlib/LinearAlgebra/UnitaryGroup.lean

Proof steps:
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
⊢ A ∈ unitaryGroup n α ↔ A * star A = 1
state_after: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
hA : A * star A = 1
⊢ star A * A = 1
tactic: refine ⟨And.right, fun hA => ⟨?_, hA⟩⟩
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
α : Type v
inst✝¹ : CommRing α
inst✝ : StarRing α
A : Matrix n n α
hA : A * star A = 1
⊢ star A * A = 1
state_after: no goals
tactic: simpa only [mul_eq_one_comm] using hA
Theorem: jacobiTheta₂_add_left'
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: z τ : ℂ
⊢ jacobiTheta₂ (z + τ) τ = cexp (-↑π * I * (τ + 2 * z)) * jacobiTheta₂ z τ
state_after: z τ : ℂ
⊢ jacobiTheta₂ (z + τ) τ = ∑' (c : ℤ), cexp (-↑π * I * (τ + 2 * z)) * jacobiTheta₂_term ((Equiv.addRight 1) c) z τ
tactic: conv_rhs => erw [← tsum_mul_left, ← (Equiv.addRight 1).tsum_eq]
state_before: z τ : ℂ
⊢ jacobiTheta₂ (z + τ) τ = ∑' (c : ℤ), cexp (-↑π * I * (τ + 2 * z)) * jacobiTheta₂_term ((Equiv.addRight 1) c) z τ
state_after: z τ : ℂ
n : ℤ
⊢ jacobiTheta₂_term n (z + τ) τ = cexp (-↑π * I * (τ + 2 * z)) * jacobiTheta₂_term ((Equiv.addRight 1) n) z τ
tactic: refine tsum_congr (fun n ↦ ?_)
state_before: z τ : ℂ
n : ℤ
⊢ jacobiTheta₂_term n (z + τ) τ = cexp (-↑π * I * (τ + 2 * z)) * jacobiTheta₂_term ((Equiv.addRight 1) n) z τ
state_after: z τ : ℂ
n : ℤ
⊢ cexp (2 * ↑π * I * ↑n * (z + τ) + ↑π * I * ↑n ^ 2 * τ) =
    cexp (-↑π * I * (τ + 2 * z) + (2 * ↑π * I * (↑n + ↑1) * z + ↑π * I * (↑n + ↑1) ^ 2 * τ))
tactic: simp_rw [jacobiTheta₂_term, ← Complex.exp_add, Equiv.coe_addRight, Int.cast_add]
state_before: z τ : ℂ
n : ℤ
⊢ cexp (2 * ↑π * I * ↑n * (z + τ) + ↑π * I * ↑n ^ 2 * τ) =
    cexp (-↑π * I * (τ + 2 * z) + (2 * ↑π * I * (↑n + ↑1) * z + ↑π * I * (↑n + ↑1) ^ 2 * τ))
state_after: no goals
tactic: ring_nf
Theorem: Polynomial.Gal.ext
File: Mathlib/FieldTheory/PolynomialGaloisGroup.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
σ τ : p.Gal
h : ∀ x ∈ p.rootSet p.SplittingField, σ x = τ x
⊢ σ = τ
state_after: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
σ τ : p.Gal
h : ∀ x ∈ p.rootSet p.SplittingField, σ x = τ x
x : p.SplittingField
⊢ AlgHom.equalizer ↑σ ↑τ = ⊤
tactic: refine
    AlgEquiv.ext fun x =>
      (AlgHom.mem_equalizer σ.toAlgHom τ.toAlgHom x).mp
        ((SetLike.ext_iff.mp ?_ x).mpr Algebra.mem_top)
state_before: F : Type u_1
inst✝² : Field F
p q : F[X]
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
σ τ : p.Gal
h : ∀ x ∈ p.rootSet p.SplittingField, σ x = τ x
x : p.SplittingField
⊢ AlgHom.equalizer ↑σ ↑τ = ⊤
state_after: no goals
tactic: rwa [eq_top_iff, ← SplittingField.adjoin_rootSet, Algebra.adjoin_le_iff]
Theorem: ProbabilityTheory.measure_le_le_exp_mul_mgf
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : t ≤ 0
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ (μ {ω | X ω ≤ ε}).toReal ≤ rexp (-t * ε) * mgf X μ t
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : t ≤ 0
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ (μ {ω | X ω ≤ ε}).toReal ≤ rexp (- -t * -ε) * mgf (-X) μ (-t)
tactic: rw [← neg_neg t, ← mgf_neg, neg_neg, ← neg_mul_neg (-t)]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : t ≤ 0
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ (μ {ω | X ω ≤ ε}).toReal ≤ rexp (- -t * -ε) * mgf (-X) μ (-t)
state_after: case refine_1
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : t ≤ 0
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ (μ {ω | X ω ≤ ε}).toReal = (μ {ω | -ε ≤ (-X) ω}).toReal

case refine_2
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
inst✝ : IsFiniteMeasure μ
ε : ℝ
ht : t ≤ 0
h_int : Integrable (fun ω => rexp (t * X ω)) μ
⊢ Integrable (fun ω => rexp (-t * (-X) ω)) μ
tactic: refine Eq.trans_le ?_ (measure_ge_le_exp_mul_mgf (-ε) (neg_nonneg.mpr ht) ?_)
Theorem: Set.ncard_empty
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
s t : Set α✝
α : Type u_3
⊢ ∅.ncard = 0
state_after: no goals
tactic: rw [ncard_eq_zero]
Theorem: Nat.exists_most_significant_bit
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n : ℕ
h : n ≠ 0
⊢ ∃ i, n.testBit i = true ∧ ∀ (j : ℕ), i < j → n.testBit j = false
state_after: case z
h : 0 ≠ 0
⊢ ∃ i, testBit 0 i = true ∧ ∀ (j : ℕ), i < j → testBit 0 j = false

case f
b : Bool
n : ℕ
hn : n ≠ 0 → ∃ i, n.testBit i = true ∧ ∀ (j : ℕ), i < j → n.testBit j = false
h : bit b n ≠ 0
⊢ ∃ i, (bit b n).testBit i = true ∧ ∀ (j : ℕ), i < j → (bit b n).testBit j = false
tactic: induction' n using Nat.binaryRec with b n hn
state_before: case f
b : Bool
n : ℕ
hn : n ≠ 0 → ∃ i, n.testBit i = true ∧ ∀ (j : ℕ), i < j → n.testBit j = false
h : bit b n ≠ 0
⊢ ∃ i, (bit b n).testBit i = true ∧ ∀ (j : ℕ), i < j → (bit b n).testBit j = false
state_after: case pos
b : Bool
n : ℕ
hn : n ≠ 0 → ∃ i, n.testBit i = true ∧ ∀ (j : ℕ), i < j → n.testBit j = false
h : bit b n ≠ 0
h' : n = 0
⊢ ∃ i, (bit b n).testBit i = true ∧ ∀ (j : ℕ), i < j → (bit b n).testBit j = false

case neg
b : Bool
n : ℕ
hn : n ≠ 0 → ∃ i, n.testBit i = true ∧ ∀ (j : ℕ), i < j → n.testBit j = false
h : bit b n ≠ 0
h' : ¬n = 0
⊢ ∃ i, (bit b n).testBit i = true ∧ ∀ (j : ℕ), i < j → (bit b n).testBit j = false
tactic: by_cases h' : n = 0
Theorem: List.alternatingSum_cons'
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
⊢ [a].alternatingProd = a * [].alternatingProd⁻¹
state_after: no goals
tactic: rw [alternatingProd_nil, inv_one, mul_one, alternatingProd_singleton]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a b : α
l : List α
⊢ (a :: b :: l).alternatingProd = a * (b :: l).alternatingProd⁻¹
state_after: no goals
tactic: rw [alternatingProd_cons_cons', alternatingProd_cons' b l, mul_inv, inv_inv, mul_assoc]
Theorem: WeierstrassCurve.baseChange_ψ
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
W : WeierstrassCurve R
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
n : ℤ
⊢ (W.baseChange B).ψ n = Polynomial.map (mapRingHom ↑f) ((W.baseChange A).ψ n)
state_after: no goals
tactic: rw [← map_ψ, map_baseChange]
Theorem: topCatToCondensedSet_obj
File: Mathlib/Condensed/TopComparison.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
G : C ⥤ TopCat
X : Type w'
inst✝ : TopologicalSpace X
X✝ Y✝ : TopCat
f : X✝ ⟶ Y✝
⊢ ∀ ⦃X Y : CompHausᵒᵖ⦄ (f_1 : X ⟶ Y),
    ((fun X => X.toCondensedSet) X✝).val.map f_1 ≫ (fun x g => comp f g) Y =
      (fun x g => comp f g) X ≫ ((fun X => X.toCondensedSet) Y✝).val.map f_1
state_after: no goals
tactic: aesop
Theorem: Matroid.Basis.basis_subset
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Basis I X
hIY : I ⊆ Y
hYX : Y ⊆ X
⊢ M.Basis I Y
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Basis I X
hIY : I ⊆ Y
hYX : Y ⊆ X
⊢ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ Y → I = J
tactic: rw [basis_iff (hYX.trans hI.subset_ground), and_iff_right hI.indep, and_iff_right hIY]
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Basis I X
hIY : I ⊆ Y
hYX : Y ⊆ X
⊢ ∀ (J : Set α), M.Indep J → I ⊆ J → J ⊆ Y → I = J
state_after: no goals
tactic: exact fun J hJ hIJ hJY ↦ hI.eq_of_subset_indep hJ hIJ (hJY.trans hYX)
Theorem: Real.Angle.two_zsmul_toReal_eq_two_mul_sub_two_pi
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ (2 • θ).toReal = 2 * θ.toReal - 2 * π ↔ π / 2 < θ.toReal
state_after: no goals
tactic: rw [two_zsmul, ← two_nsmul, two_nsmul_toReal_eq_two_mul_sub_two_pi]
Theorem: Equiv.permCongr_trans
File: Mathlib/Logic/Equiv/Defs.lean

Proof steps:
state_before: α : Sort u
β : Sort v
γ : Sort w
α' : Type u_1
β' : Type u_2
e : α' ≃ β'
p p' : Perm α'
⊢ Equiv.trans (e.permCongr p) (e.permCongr p') = e.permCongr (Equiv.trans p p')
state_after: case H
α : Sort u
β : Sort v
γ : Sort w
α' : Type u_1
β' : Type u_2
e : α' ≃ β'
p p' : Perm α'
x✝ : β'
⊢ (Equiv.trans (e.permCongr p) (e.permCongr p')) x✝ = (e.permCongr (Equiv.trans p p')) x✝
tactic: ext
state_before: case H
α : Sort u
β : Sort v
γ : Sort w
α' : Type u_1
β' : Type u_2
e : α' ≃ β'
p p' : Perm α'
x✝ : β'
⊢ (Equiv.trans (e.permCongr p) (e.permCongr p')) x✝ = (e.permCongr (Equiv.trans p p')) x✝
state_after: no goals
tactic: simp only [trans_apply, comp_apply, permCongr_apply, symm_apply_apply]
Theorem: Inducing.regularSpace
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : RegularSpace X
x : X
s : Set X
inst✝ : TopologicalSpace Y
f : Y → X
hf : Inducing f
b : Y
⊢ (𝓝 b).HasBasis (?m.187297 b) (?m.187298 b)
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : RegularSpace X
x : X
s : Set X
inst✝ : TopologicalSpace Y
f : Y → X
hf : Inducing f
b : Y
⊢ (comap f (𝓝 (f b))).HasBasis (?m.187297 b) (?m.187298 b)
tactic: rw [hf.nhds_eq_comap b]
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : RegularSpace X
x : X
s : Set X
inst✝ : TopologicalSpace Y
f : Y → X
hf : Inducing f
b : Y
⊢ (comap f (𝓝 (f b))).HasBasis (?m.187297 b) (?m.187298 b)
state_after: no goals
tactic: exact (closed_nhds_basis _).comap _
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : RegularSpace X
x : X
s✝ : Set X
inst✝ : TopologicalSpace Y
f : Y → X
hf : Inducing f
b : Y
s : Set X
hs : s ∈ 𝓝 (f b) ∧ IsClosed s
⊢ IsClosed (f ⁻¹' id s)
state_after: no goals
tactic: exact hs.2.preimage hf.continuous
Theorem: tsum_mul_tsum_eq_tsum_sum_range_of_summable_norm
File: Mathlib/Analysis/Normed/Field/InfiniteSum.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ (∑' (n : ℕ), f n) * ∑' (n : ℕ), g n = ∑' (n : ℕ), ∑ k ∈ range (n + 1), f k * g (n - k)
state_after: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ (∑' (n : ℕ), f n) * ∑' (n : ℕ), g n = ∑' (n : ℕ), ∑ ij ∈ antidiagonal n, f ij.1 * g ij.2
tactic: simp_rw [← sum_antidiagonal_eq_sum_range_succ fun k l => f k * g l]
state_before: R : Type u_1
ι : Type u_2
ι' : Type u_3
inst✝¹ : NormedRing R
inst✝ : CompleteSpace R
f g : ℕ → R
hf : Summable fun x => ‖f x‖
hg : Summable fun x => ‖g x‖
⊢ (∑' (n : ℕ), f n) * ∑' (n : ℕ), g n = ∑' (n : ℕ), ∑ ij ∈ antidiagonal n, f ij.1 * g ij.2
state_after: no goals
tactic: exact tsum_mul_tsum_eq_tsum_sum_antidiagonal_of_summable_norm hf hg
Theorem: DirectSum.toAddMonoidAlgebra_mul
File: Mathlib/Algebra/MonoidAlgebra/ToDirectSum.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ (f * g).toAddMonoidAlgebra = f.toAddMonoidAlgebra * g.toAddMonoidAlgebra
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ (f * g).toAddMonoidAlgebra.toDirectSum = (f.toAddMonoidAlgebra * g.toAddMonoidAlgebra).toDirectSum

case inj
ι : Type u_1
R : Type u_2
M : Type u_3
A : Type u_4
inst✝³ : DecidableEq ι
inst✝² : AddMonoid ι
inst✝¹ : Semiring M
inst✝ : (m : M) → Decidable (m ≠ 0)
f g : ⨁ (x : ι), M
⊢ Function.Injective AddMonoidAlgebra.toDirectSum
tactic: apply_fun AddMonoidAlgebra.toDirectSum
Theorem: _private.Mathlib.Data.Real.EReal.0.EReal.coe_ennreal_top_mul
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : ℝ≥0
⊢ ↑(⊤ * ↑x) = ⊤ * ↑↑x
state_after: case inl

⊢ ↑(⊤ * ↑0) = ⊤ * ↑↑0

case inr
x : ℝ≥0
h0 : x ≠ 0
⊢ ↑(⊤ * ↑x) = ⊤ * ↑↑x
tactic: rcases eq_or_ne x 0 with (rfl | h0)
Theorem: MeasureTheory.eLpNorm'_mono_nnnorm_ae
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
f : α → F
g : α → G
hq : 0 ≤ q
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ eLpNorm' f q μ ≤ eLpNorm' g q μ
state_after: α : 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
f : α → F
g : α → G
hq : 0 ≤ q
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q) ≤ (∫⁻ (a : α), ↑‖g a‖₊ ^ q ∂μ) ^ (1 / q)
tactic: simp only [eLpNorm']
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
f : α → F
g : α → G
hq : 0 ≤ q
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q) ≤ (∫⁻ (a : α), ↑‖g a‖₊ ^ q ∂μ) ^ (1 / q)
state_after: case h₁
α : 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
f : α → F
g : α → G
hq : 0 ≤ q
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ ≤ ∫⁻ (a : α), ↑‖g a‖₊ ^ q ∂μ
tactic: gcongr ?_ ^ (1/q)
state_before: case h₁
α : 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
f : α → F
g : α → G
hq : 0 ≤ q
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
⊢ ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ ≤ ∫⁻ (a : α), ↑‖g a‖₊ ^ q ∂μ
state_after: case h₁
α : 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
f : α → F
g : α → G
hq : 0 ≤ q
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
x : α
hx : ‖f x‖₊ ≤ ‖g x‖₊
⊢ ↑‖f x‖₊ ^ q ≤ ↑‖g x‖₊ ^ q
tactic: refine lintegral_mono_ae (h.mono fun x hx => ?_)
state_before: case h₁
α : 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
f : α → F
g : α → G
hq : 0 ≤ q
h : ∀ᵐ (x : α) ∂μ, ‖f x‖₊ ≤ ‖g x‖₊
x : α
hx : ‖f x‖₊ ≤ ‖g x‖₊
⊢ ↑‖f x‖₊ ^ q ≤ ↑‖g x‖₊ ^ q
state_after: no goals
tactic: gcongr
Theorem: CliffordAlgebra.contractRight_algebraMap_mul
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

Proof steps:
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q : QuadraticForm R M
d d' : Module.Dual R M
r : R
b : CliffordAlgebra Q
⊢ (contractRight ((algebraMap R (CliffordAlgebra Q)) r * b)) d =
    (algebraMap R (CliffordAlgebra Q)) r * (contractRight b) d
state_after: no goals
tactic: rw [← Algebra.smul_def, LinearMap.map_smul₂, Algebra.smul_def]
Theorem: IsNilpotent.smul
File: Mathlib/RingTheory/Nilpotent/Basic.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝⁴ : MonoidWithZero R
inst✝³ : MonoidWithZero S
inst✝² : MulActionWithZero R S
inst✝¹ : SMulCommClass R S S
inst✝ : IsScalarTower R S S
a : S
ha : IsNilpotent a
t : R
⊢ IsNilpotent (t • a)
state_after: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝⁴ : MonoidWithZero R
inst✝³ : MonoidWithZero S
inst✝² : MulActionWithZero R S
inst✝¹ : SMulCommClass R S S
inst✝ : IsScalarTower R S S
a : S
t : R
k : ℕ
ha : a ^ k = 0
⊢ IsNilpotent (t • a)
tactic: obtain ⟨k, ha⟩ := ha
state_before: case intro
R : Type u_1
S : Type u_2
x y : R
inst✝⁴ : MonoidWithZero R
inst✝³ : MonoidWithZero S
inst✝² : MulActionWithZero R S
inst✝¹ : SMulCommClass R S S
inst✝ : IsScalarTower R S S
a : S
t : R
k : ℕ
ha : a ^ k = 0
⊢ IsNilpotent (t • a)
state_after: case h
R : Type u_1
S : Type u_2
x y : R
inst✝⁴ : MonoidWithZero R
inst✝³ : MonoidWithZero S
inst✝² : MulActionWithZero R S
inst✝¹ : SMulCommClass R S S
inst✝ : IsScalarTower R S S
a : S
t : R
k : ℕ
ha : a ^ k = 0
⊢ (t • a) ^ k = 0
tactic: use k
state_before: case h
R : Type u_1
S : Type u_2
x y : R
inst✝⁴ : MonoidWithZero R
inst✝³ : MonoidWithZero S
inst✝² : MulActionWithZero R S
inst✝¹ : SMulCommClass R S S
inst✝ : IsScalarTower R S S
a : S
t : R
k : ℕ
ha : a ^ k = 0
⊢ (t • a) ^ k = 0
state_after: no goals
tactic: rw [smul_pow, ha, smul_zero]