ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: LiouvilleWith.mul_int_iff
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

Proof steps:
state_before: p q x y : ℝ
r : ℚ
m : ℤ
n : ℕ
hm : m ≠ 0
⊢ LiouvilleWith p (x * ↑m) ↔ LiouvilleWith p x
state_after: no goals
tactic: rw [← Rat.cast_intCast, mul_rat_iff (Int.cast_ne_zero.2 hm)]
Theorem: gcd_mul_right
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b c : α
⊢ gcd (b * a) (c * a) = gcd b c * normalize a
state_after: no goals
tactic: simp only [mul_comm, gcd_mul_left]
Theorem: Matrix.rank_le_card_width
File: Mathlib/Data/Matrix/Rank.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
⊢ A.rank ≤ Fintype.card n
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this : Module.Finite R (n → R)
⊢ A.rank ≤ Fintype.card n
tactic: haveI : Module.Finite R (n → R) := Module.Finite.pi
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this : Module.Finite R (n → R)
⊢ A.rank ≤ Fintype.card n
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this✝ : Module.Finite R (n → R)
this : Module.Free R (n → R)
⊢ A.rank ≤ Fintype.card n
tactic: haveI : Module.Free R (n → R) := Module.Free.pi _ _
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : StrongRankCondition R
A : Matrix m n R
this✝ : Module.Finite R (n → R)
this : Module.Free R (n → R)
⊢ A.rank ≤ Fintype.card n
state_after: no goals
tactic: exact A.mulVecLin.finrank_range_le.trans_eq (finrank_pi _)
Theorem: fderivWithin_continuousMultilinear_apply_const_apply
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type u_3
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁶ : NormedAddCommGroup G'
inst✝⁵ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝⁴ : Fintype ι
M : ι → Type u_7
inst✝³ : (i : ι) → NormedAddCommGroup (M i)
inst✝² : (i : ι) → NormedSpace 𝕜 (M i)
H : Type u_8
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
c : E → ContinuousMultilinearMap 𝕜 M H
c' : E →L[𝕜] ContinuousMultilinearMap 𝕜 M H
hxs : UniqueDiffWithinAt 𝕜 s x
hc : DifferentiableWithinAt 𝕜 c s x
u : (i : ι) → M i
m : E
⊢ (fderivWithin 𝕜 (fun y => (c y) u) s x) m = ((fderivWithin 𝕜 c s x) m) u
state_after: no goals
tactic: simp [fderivWithin_continuousMultilinear_apply_const hxs hc]
Theorem: fourierCoeffOn.const_smul
File: Mathlib/Analysis/Fourier/AddCircle.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
a b : ℝ
f : ℝ → E
c : ℂ
n : ℤ
hab : a < b
⊢ fourierCoeffOn hab (c • f) n = c • fourierCoeffOn hab f n
state_after: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
a b : ℝ
f : ℝ → E
c : ℂ
n : ℤ
hab : a < b
this : Fact (0 < b - a)
⊢ fourierCoeffOn hab (c • f) n = c • fourierCoeffOn hab f n
tactic: haveI := Fact.mk (by linarith : 0 < b - a)
state_before: T : ℝ
hT : Fact (0 < T)
E : Type
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℂ E
inst✝ : CompleteSpace E
a b : ℝ
f : ℝ → E
c : ℂ
n : ℤ
hab : a < b
this : Fact (0 < b - a)
⊢ fourierCoeffOn hab (c • f) n = c • fourierCoeffOn hab f n
state_after: no goals
tactic: apply fourierCoeff.const_smul
Theorem: CategoryTheory.StrongMono.of_arrow_iso
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
⊢ Mono g
state_after: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)
tactic: rw [Arrow.iso_w' e]
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)
state_after: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
this : Mono (f ≫ e.hom.right)
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)
tactic: haveI := mono_comp f e.hom.right
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
this : Mono (f ≫ e.hom.right)
⊢ Mono (e.inv.left ≫ f ≫ e.hom.right)
state_after: no goals
tactic: apply mono_comp
state_before: C : Type u
inst✝ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
X Y : C
z : X ⟶ Y
⊢ ∀ [inst : Epi z], HasLiftingProperty z g
state_after: C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
X Y : C
z : X ⟶ Y
inst✝ : Epi z
⊢ HasLiftingProperty z g
tactic: intro
state_before: C : Type u
inst✝¹ : Category.{v, u} C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongMono f
X Y : C
z : X ⟶ Y
inst✝ : Epi z
⊢ HasLiftingProperty z g
state_after: no goals
tactic: apply HasLiftingProperty.of_arrow_iso_right z e
Theorem: Ordinal.enumOrd_isNormal_iff_isClosed
File: Mathlib/SetTheory/Ordinal/Topology.lean

