ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ctop.ofEquiv_val
File: Mathlib/Data/Analysis/Topology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
F✝ : Ctop α σ
E : σ ≃ τ
F : Ctop α σ
a : τ
⊢ (ofEquiv E F).f a = F.f (E.symm a)
state_after: case mk
α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
F : Ctop α σ
E : σ ≃ τ
a : τ
f✝ : σ → Set α
top✝ : α → σ
top_mem✝ : ∀ (x : α), x ∈ f✝ (top✝ x)
inter✝ : (a b : σ) → (x : α) → x ∈ f✝ a ∩ f✝ b → σ
inter_mem✝ : ∀ (a b : σ) (x : α) (h : x ∈ f✝ a ∩ f✝ b), x ∈ f✝ (inter✝ a b x h)
inter_sub✝ : ∀ (a b : σ) (x : α) (h : x ∈ f✝ a ∩ f✝ b), f✝ (inter✝ a b x h) ⊆ f✝ a ∩ f✝ b
⊢ (ofEquiv E
          { f := f✝, top := top✝, top_mem := top_mem✝, inter := inter✝, inter_mem := inter_mem✝,
            inter_sub := inter_sub✝ }).f
      a =
    { f := f✝, top := top✝, top_mem := top_mem✝, inter := inter✝, inter_mem := inter_mem✝, inter_sub := inter_sub✝ }.f
      (E.symm a)
tactic: cases F
state_before: case mk
α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
F : Ctop α σ
E : σ ≃ τ
a : τ
f✝ : σ → Set α
top✝ : α → σ
top_mem✝ : ∀ (x : α), x ∈ f✝ (top✝ x)
inter✝ : (a b : σ) → (x : α) → x ∈ f✝ a ∩ f✝ b → σ
inter_mem✝ : ∀ (a b : σ) (x : α) (h : x ∈ f✝ a ∩ f✝ b), x ∈ f✝ (inter✝ a b x h)
inter_sub✝ : ∀ (a b : σ) (x : α) (h : x ∈ f✝ a ∩ f✝ b), f✝ (inter✝ a b x h) ⊆ f✝ a ∩ f✝ b
⊢ (ofEquiv E
          { f := f✝, top := top✝, top_mem := top_mem✝, inter := inter✝, inter_mem := inter_mem✝,
            inter_sub := inter_sub✝ }).f
      a =
    { f := f✝, top := top✝, top_mem := top_mem✝, inter := inter✝, inter_mem := inter_mem✝, inter_sub := inter_sub✝ }.f
      (E.symm a)
state_after: no goals
tactic: rfl
Theorem: Ordinal.pred_eq_iff_not_succ
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
o : Ordinal.{u_4}
e : o.pred = o
x✝ : ∃ a, o = succ a
a : Ordinal.{u_4}
e' : o = succ a
⊢ False
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
x✝ : ∃ a, o = succ a
a : Ordinal.{u_4}
e : a = succ a
e' : o = succ a
⊢ False
tactic: rw [e', pred_succ] at e
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_4}
x✝ : ∃ a, o = succ a
a : Ordinal.{u_4}
e : a = succ a
e' : o = succ a
⊢ False
state_after: no goals
tactic: exact (lt_succ a).ne e
Theorem: Complex.log_neg_I
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: ⊢ log (-I) = -(↑π / 2) * I
state_after: no goals
tactic: simp [log]
Theorem: MeasureTheory.VectorMeasure.restrict_zero
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
⊢ restrict 0 i = 0
state_after: case pos
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ restrict 0 i = 0

case neg
α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : ¬MeasurableSet i
⊢ restrict 0 i = 0
tactic: by_cases hi : MeasurableSet i
Theorem: MonoidHom.prod_unique
File: Mathlib/Algebra/Group/Prod.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
G : Type u_3
H : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
f : M →* N × P
x : M
⊢ (((fst N P).comp f).prod ((snd N P).comp f)) x = f x
state_after: no goals
tactic: simp only [prod_apply, coe_fst, coe_snd, comp_apply]
Theorem: Complex.normSq_I
File: Mathlib/Data/Complex/Basic.lean

