ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DirichletCharacter.fourierTransform_eq_gaussSum_mulShift
File: Mathlib/Analysis/Fourier/ZMod.lean

Proof steps:
state_before: N : ℕ
inst✝ : NeZero N
χ : DirichletCharacter ℂ N
k : ZMod N
⊢ 𝓕 (⇑χ) k = gaussSum χ (stdAddChar.mulShift (-k))
state_after: N : ℕ
inst✝ : NeZero N
χ : DirichletCharacter ℂ N
k : ZMod N
⊢ ∑ j : ZMod N, toCircle (-(j * k)) • χ j = gaussSum χ (stdAddChar.mulShift (-k))
tactic: simp only [dft_def]
state_before: N : ℕ
inst✝ : NeZero N
χ : DirichletCharacter ℂ N
k : ZMod N
⊢ ∑ j : ZMod N, toCircle (-(j * k)) • χ j = gaussSum χ (stdAddChar.mulShift (-k))
state_after: case e_f.h
N : ℕ
inst✝ : NeZero N
χ : DirichletCharacter ℂ N
k j : ZMod N
⊢ toCircle (-(j * k)) • χ j = χ j * (stdAddChar.mulShift (-k)) j
tactic: congr 1 with j
state_before: case e_f.h
N : ℕ
inst✝ : NeZero N
χ : DirichletCharacter ℂ N
k j : ZMod N
⊢ toCircle (-(j * k)) • χ j = χ j * (stdAddChar.mulShift (-k)) j
state_after: no goals
tactic: rw [AddChar.mulShift_apply, mul_comm j, Submonoid.smul_def, smul_eq_mul, neg_mul,
    stdAddChar_apply, mul_comm (χ _)]
Theorem: ENNReal.hasBasis_nhds_of_ne_top
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
xt : x ≠ ⊤
⊢ (𝓝 x).HasBasis (fun x => 0 < x) fun ε => Icc (x - ε) (x + ε)
state_after: no goals
tactic: simpa only [pos_iff_ne_zero] using hasBasis_nhds_of_ne_top' xt
Theorem: Algebra.TensorProduct.lift_comp_includeRight
File: Mathlib/RingTheory/TensorProduct/Basic.lean