Proof steps:
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
⊢ IsNormal (enumOrd s) ↔ IsClosed s
state_after: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
⊢ IsNormal (enumOrd s) ↔ IsClosed s
tactic: have Hs := enumOrd_strictMono hs
state_before: s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
⊢ IsNormal (enumOrd s) ↔ IsClosed s
state_after: case refine_1
s : Set Ordinal.{u}
a : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsNormal (enumOrd s)
ι : Type u
hι : Nonempty ι
f : ι → Ordinal.{u}
hf : ∀ (i : ι), f i ∈ s
⊢ sup f ∈ s

case refine_2
s : Set Ordinal.{u}
a✝ : Ordinal.{u}
hs : Set.Unbounded (fun x x_1 => x < x_1) s
Hs : StrictMono (enumOrd s)
h : IsClosed s
a : Ordinal.{u}
ha : a.IsLimit
o : Ordinal.{u}
H : ∀ b < a, enumOrd s b ≤ o
⊢ enumOrd s a ≤ o
tactic: refine
    ⟨fun h => isClosed_iff_sup.2 fun {ι} hι f hf => ?_, fun h =>
      (isNormal_iff_strictMono_limit _).2 ⟨Hs, fun a ha o H => ?_⟩⟩
Theorem: Option.map_map₂_distrib
File: Mathlib/Data/Option/NAry.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
f : α → β → γ
a : Option α
b : Option β
c : Option γ
α' : Type u_5
β' : Type u_6
δ' : Type u_7
ε : Type u_8
ε' : Type u_9
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
⊢ Option.map g (map₂ f a b) = map₂ f' (Option.map g₁ a) (Option.map g₂ b)
state_after: no goals
tactic: cases a <;> cases b <;> simp [h_distrib]
Theorem: QuaternionGroup.orderOf_xa
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

Proof steps:
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (xa i) = 4
state_after: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (xa i) = 2 ^ 2
tactic: change _ = 2 ^ 2
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
⊢ orderOf (xa i) = 2 ^ 2
state_after: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ orderOf (xa i) = 2 ^ 2
tactic: haveI : Fact (Nat.Prime 2) := Fact.mk Nat.prime_two
state_before: n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ orderOf (xa i) = 2 ^ 2
state_after: case hnot
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ ¬xa i ^ 2 ^ 1 = 1

case hfin
n : ℕ
inst✝ : NeZero n
i : ZMod (2 * n)
this : Fact (Nat.Prime 2)
⊢ xa i ^ 2 ^ (1 + 1) = 1
tactic: apply orderOf_eq_prime_pow
Theorem: flip_innerₗ
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
⊢ (innerₗ F).flip = innerₗ F
state_after: case h.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
v w : F
⊢ ((innerₗ F).flip v) w = ((innerₗ F) v) w
tactic: ext v w
state_before: case h.h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
v w : F
⊢ ((innerₗ F).flip v) w = ((innerₗ F) v) w
state_after: no goals
tactic: exact real_inner_comm v w
Theorem: codisjoint_inf_left
File: Mathlib/Order/Disjoint.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DistribLattice α
inst✝ : OrderTop α
a b c : α
⊢ Codisjoint (a ⊓ b) c ↔ Codisjoint a c ∧ Codisjoint b c
state_after: no goals
tactic: simp only [codisjoint_iff, sup_inf_right, inf_eq_top_iff]
Theorem: CategoryTheory.Limits.biprod.lift_eq
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : Preadditive C
X Y : C
inst✝ : HasBinaryBiproduct X Y
T : C
f : T ⟶ X
g : T ⟶ Y
⊢ lift f g = f ≫ inl + g ≫ inr
state_after: no goals
tactic: ext <;> simp [add_comp]
Theorem: NonUnitalCommSemiring.toNonUnitalSemiring_injective
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
⊢ Function.Injective (@toNonUnitalSemiring R)
state_after: case mk.mk
R : Type u
toNonUnitalSemiring✝¹ : NonUnitalSemiring R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toNonUnitalSemiring✝ : NonUnitalSemiring R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toNonUnitalSemiring = toNonUnitalSemiring
⊢ mk mul_comm✝¹ = mk mul_comm✝
tactic: rintro ⟨⟩ ⟨⟩ _
state_before: case mk.mk
R : Type u
toNonUnitalSemiring✝¹ : NonUnitalSemiring R
mul_comm✝¹ : ∀ (a b : R), a * b = b * a
toNonUnitalSemiring✝ : NonUnitalSemiring R
mul_comm✝ : ∀ (a b : R), a * b = b * a
a✝ : toNonUnitalSemiring = toNonUnitalSemiring
⊢ mk mul_comm✝¹ = mk mul_comm✝
state_after: no goals
tactic: congr
Theorem: inf_eq_half_smul_add_sub_abs_sub'
File: Mathlib/Algebra/Order/Module/OrderedSMul.lean