Proof steps:
state_before: ⊢ normSq I = 1
state_after: no goals
tactic: simp [normSq]
Theorem: Filter.HasBasis.disjoint_iff_left
File: Mathlib/Order/Filter/Bases.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
l l' : Filter α
p : ι → Prop
s : ι → Set α
t : Set α
i : ι
p' : ι' → Prop
s' : ι' → Set α
i' : ι'
h : l.HasBasis p s
⊢ Disjoint l l' ↔ ∃ i, p i ∧ (s i)ᶜ ∈ l'
state_after: no goals
tactic: simp only [h.disjoint_iff l'.basis_sets, id, ← disjoint_principal_left,
    (hasBasis_principal _).disjoint_iff l'.basis_sets, true_and, Unique.exists_iff]
Theorem: hasSum_zeta_two
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: ⊢ HasSum (fun n => 1 / ↑n ^ 2) (π ^ 2 / 6)
state_after: case h.e'_6

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 * 1 - 1) * π ^ (2 * 1) * ↑(bernoulli (2 * 1)) / ↑(2 * 1)!
tactic: convert hasSum_zeta_nat one_ne_zero using 1
state_before: case h.e'_6

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 * 1 - 1) * π ^ (2 * 1) * ↑(bernoulli (2 * 1)) / ↑(2 * 1)!
state_after: case h.e'_6

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 - 1) * π ^ 2 * ↑(bernoulli 2) / ↑2!
tactic: rw [mul_one]
state_before: case h.e'_6

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 - 1) * π ^ 2 * ↑(bernoulli 2) / ↑2!
state_after: case h.e'_6

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 - 1) * π ^ 2 * ↑(1 / 6) / ↑2!
tactic: rw [bernoulli_eq_bernoulli'_of_ne_one (by decide : 2 ≠ 1), bernoulli'_two]
state_before: case h.e'_6

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 - 1) * π ^ 2 * ↑(1 / 6) / ↑2!
state_after: case h.e'_6

⊢ π ^ 2 / 6 = 2 * π ^ 2 * (1 / 6) / 2
tactic: norm_num [Nat.factorial]
state_before: case h.e'_6

⊢ π ^ 2 / 6 = 2 * π ^ 2 * (1 / 6) / 2
state_after: case h.e'_6

⊢ π ^ 2 * (6 * 2) = 2 * π ^ 2 * 6
tactic: field_simp
state_before: case h.e'_6

⊢ π ^ 2 * (6 * 2) = 2 * π ^ 2 * 6
state_after: no goals
tactic: ring
Theorem: EReal.neg_le
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a b : EReal
⊢ -a ≤ b ↔ -b ≤ a
state_after: no goals
tactic: rw [← neg_le_neg_iff, neg_neg]
Theorem: Real.four_mul_arctan_inv_5_sub_arctan_inv_239
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

Proof steps:
state_before: ⊢ 4 * arctan 5⁻¹ - arctan 239⁻¹ = π / 4
state_after: no goals
tactic: rw [show 4 * arctan _ = 2 * (2 * _) by ring, two_mul_arctan, two_mul_arctan, ← arctan_one,
    sub_eq_iff_eq_add, arctan_add] <;> norm_num
Theorem: Orientation.sin_oangle_add_left_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle (x + y) y).sin = ‖x‖ / ‖x + y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (x + y)).sin = ‖x‖ / ‖x + y‖
tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (x + y)).sin = ‖x‖ / ‖x + y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (y + x)).sin = ‖x‖ / ‖y + x‖
tactic: rw [add_comm]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle y (y + x)).sin = ‖x‖ / ‖y + x‖
state_after: no goals
tactic: exact (-o).sin_oangle_add_right_of_oangle_eq_pi_div_two h
Theorem: ArithmeticFunction.IsMultiplicative.iff_ne_zero
File: Mathlib/NumberTheory/ArithmeticFunction.lean