Proof steps:
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
C : Type uC
D : Type uD
E : Type uE
F : Type uF
inst✝¹⁴ : CommSemiring R
inst✝¹³ : CommSemiring S
inst✝¹² : Algebra R S
inst✝¹¹ : Semiring A
inst✝¹⁰ : Algebra R A
inst✝⁹ : Algebra S A
inst✝⁸ : IsScalarTower R S A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R B
inst✝⁵ : Semiring C
inst✝⁴ : Algebra R C
inst✝³ : Algebra S C
inst✝² : Semiring D
inst✝¹ : Algebra R D
inst✝ : IsScalarTower R S C
f : A →ₐ[S] C
g : B →ₐ[R] C
hfg : ∀ (x : A) (y : B), Commute (f x) (g y)
⊢ ∀ (x : B), ((AlgHom.restrictScalars R (lift f g hfg)).comp includeRight) x = g x
state_after: no goals
tactic: simp
Theorem: le_of_forall_pos_lt_add
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
h : ∀ (ε : α), 1 < ε → a < b * ε
h₁ : b < a
⊢ a < a
state_after: no goals
tactic: simpa using h _ (lt_inv_mul_iff_lt.mpr h₁)
Theorem: Ordinal.lt_mul_succ_div
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
h : b ≠ 0
⊢ a < b * succ (a / b)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
h : b ≠ 0
⊢ a < b * succ (sInf {o | a < b * succ o})
tactic: rw [div_def a h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
a b : Ordinal.{u_4}
h : b ≠ 0
⊢ a < b * succ (sInf {o | a < b * succ o})
state_after: no goals
tactic: exact csInf_mem (div_nonempty h)
Theorem: Matroid.isClosed_iff_flat
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Matroid α
F✝ X Y : Set α
e : α
F : ↑(Iic M.E)
⊢ M.subtypeClosure.IsClosed F ↔ M.Flat ↑F
state_after: no goals
tactic: simp [subtypeClosure]
Theorem: MulAction.orbit_smul
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
g : G
a : α
⊢ orbit G a = orbit G (g⁻¹ • g • a)
state_after: no goals
tactic: rw [inv_smul_smul]
Theorem: Stream'.WSeq.destruct_map
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
s : WSeq α
⊢ (map f s).destruct = Computation.map (Option.map (Prod.map f (map f))) s.destruct
state_after: case bisim
α : Type u
β : Type v
γ : Type w
f : α → β
s : WSeq α
⊢ Computation.IsBisimulation fun c1 c2 =>
    ∃ s, c1 = (map f s).destruct ∧ c2 = Computation.map (Option.map (Prod.map f (map f))) s.destruct

case r
α : Type u
β : Type v
γ : Type w
f : α → β
s : WSeq α
⊢ ∃ s_1,
    (map f s).destruct = (map f s_1).destruct ∧
      Computation.map (Option.map (Prod.map f (map f))) s.destruct =
        Computation.map (Option.map (Prod.map f (map f))) s_1.destruct
tactic: apply
    Computation.eq_of_bisim fun c1 c2 =>
      ∃ s,
        c1 = destruct (map f s) ∧
          c2 = Computation.map (Option.map (Prod.map f (map f))) (destruct s)
Theorem: Multiset.gcd_map_mul
File: Mathlib/Algebra/GCDMonoid/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s : Multiset α
⊢ (map (fun x => a * x) s).gcd = normalize a * s.gcd
state_after: case refine_1
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s : Multiset α
⊢ (map (fun x => a * x) 0).gcd = normalize a * gcd 0

case refine_2
α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a : α
s✝ : Multiset α
b : α
s : Multiset α
ih : (map (fun x => a * x) s).gcd = normalize a * s.gcd
⊢ (map (fun x => a * x) (b ::ₘ s)).gcd = normalize a * (b ::ₘ s).gcd
tactic: refine s.induction_on ?_ fun b s ih ↦ ?_
Theorem: YoungDiagram.ofRowLens_to_rowLens_eq_self
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: μ : YoungDiagram
⊢ ofRowLens μ.rowLens ⋯ = μ
state_after: case cells.a.mk
μ : YoungDiagram
i j : ℕ
⊢ (i, j) ∈ (ofRowLens μ.rowLens ⋯).cells ↔ (i, j) ∈ μ.cells
tactic: ext ⟨i, j⟩
state_before: case cells.a.mk
μ : YoungDiagram
i j : ℕ
⊢ (i, j) ∈ (ofRowLens μ.rowLens ⋯).cells ↔ (i, j) ∈ μ.cells
state_after: case cells.a.mk
μ : YoungDiagram
i j : ℕ
⊢ (∃ (h : i < μ.colLen 0), j < μ.rowLens.get ⟨i, ⋯⟩) ↔ (i, j) ∈ μ
tactic: simp only [mem_cells, mem_ofRowLens, length_rowLens, get_rowLens]
state_before: case cells.a.mk
μ : YoungDiagram
i j : ℕ
⊢ (∃ (h : i < μ.colLen 0), j < μ.rowLens.get ⟨i, ⋯⟩) ↔ (i, j) ∈ μ
state_after: no goals
tactic: simpa [← mem_iff_lt_colLen, mem_iff_lt_rowLen] using j.zero_le.trans_lt
Theorem: Complex.inv_cpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: x n : ℂ
hx : x.arg ≠ π
⊢ x⁻¹ ^ n = (x ^ n)⁻¹
state_after: no goals
tactic: rw [inv_cpow_eq_ite, if_neg hx]
Theorem: CategoryTheory.Limits.Sigma.ι_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β✝ : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
β : Type w
f : β → C
inst✝ : HasCoproduct f
P : C
p : (b : β) → f b ⟶ P
b : β
⊢ ι f b ≫ desc p = p b
state_after: no goals
tactic: simp only [colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app]
Theorem: Associates.sup_mul_inf
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
⊢ (a.factors ⊔ b.factors).prod * (a.factors ⊓ b.factors).prod = a * b
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a.factors ⊔ b.factors).prod * (a.factors ⊓ b.factors).prod = a * b
tactic: nontriviality α
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ (a.factors ⊔ b.factors).prod * (a.factors ⊓ b.factors).prod = a * b
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ ((a.factors ⊔ b.factors).prod * (a.factors ⊓ b.factors).prod).factors = (a * b).factors
tactic: refine eq_of_factors_eq_factors ?_
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
a✝ : Nontrivial α
⊢ ((a.factors ⊔ b.factors).prod * (a.factors ⊓ b.factors).prod).factors = (a * b).factors
state_after: no goals
tactic: rw [← prod_add, prod_factors, factors_mul, FactorSet.sup_add_inf_eq_add]
Theorem: gold_pos
File: Mathlib/Data/Real/GoldenRatio.lean