Proof steps:
state_before: ι : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
𝕜 : Type u_5
R : Type u_6
M : Type u_7
N : Type u_8
α : Type u_9
β : Type u_10
inst✝⁵ : DivisionSemiring α
inst✝⁴ : NeZero 2
inst✝³ : Lattice β
inst✝² : AddCommGroup β
inst✝¹ : Module α β
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
x y : β
⊢ x ⊓ y = 2⁻¹ • (x + y - |y - x|)
state_after: ι : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
𝕜 : Type u_5
R : Type u_6
M : Type u_7
N : Type u_8
α : Type u_9
β : Type u_10
inst✝⁵ : DivisionSemiring α
inst✝⁴ : NeZero 2
inst✝³ : Lattice β
inst✝² : AddCommGroup β
inst✝¹ : Module α β
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
x y : β
this : Invertible 2 := invertibleOfNonzero ⋯
⊢ x ⊓ y = 2⁻¹ • (x + y - |y - x|)
tactic: letI := invertibleOfNonzero (two_ne_zero' α)
state_before: ι : Type u_1
α✝ : Type u_2
β✝ : Type u_3
γ : Type u_4
𝕜 : Type u_5
R : Type u_6
M : Type u_7
N : Type u_8
α : Type u_9
β : Type u_10
inst✝⁵ : DivisionSemiring α
inst✝⁴ : NeZero 2
inst✝³ : Lattice β
inst✝² : AddCommGroup β
inst✝¹ : Module α β
inst✝ : CovariantClass β β (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
x y : β
this : Invertible 2 := invertibleOfNonzero ⋯
⊢ x ⊓ y = 2⁻¹ • (x + y - |y - x|)
state_after: no goals
tactic: exact inf_eq_half_smul_add_sub_abs_sub α x y
Theorem: GaussianInt.toComplex_eq_zero
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x : ℤ[i]
⊢ toComplex x = 0 ↔ x = 0
state_after: no goals
tactic: rw [← toComplex_zero, toComplex_inj]
Theorem: Finset.sym2_univ
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Finset α
a b : α
inst✝ : Fintype α
inst : optParam (Fintype (Sym2 α)) Sym2.instFintype
⊢ univ.sym2 = univ
state_after: case a
α : Type u_1
β : Type u_2
s t : Finset α
a b : α
inst✝ : Fintype α
inst : optParam (Fintype (Sym2 α)) Sym2.instFintype
a✝ : Sym2 α
⊢ a✝ ∈ univ.sym2 ↔ a✝ ∈ univ
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
s t : Finset α
a b : α
inst✝ : Fintype α
inst : optParam (Fintype (Sym2 α)) Sym2.instFintype
a✝ : Sym2 α
⊢ a✝ ∈ univ.sym2 ↔ a✝ ∈ univ
state_after: no goals
tactic: simp only [mem_sym2_iff, mem_univ, implies_true]
Theorem: MeasureTheory.tendsto_integral_filter_of_dominated_convergence
File: Mathlib/MeasureTheory/Integral/DominatedConvergence.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
G : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
ι : Type u_4
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → α → G
f : α → G
bound : α → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) μ
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) l (𝓝 (f a))
⊢ Tendsto (fun n => ∫ (a : α), F n a ∂μ) l (𝓝 (∫ (a : α), f a ∂μ))
state_after: case pos
α : Type u_1
E : Type u_2
G : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
ι : Type u_4
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → α → G
f : α → G
bound : α → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) μ
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) l (𝓝 (f a))
hG : CompleteSpace G
⊢ Tendsto (fun n => ∫ (a : α), F n a ∂μ) l (𝓝 (∫ (a : α), f a ∂μ))