Proof steps:
state_before: R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
⊢ f.IsMultiplicative ↔ f 1 = 1 ∧ ∀ {m n : ℕ}, m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
state_after: R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
hmn : m.Coprime n
⊢ f (m * n) = f m * f n
tactic: refine and_congr_right' (forall₂_congr fun m n => ⟨fun h _ _ => h, fun h hmn => ?_⟩)
state_before: R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
hmn : m.Coprime n
⊢ f (m * n) = f m * f n
state_after: case inl
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
n : ℕ
h : 0 ≠ 0 → n ≠ 0 → Coprime 0 n → f (0 * n) = f 0 * f n
hmn : Coprime 0 n
⊢ f (0 * n) = f 0 * f n

case inr
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
hmn : m.Coprime n
hm : m ≠ 0
⊢ f (m * n) = f m * f n
tactic: rcases eq_or_ne m 0 with (rfl | hm)
state_before: case inr
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
hmn : m.Coprime n
hm : m ≠ 0
⊢ f (m * n) = f m * f n
state_after: case inr.inl
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m : ℕ
hm : m ≠ 0
h : m ≠ 0 → 0 ≠ 0 → m.Coprime 0 → f (m * 0) = f m * f 0
hmn : m.Coprime 0
⊢ f (m * 0) = f m * f 0

case inr.inr
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
hmn : m.Coprime n
hm : m ≠ 0
hn : n ≠ 0
⊢ f (m * n) = f m * f n
tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case inr.inr
R : Type u_1
inst✝ : MonoidWithZero R
f : ArithmeticFunction R
m n : ℕ
h : m ≠ 0 → n ≠ 0 → m.Coprime n → f (m * n) = f m * f n
hmn : m.Coprime n
hm : m ≠ 0
hn : n ≠ 0
⊢ f (m * n) = f m * f n
state_after: no goals
tactic: exact h hm hn hmn
Theorem: CircleDeg1Lift.units_apply_inv_apply
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

Proof steps:
state_before: f✝ g : CircleDeg1Lift
f : CircleDeg1Liftˣ
x : ℝ
⊢ ↑f (↑f⁻¹ x) = x
state_after: no goals
tactic: simp only [← mul_apply, f.mul_inv, coe_one, id]
Theorem: Polynomial.restriction_zero
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
⊢ restriction 0 = 0
state_after: no goals
tactic: simp only [restriction, Finset.sum_empty, support_zero]
Theorem: WeierstrassCurve.Jacobian.addXYZ_of_Z_eq_zero_right
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → R
hQ : W'.Equation Q
hQz : Q z = 0
⊢ W'.addXYZ P Q = -(Q x * P z) • P
state_after: no goals
tactic: rw [addXYZ, addX_of_Z_eq_zero_right hQz, addY_of_Z_eq_zero_right hQ hQz,
    addZ_of_Z_eq_zero_right hQz, smul_fin3]
Theorem: FreeAbelianGroup.of_mul_of
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝ : Mul α
x y : α
⊢ of x * of y = of (x * y)
state_after: no goals
tactic: rw [mul_def, lift.of, lift.of]
Theorem: CategoryTheory.GradedObject.mapBifunctorRightUnitorCofan_inj
File: Mathlib/CategoryTheory/GradedObject/Unitor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
I : Type u_3
J : Type u_4
inst✝⁵ : Category.{u_6, u_1} C
inst✝⁴ : Category.{u_5, u_2} D
inst✝³ : Zero I
inst✝² : DecidableEq I
inst✝¹ : HasInitial C
F : D ⥤ C ⥤ D
Y : C
e : F.flip.obj Y ≅ 𝟭 D
inst✝ : (X : D) → PreservesColimit (Functor.empty C) (F.obj X)
p : J × I → J
hp : ∀ (j : J), p (j, 0) = j
X X' : GradedObject J D
φ : X ⟶ X'
j : J
⊢ Cofan.inj (mapBifunctorRightUnitorCofan F Y e p hp X j) ⟨(j, 0), ⋯⟩ =
    (F.obj (X j)).map (singleObjApplyIso 0 Y).hom ≫ e.hom.app (X j)
state_after: no goals
tactic: simp [mapBifunctorRightUnitorCofan]
Theorem: _private.Mathlib.Analysis.Matrix.0.Matrix.mul_unitOf
File: Mathlib/Analysis/Matrix.lean