Proof steps:
state_before: ⊢ 0 < 1 + √5
state_after: no goals
tactic: apply add_pos <;> norm_num
Theorem: Rat.inv_intCast_num
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: a : ℤ
⊢ (↑a)⁻¹.num = a.sign
state_after: case inl
a : ℤ
lt : a < 0
⊢ (↑a)⁻¹.num = a.sign

case inr.inl

⊢ (↑0)⁻¹.num = Int.sign 0

case inr.inr
a : ℤ
gt : 0 < a
⊢ (↑a)⁻¹.num = a.sign
tactic: rcases lt_trichotomy a 0 with lt | rfl | gt
Theorem: CategoryTheory.Presieve.extend_restrict
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.Compatible
⊢ (FamilyOfElements.restrict ⋯ x).sieveExtend = x
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
⊢ (FamilyOfElements.restrict ⋯ x).sieveExtend = x
tactic: rw [compatible_iff_sieveCompatible] at t
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
⊢ (FamilyOfElements.restrict ⋯ x).sieveExtend = x
state_after: case h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ (FamilyOfElements.restrict ⋯ x).sieveExtend x✝ h = x x✝ h
tactic: funext _ _ h
state_before: case h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ (FamilyOfElements.restrict ⋯ x).sieveExtend x✝ h = x x✝ h
state_after: case h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ x (⋯.choose ≫ ⋯.choose) ⋯ = x x✝ h
tactic: apply (t _ _ _).symm.trans
state_before: case h.h.h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ x (⋯.choose ≫ ⋯.choose) ⋯ = x x✝ h
state_after: case h.h.h.e_f
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ ⋯.choose ≫ ⋯.choose = x✝
tactic: congr
state_before: case h.h.h.e_f
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x : FamilyOfElements P (generate R).arrows
t : x.SieveCompatible
x✝¹ : C
x✝ : x✝¹ ⟶ X
h : (generate R).arrows x✝
⊢ ⋯.choose ≫ ⋯.choose = x✝
state_after: no goals
tactic: exact h.choose_spec.choose_spec.choose_spec.2
Theorem: Matroid.Basis.basis_restrict_of_subset
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
hI : M.Basis I X
hXY : X ⊆ Y
⊢ (M ↾ Y).Basis I X
state_after: no goals
tactic: rwa [← base_restrict_iff, M.restrict_restrict_eq hXY, base_restrict_iff]
Theorem: ContinuousLinearMap.inverse_equiv
File: Mathlib/Topology/Algebra/Module/Basic.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
⊢ (↑e).inverse = ↑e.symm
state_after: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ (↑e).inverse = ↑e.symm
tactic: have h : ∃ e' : M ≃L[R] M₂, (e' : M →L[R] M₂) = ↑e := ⟨e, rfl⟩
state_before: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ (↑e).inverse = ↑e.symm
state_after: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ ↑(Classical.choose h).symm = ↑e.symm
tactic: simp only [inverse, dif_pos h]
state_before: R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ ↑(Classical.choose h).symm = ↑e.symm
state_after: case e_e.e_e
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ Classical.choose h = e
tactic: congr
state_before: case e_e.e_e
R : Type u_1
M : Type u_2
M₂ : Type u_3
inst✝⁶ : TopologicalSpace M
inst✝⁵ : TopologicalSpace M₂
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M₂
inst✝² : Module R M₂
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
e : M ≃L[R] M₂
h : ∃ e', ↑e' = ↑e
⊢ Classical.choose h = e
state_after: no goals
tactic: exact mod_cast Classical.choose_spec h
Theorem: Sum.not_isRight
File: .lake/packages/batteries/Batteries/Data/Sum/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : α ⊕ β
⊢ ¬x.isRight = true ↔ x.isLeft = true
state_after: no goals
tactic: simp
Theorem: invOf_nonneg
File: Mathlib/Algebra/Order/Invertible.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrderedSemiring α
a : α
inst✝ : Invertible a
⊢ 0 < a * ⅟a
state_after: no goals
tactic: simp only [mul_invOf_self, zero_lt_one]
Theorem: Basis.map_addHaar
File: Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean

Proof steps:
state_before: ι : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : Fintype ι
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : MeasurableSpace E
inst✝⁴ : MeasurableSpace F
inst✝³ : BorelSpace E
inst✝² : BorelSpace F
inst✝¹ : SecondCountableTopology F
inst✝ : SigmaCompactSpace F
b : Basis ι ℝ E
f : E ≃L[ℝ] F
⊢ Measure.map (⇑f) b.addHaar = (b.map f.toLinearEquiv).addHaar
state_after: ι : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : Fintype ι
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : MeasurableSpace E
inst✝⁴ : MeasurableSpace F
inst✝³ : BorelSpace E
inst✝² : BorelSpace F
inst✝¹ : SecondCountableTopology F
inst✝ : SigmaCompactSpace F
b : Basis ι ℝ E
f : E ≃L[ℝ] F
this : (Measure.map (⇑f) b.addHaar).IsAddHaarMeasure
⊢ Measure.map (⇑f) b.addHaar = (b.map f.toLinearEquiv).addHaar
tactic: have : IsAddHaarMeasure (map f b.addHaar) :=
    AddEquiv.isAddHaarMeasure_map b.addHaar f.toAddEquiv f.continuous f.symm.continuous
state_before: ι : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : Fintype ι
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : MeasurableSpace E
inst✝⁴ : MeasurableSpace F
inst✝³ : BorelSpace E
inst✝² : BorelSpace F
inst✝¹ : SecondCountableTopology F
inst✝ : SigmaCompactSpace F
b : Basis ι ℝ E
f : E ≃L[ℝ] F
this : (Measure.map (⇑f) b.addHaar).IsAddHaarMeasure
⊢ Measure.map (⇑f) b.addHaar = (b.map f.toLinearEquiv).addHaar
state_after: ι : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : Fintype ι
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : MeasurableSpace E
inst✝⁴ : MeasurableSpace F
inst✝³ : BorelSpace E
inst✝² : BorelSpace F
inst✝¹ : SecondCountableTopology F
inst✝ : SigmaCompactSpace F
b : Basis ι ℝ E
f : E ≃L[ℝ] F
this : (Measure.map (⇑f) b.addHaar).IsAddHaarMeasure
⊢ b.addHaar (⇑f ⁻¹' _root_.parallelepiped (⇑f.toLinearEquiv ∘ ⇑b)) = 1
tactic: rw [eq_comm, Basis.addHaar_eq_iff, Measure.map_apply f.continuous.measurable
    (PositiveCompacts.isCompact _).measurableSet, Basis.coe_parallelepiped, Basis.coe_map]
state_before: ι : Type u_1
E : Type u_2
F : Type u_3
inst✝¹⁰ : Fintype ι
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedSpace ℝ F
inst✝⁵ : MeasurableSpace E
inst✝⁴ : MeasurableSpace F
inst✝³ : BorelSpace E
inst✝² : BorelSpace F
inst✝¹ : SecondCountableTopology F
inst✝ : SigmaCompactSpace F
b : Basis ι ℝ E
f : E ≃L[ℝ] F
this : (Measure.map (⇑f) b.addHaar).IsAddHaarMeasure
⊢ b.addHaar (⇑f ⁻¹' _root_.parallelepiped (⇑f.toLinearEquiv ∘ ⇑b)) = 1
state_after: no goals
tactic: erw [← image_parallelepiped, f.toEquiv.preimage_image, addHaar_self]
Theorem: ProbabilityTheory.gammaPDF_of_neg
File: Mathlib/Probability/Distributions/Gamma.lean

Proof steps:
state_before: a r x : ℝ
hx : x < 0
⊢ gammaPDF a r x = 0
state_after: no goals
tactic: simp only [gammaPDF_eq, if_neg (not_le.mpr hx), ENNReal.ofReal_zero]
Theorem: map_inv_lt_iff
File: Mathlib/Order/Hom/Basic.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : EquivLike F α β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ EquivLike.inv f b < a ↔ b < f a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : EquivLike F α β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ f (EquivLike.inv f b) < f a ↔ b < f a
tactic: rw [← map_lt_map_iff f]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝³ : Preorder α
inst✝² : Preorder β
inst✝¹ : EquivLike F α β
inst✝ : OrderIsoClass F α β
f : F
a : α
b : β
⊢ f (EquivLike.inv f b) < f a ↔ b < f a
state_after: no goals
tactic: simp only [EquivLike.apply_inv_apply]
Theorem: SimpleGraph.Walk.IsCycle.transfer
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
p✝ : ?m.47193
u v : V
H : SimpleGraph V
p : G.Walk u v
q : G.Walk u u
qc : q.IsCycle
hq : ∀ e ∈ q.edges, e ∈ H.edgeSet
⊢ (q.transfer H hq).IsCycle
state_after: no goals
tactic: cases q with
  | nil => simp at qc
  | cons _ q =>
    simp only [edges_cons, List.find?, List.mem_cons, forall_eq_or_imp, mem_edgeSet] at hq
    simp only [Walk.transfer, cons_isCycle_iff, edges_transfer q hq.2] at qc ⊢
    exact ⟨qc.1.transfer hq.2, qc.2⟩
Theorem: Interval.add_eq_zero_iff
File: Mathlib/Algebra/Order/Interval/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
s t : Interval α
⊢ s * t = 1 ↔ ∃ a b, s = pure a ∧ t = pure b ∧ a * b = 1
state_after: case bot
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
t : Interval α
⊢ ⊥ * t = 1 ↔ ∃ a b, ⊥ = pure a ∧ t = pure b ∧ a * b = 1

case coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
t : Interval α
a✝ : NonemptyInterval α
⊢ ↑a✝ * t = 1 ↔ ∃ a b, ↑a✝ = pure a ∧ t = pure b ∧ a * b = 1
tactic: cases s
state_before: case coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
t : Interval α
a✝ : NonemptyInterval α
⊢ ↑a✝ * t = 1 ↔ ∃ a b, ↑a✝ = pure a ∧ t = pure b ∧ a * b = 1
state_after: case coe.bot
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝ : NonemptyInterval α
⊢ ↑a✝ * ⊥ = 1 ↔ ∃ a b, ↑a✝ = pure a ∧ ⊥ = pure b ∧ a * b = 1

case coe.coe
ι : Type u_1
α : Type u_2
inst✝ : OrderedCommGroup α
a✝¹ a✝ : NonemptyInterval α
⊢ ↑a✝¹ * ↑a✝ = 1 ↔ ∃ a b, ↑a✝¹ = pure a ∧ ↑a✝ = pure b ∧ a * b = 1
tactic: cases t
Theorem: QuotientAddGroup.preimage_image_mk
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
⊢ mk ⁻¹' (mk '' s) = ⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s
state_after: case h
α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
⊢ x ∈ mk ⁻¹' (mk '' s) ↔ x ∈ ⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s
tactic: ext x
state_before: case h
α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
⊢ x ∈ mk ⁻¹' (mk '' s) ↔ x ∈ ⋃ x, (fun x_1 => x_1 * ↑x) ⁻¹' s
state_after: case h
α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
⊢ (∃ x_1 ∈ s, x_1⁻¹ * x ∈ N) ↔ ∃ x_1 ∈ N, x * x_1 ∈ s
tactic: simp only [QuotientGroup.eq, SetLike.exists, exists_prop, Set.mem_preimage, Set.mem_iUnion,
    Set.mem_image, ← eq_inv_mul_iff_mul_eq]
state_before: case h
α : Type u_1
inst✝ : Group α
s✝ : Subgroup α
a b : α
N : Subgroup α
s : Set α
x : α
⊢ (∃ x_1 ∈ s, x_1⁻¹ * x ∈ N) ↔ ∃ x_1 ∈ N, x * x_1 ∈ s
state_after: no goals
tactic: exact
    ⟨fun ⟨y, hs, hN⟩ => ⟨_, N.inv_mem hN, by simpa using hs⟩, fun ⟨z, hz, hxz⟩ =>
      ⟨x * z, hxz, by simpa using hz⟩⟩
Theorem: Semiring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : Semiring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : Semiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : Semiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: Matroid.Base.closure_eq
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hB : M.Base B
⊢ M.closure B = M.E
state_after: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hB : M.Basis B M.E
⊢ M.closure B = M.E
tactic: rw [← basis_ground_iff] at hB
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hB : M.Basis B M.E
⊢ M.closure B = M.E
state_after: no goals
tactic: rw [hB.closure_eq_closure, closure_ground]
Theorem: CategoryTheory.Limits.WalkingParallelPairHom.assoc
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: X Y Z W : WalkingParallelPair
f : WalkingParallelPairHom X Y
g : WalkingParallelPairHom Y Z
h : WalkingParallelPairHom Z W
⊢ (f.comp g).comp h = f.comp (g.comp h)
state_after: no goals
tactic: cases f <;> cases g <;> cases h <;> rfl
Theorem: Semigroup.mem_center_iff
File: Mathlib/Algebra/Group/Center.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
inst✝ : Semigroup M
a✝ b z : M
a : z ∈ center M
g : M
⊢ g * z = z * g
state_after: no goals
tactic: rw [IsMulCentral.comm a g]