case neg
α : Type u_1
E : Type u_2
G : Type u_3
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
f✝ g : α → E
m : MeasurableSpace α
μ : Measure α
ι : Type u_4
l : Filter ι
inst✝ : l.IsCountablyGenerated
F : ι → α → G
f : α → G
bound : α → ℝ
hF_meas : ∀ᶠ (n : ι) in l, AEStronglyMeasurable (F n) μ
h_bound : ∀ᶠ (n : ι) in l, ∀ᵐ (a : α) ∂μ, ‖F n a‖ ≤ bound a
bound_integrable : Integrable bound μ
h_lim : ∀ᵐ (a : α) ∂μ, Tendsto (fun n => F n a) l (𝓝 (f a))
hG : ¬CompleteSpace G
⊢ Tendsto (fun n => ∫ (a : α), F n a ∂μ) l (𝓝 (∫ (a : α), f a ∂μ))
tactic: by_cases hG : CompleteSpace G
Theorem: ExteriorAlgebra.ι_eq_algebraMap_iff
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean

Proof steps:
state_before: R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
r : R
⊢ (ι R) x = (algebraMap R (ExteriorAlgebra R M)) r ↔ x = 0 ∧ r = 0
state_after: case refine_1
R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
r : R
h : (ι R) x = (algebraMap R (ExteriorAlgebra R M)) r
⊢ x = 0 ∧ r = 0