Proof steps:
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Unique ι
inst✝² : NormedDivisionRing α
inst✝¹ : NormedAlgebra ℝ α
inst✝ : CompleteSpace α
a : α
⊢ a * Matrix.unitOf a = (algebraMap ℝ α) ↑‖a‖₊
state_after: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Unique ι
inst✝² : NormedDivisionRing α
inst✝¹ : NormedAlgebra ℝ α
inst✝ : CompleteSpace α
a : α
⊢ (a * if a = 0 then 1 else ‖a‖ • a⁻¹) = (algebraMap ℝ α) ‖a‖
tactic: simp only [unitOf, coe_nnnorm]
state_before: R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Unique ι
inst✝² : NormedDivisionRing α
inst✝¹ : NormedAlgebra ℝ α
inst✝ : CompleteSpace α
a : α
⊢ (a * if a = 0 then 1 else ‖a‖ • a⁻¹) = (algebraMap ℝ α) ‖a‖
state_after: case pos
R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Unique ι
inst✝² : NormedDivisionRing α
inst✝¹ : NormedAlgebra ℝ α
inst✝ : CompleteSpace α
a : α
h : a = 0
⊢ a * 1 = (algebraMap ℝ α) ‖a‖

case neg
R : Type u_1
l : Type u_2
m : Type u_3
n : Type u_4
α : Type u_5
β : Type u_6
ι : Type u_7
inst✝⁶ : Fintype l
inst✝⁵ : Fintype m
inst✝⁴ : Fintype n
inst✝³ : Unique ι
inst✝² : NormedDivisionRing α
inst✝¹ : NormedAlgebra ℝ α
inst✝ : CompleteSpace α
a : α
h : ¬a = 0
⊢ a * ‖a‖ • a⁻¹ = (algebraMap ℝ α) ‖a‖
tactic: split_ifs with h
Theorem: SimpleGraph.Subgraph.singletonSubgraph_connected
File: Mathlib/Combinatorics/SimpleGraph/Connectivity/Subgraph.lean

Proof steps:
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v : V
⊢ (G.singletonSubgraph v).Connected
state_after: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v : V
⊢ (G.singletonSubgraph v).coe.Preconnected
tactic: refine ⟨⟨?_⟩⟩
state_before: V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v : V
⊢ (G.singletonSubgraph v).coe.Preconnected
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha : a ∈ (G.singletonSubgraph v).verts
b : V
hb : b ∈ (G.singletonSubgraph v).verts
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha⟩ ⟨b, hb⟩
tactic: rintro ⟨a, ha⟩ ⟨b, hb⟩
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha : a ∈ (G.singletonSubgraph v).verts
b : V
hb : b ∈ (G.singletonSubgraph v).verts
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha⟩ ⟨b, hb⟩
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha✝ : a ∈ (G.singletonSubgraph v).verts
b : V
hb✝ : b ∈ (G.singletonSubgraph v).verts
ha : a = v
hb : b = v
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha✝⟩ ⟨b, hb✝⟩
tactic: simp only [singletonSubgraph_verts, Set.mem_singleton_iff] at ha hb
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
v a : V
ha✝ : a ∈ (G.singletonSubgraph v).verts
b : V
hb✝ : b ∈ (G.singletonSubgraph v).verts
ha : a = v
hb : b = v
⊢ (G.singletonSubgraph v).coe.Reachable ⟨a, ha✝⟩ ⟨b, hb✝⟩
state_after: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
b : V
ha hb : b = b
⊢ (G.singletonSubgraph b).coe.Reachable ⟨b, ⋯⟩ ⟨b, ⋯⟩
tactic: subst_vars
state_before: case mk.mk
V : Type u
V' : Type v
G : SimpleGraph V
G' : SimpleGraph V'
b : V
ha hb : b = b
⊢ (G.singletonSubgraph b).coe.Reachable ⟨b, ⋯⟩ ⟨b, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: normalizerCondition_iff_only_full_group_self_normalizing
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
H K : Subgroup G
N : Type u_5
inst✝ : Group N
⊢ NormalizerCondition G ↔ ∀ (H : Subgroup G), H.normalizer = H → H = ⊤
state_after: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
H K : Subgroup G
N : Type u_5
inst✝ : Group N
⊢ ∀ (a : Subgroup G), a < ⊤ → a < a.normalizer ↔ a.normalizer = a → a = ⊤
tactic: apply forall_congr'
state_before: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
H K : Subgroup G
N : Type u_5
inst✝ : Group N
⊢ ∀ (a : Subgroup G), a < ⊤ → a < a.normalizer ↔ a.normalizer = a → a = ⊤
state_after: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
H✝ K : Subgroup G
N : Type u_5
inst✝ : Group N
H : Subgroup G
⊢ H < ⊤ → H < H.normalizer ↔ H.normalizer = H → H = ⊤
tactic: intro H
state_before: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
H✝ K : Subgroup G
N : Type u_5
inst✝ : Group N
H : Subgroup G
⊢ H < ⊤ → H < H.normalizer ↔ H.normalizer = H → H = ⊤
state_after: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
H✝ K : Subgroup G
N : Type u_5
inst✝ : Group N
H : Subgroup G
⊢ ¬H = ⊤ → ¬H = H.normalizer ↔ H.normalizer = H → H = ⊤
tactic: simp only [lt_iff_le_and_ne, le_normalizer, true_and_iff, le_top, Ne]
state_before: case h
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
H✝ K : Subgroup G
N : Type u_5
inst✝ : Group N
H : Subgroup G
⊢ ¬H = ⊤ → ¬H = H.normalizer ↔ H.normalizer = H → H = ⊤
state_after: no goals
tactic: tauto
Theorem: unique_subtype_iff_exists_unique
File: Mathlib/Logic/Unique.lean