case refine_2
R : Type u1
inst✝⁴ : CommRing R
M : Type u2
inst✝³ : AddCommGroup M
inst✝² : Module R M
A : Type u_1
inst✝¹ : Semiring A
inst✝ : Algebra R A
x : M
r : R
⊢ x = 0 ∧ r = 0 → (ι R) x = (algebraMap R (ExteriorAlgebra R M)) r
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: Finset.filterMap_mono
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
s' s t : Finset α
f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'
h : s ⊆ t
⊢ filterMap f s f_inj ⊆ filterMap f t f_inj
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
s' s t : Finset α
f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'
h : s.val ≤ t.val
⊢ (filterMap f s f_inj).val ≤ (filterMap f t f_inj).val
tactic: rw [← val_le_iff] at h ⊢
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f : α → Option β
s' s t : Finset α
f_inj : ∀ (a a' : α), ∀ b ∈ f a, b ∈ f a' → a = a'
h : s.val ≤ t.val
⊢ (filterMap f s f_inj).val ≤ (filterMap f t f_inj).val
state_after: no goals
tactic: exact Multiset.filterMap_le_filterMap f h
Theorem: AddCommGrp.image.fac
File: Mathlib/Algebra/Category/Grp/Images.lean

Proof steps:
state_before: G H : AddCommGrp
f : G ⟶ H
⊢ factorThruImage f ≫ ι f = f
state_after: case w
G H : AddCommGrp
f : G ⟶ H
x✝ : ↑G
⊢ (factorThruImage f ≫ ι f) x✝ = f x✝
tactic: ext
state_before: case w
G H : AddCommGrp
f : G ⟶ H
x✝ : ↑G
⊢ (factorThruImage f ≫ ι f) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: IsOpen.inter_frontier_eq
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
hs : IsOpen s
⊢ s ∩ frontier s = ∅
state_after: no goals
tactic: rw [hs.frontier_eq, inter_diff_self]
Theorem: MeasureTheory.Measure.toPMF_toMeasure
File: Mathlib/Probability/ProbabilityMassFunction/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Countable α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
s : Set α
hs : MeasurableSet s
⊢ μ.toPMF.toMeasure s = μ s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Countable α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
s : Set α
hs : MeasurableSet s
⊢ ∑' (x : α), s.indicator (⇑μ.toPMF) x = ∑' (x : α), s.indicator (fun x => μ {x}) x
tactic: rw [μ.toPMF.toMeasure_apply s hs, ← μ.tsum_indicator_apply_singleton s hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Countable α
inst✝² : MeasurableSpace α
inst✝¹ : MeasurableSingletonClass α
μ : Measure α
inst✝ : IsProbabilityMeasure μ
s : Set α
hs : MeasurableSet s
⊢ ∑' (x : α), s.indicator (⇑μ.toPMF) x = ∑' (x : α), s.indicator (fun x => μ {x}) x
state_after: no goals
tactic: rfl
Theorem: Subsemigroup.mem_iInf
File: Mathlib/Algebra/Group/Subsemigroup/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
A : Type u_3
inst✝¹ : Mul M
s : Set M
inst✝ : Add A
t : Set A
S✝ : Subsemigroup M
ι : Sort u_4
S : ι → Subsemigroup M
x : M
⊢ x ∈ ⨅ i, S i ↔ ∀ (i : ι), x ∈ S i
state_after: no goals
tactic: simp only [iInf, mem_sInf, Set.forall_mem_range]
Theorem: dist_neg
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x y : E
⊢ dist x⁻¹ y = dist x y⁻¹
state_after: no goals
tactic: simp_rw [dist_eq_norm_div, ← norm_inv' (x⁻¹ / y), inv_div, div_inv_eq_mul, mul_comm]
Theorem: AddSemiconjBy.zero_right
File: Mathlib/Algebra/Group/Semiconj/Defs.lean

Proof steps:
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : MulOneClass M
a : M
⊢ SemiconjBy a 1 1
state_after: no goals
tactic: rw [SemiconjBy, mul_one, one_mul]
Theorem: List.perm_iff_count
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
⊢ l₁ ~ l₂ ↔ ∀ (a : α), count a l₁ = count a l₂
state_after: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
H : ∀ (a : α), count a l₁ = count a l₂
⊢ l₁ ~ l₂
tactic: refine ⟨Perm.count_eq, fun H => ?_⟩
state_before: α : Type u_1
inst✝ : DecidableEq α
l₁ l₂ : List α
H : ∀ (a : α), count a l₁ = count a l₂
⊢ l₁ ~ l₂
state_after: no goals
tactic: induction l₁ generalizing l₂ with
  | nil =>
    match l₂ with
    | nil => rfl
    | cons b l₂ =>
      specialize H b
      simp at H
  | cons a l₁ IH =>
    have : a ∈ l₂ := count_pos_iff_mem.mp (by rw [← H]; simp)
    refine ((IH fun b => ?_).cons a).trans (perm_cons_erase this).symm
    specialize H b
    rw [(perm_cons_erase this).count_eq] at H
    by_cases h : b = a <;> simpa [h] using H
Theorem: IsTorsion.of_surjective
File: Mathlib/GroupTheory/Torsion.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hf : Function.Surjective ⇑f
tG : IsTorsion G
h : H
⊢ IsOfFinOrder h
state_after: case intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hf : Function.Surjective ⇑f
tG : IsTorsion G
h : H
g : G
hg : f g = h
⊢ IsOfFinOrder h
tactic: obtain ⟨g, hg⟩ := hf h
state_before: case intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hf : Function.Surjective ⇑f
tG : IsTorsion G
h : H
g : G
hg : f g = h
⊢ IsOfFinOrder h
state_after: case intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hf : Function.Surjective ⇑f
tG : IsTorsion G
h : H
g : G
hg : f g = h
⊢ IsOfFinOrder (f g)
tactic: rw [← hg]
state_before: case intro
G : Type u_1
H : Type u_2
inst✝¹ : Group G
N : Subgroup G
inst✝ : Group H
f : G →* H
hf : Function.Surjective ⇑f
tG : IsTorsion G
h : H
g : G
hg : f g = h
⊢ IsOfFinOrder (f g)
state_after: no goals
tactic: exact f.isOfFinOrder (tG g)
Theorem: Polynomial.mem_map_rangeS
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : S[X]
⊢ p ∈ (mapRingHom f).rangeS ↔ ∀ (n : ℕ), p.coeff n ∈ f.rangeS
state_after: case mp
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : S[X]
⊢ p ∈ (mapRingHom f).rangeS → ∀ (n : ℕ), p.coeff n ∈ f.rangeS

case mpr
R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : Semiring S
f : R →+* S
p : S[X]
⊢ (∀ (n : ℕ), p.coeff n ∈ f.rangeS) → p ∈ (mapRingHom f).rangeS
tactic: constructor
Theorem: Pi.single_apply_addCommute
File: Mathlib/Algebra/Group/Pi/Lemmas.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i j : I
⊢ Commute (mulSingle i (x i)) (mulSingle j (x j))
state_after: case inl
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i : I
⊢ Commute (mulSingle i (x i)) (mulSingle i (x i))

case inr
ι : Type u_1
α : Type u_2
I : Type u
f : I → Type v
x✝ y : (i : I) → f i
i✝ j✝ : I
inst✝¹ : DecidableEq I
inst✝ : (i : I) → MulOneClass (f i)
x : (i : I) → f i
i j : I
hij : i ≠ j
⊢ Commute (mulSingle i (x i)) (mulSingle j (x j))
tactic: obtain rfl | hij := Decidable.eq_or_ne i j
Theorem: exists_open_set_nhds'
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
U : Set X
h : U ∈ ⨆ x ∈ s, 𝓝 x
⊢ ∀ x ∈ s, U ∈ 𝓝 x
state_after: no goals
tactic: simpa using h