Proof steps:
state_before: α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ ⟨b, hb⟩ = default
state_after: case e_val
α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ b = a
tactic: congr
state_before: case e_val
α : Sort u_1
p : α → Prop
x✝¹ : ∃! a, p a
a : α
ha : (fun a => p a) a
he : ∀ (y : α), (fun a => p a) y → y = a
x✝ : Subtype p
b : α
hb : p b
⊢ b = a
state_after: no goals
tactic: exact he b hb
Theorem: map_zsmul'
File: Mathlib/Algebra/Group/Hom/Defs.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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), f x⁻¹ = (f x)⁻¹
a : G
n : ℕ
⊢ f (a ^ ↑n) = f a ^ ↑n
state_after: no goals
tactic: rw [zpow_natCast, map_pow, zpow_natCast]
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
H : Type u_8
F : Type u_9
inst✝⁶ : MulOneClass M
inst✝⁵ : MulOneClass N
inst✝⁴ : FunLike F M N
inst✝³ : FunLike F G H
inst✝² : DivInvMonoid G
inst✝¹ : DivInvMonoid H
inst✝ : MonoidHomClass F G H
f : F
hf : ∀ (x : G), f x⁻¹ = (f x)⁻¹
a : G
n : ℕ
⊢ f (a ^ Int.negSucc n) = f a ^ Int.negSucc n
state_after: no goals
tactic: rw [zpow_negSucc, hf, map_pow, ← zpow_negSucc]
Theorem: LSeries.term_convolution
File: Mathlib/NumberTheory/LSeries/Convolution.lean

Proof steps:
state_before: f g : ℕ → ℂ
s : ℂ
n : ℕ
⊢ term (f ⍟ g) s n = ∑ p ∈ n.divisorsAntidiagonal, term f s p.1 * term g s p.2
state_after: case inl
f g : ℕ → ℂ
s : ℂ
⊢ term (f ⍟ g) s 0 = ∑ p ∈ divisorsAntidiagonal 0, term f s p.1 * term g s p.2

case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ term (f ⍟ g) s n = ∑ p ∈ n.divisorsAntidiagonal, term f s p.1 * term g s p.2
tactic: rcases eq_or_ne n 0 with rfl | hn
state_before: case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ term (f ⍟ g) s n = ∑ p ∈ n.divisorsAntidiagonal, term f s p.1 * term g s p.2
state_after: case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ∑ i ∈ n.divisorsAntidiagonal, f i.1 * g i.2 / ↑n ^ s = ∑ p ∈ n.divisorsAntidiagonal, term f s p.1 * term g s p.2
tactic: rw [term_of_ne_zero hn, convolution_def, Finset.sum_div]
state_before: case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
⊢ ∑ i ∈ n.divisorsAntidiagonal, f i.1 * g i.2 / ↑n ^ s = ∑ p ∈ n.divisorsAntidiagonal, term f s p.1 * term g s p.2
state_after: case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
⊢ f p.1 * g p.2 / ↑n ^ s = term f s p.1 * term g s p.2
tactic: refine Finset.sum_congr rfl fun p hp ↦ ?_
state_before: case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
⊢ f p.1 * g p.2 / ↑n ^ s = term f s p.1 * term g s p.2
state_after: case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
hp₁ : p.1 ≠ 0
hp₂ : p.2 ≠ 0
⊢ f p.1 * g p.2 / ↑n ^ s = term f s p.1 * term g s p.2
tactic: have ⟨hp₁, hp₂⟩ := ne_zero_of_mem_divisorsAntidiagonal hp
state_before: case inr
f g : ℕ → ℂ
s : ℂ
n : ℕ
hn : n ≠ 0
p : ℕ × ℕ
hp : p ∈ n.divisorsAntidiagonal
hp₁ : p.1 ≠ 0
hp₂ : p.2 ≠ 0
⊢ f p.1 * g p.2 / ↑n ^ s = term f s p.1 * term g s p.2
state_after: no goals
tactic: rw [term_of_ne_zero hp₁ f s, term_of_ne_zero hp₂ g s, mul_comm_div, div_div, ← mul_div_assoc,
    ← natCast_mul_natCast_cpow, ← cast_mul, mul_comm p.2, (mem_divisorsAntidiagonal.mp hp).1]
Theorem: BooleanRing.sup_comm
File: Mathlib/Algebra/Ring/BooleanRing.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : BooleanRing α
inst✝¹ : BooleanRing β
inst✝ : BooleanRing γ
a b : α
⊢ a + b + a * b = b + a + b * a
state_after: no goals
tactic: ring
Theorem: Composition.eq_ones_iff_le_length
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c✝ c : Composition n
⊢ c = ones n ↔ n ≤ c.length
state_after: no goals
tactic: simp [eq_ones_iff_length, le_antisymm_iff, c.length_le]
Theorem: Multiset.foldr_induction'
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
f : α → β → β
H : LeftCommutative f
x : β
q : α → Prop
p : β → Prop
s : Multiset α
hpqf : ∀ (a : α) (b : β), q a → p b → p (f a b)
px : p x
q_s : ∀ a ∈ s, q a
⊢ p (foldr f H x s)
state_after: no goals
tactic: induction s using Multiset.induction with
  | empty => simpa
  | cons a s ihs =>
    simp only [forall_mem_cons, foldr_cons] at q_s ⊢
    exact hpqf _ _ q_s.1 (ihs q_s.2)
Theorem: ProbabilityTheory.Kernel.comap_map_comm
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f✝ : β → γ
g✝ : γ → α
κ : Kernel β γ
f : α → β
g : γ → δ
hf : Measurable f
hg : Measurable g
⊢ (κ.map g hg).comap f hf = (κ.comap f hf).map g hg
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f✝ : β → γ
g✝ : γ → α
κ : Kernel β γ
f : α → β
g : γ → δ
hf : Measurable f
hg : Measurable g
x : α
s : Set δ
a✝ : MeasurableSet s
⊢ (((κ.map g hg).comap f hf) x) s = (((κ.comap f hf).map g hg) x) s
tactic: ext x s _
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
δ : Type u_5
mγ : MeasurableSpace γ
mδ : MeasurableSpace δ
f✝ : β → γ
g✝ : γ → α
κ : Kernel β γ
f : α → β
g : γ → δ
hf : Measurable f
hg : Measurable g
x : α
s : Set δ
a✝ : MeasurableSet s
⊢ (((κ.map g hg).comap f hf) x) s = (((κ.comap f hf).map g hg) x) s
state_after: no goals
tactic: rw [comap_apply, map_apply, map_apply, comap_apply]