ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: groupCohomology.twoCocycles_map_one_snd
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
⊢ ↑f (g, 1) = (A.ρ g) (↑f (1, 1))
state_after: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : ↑f (g * 1, 1) + ↑f (g, 1) = (A.ρ g) (↑f (1, 1)) + ↑f (g, 1 * 1)
⊢ ↑f (g, 1) = (A.ρ g) (↑f (1, 1))
tactic: have := (mem_twoCocycles_iff f.1).1 f.2 g 1 1
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
f : ↥(twoCocycles A)
g : G
this : ↑f (g * 1, 1) + ↑f (g, 1) = (A.ρ g) (↑f (1, 1)) + ↑f (g, 1 * 1)
⊢ ↑f (g, 1) = (A.ρ g) (↑f (1, 1))
state_after: no goals
tactic: simpa only [mul_one, add_left_inj, this]
Theorem: AddCommGroup.zsmul_add_modEq
File: Mathlib/Algebra/ModEq.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommGroup α
p a a₁ a₂ b b₁ b₂ c : α
n : ℕ
z✝ z : ℤ
⊢ a - (z • p + a) = -z • p
state_after: no goals
tactic: simp [← sub_sub]
Theorem: Matrix.diagonal_const_mulVec
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
x : α
v : m → α
⊢ (diagonal fun x_1 => x) *ᵥ v = x • v
state_after: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
x : α
v : m → α
x✝ : m
⊢ ((diagonal fun x_1 => x) *ᵥ v) x✝ = (x • v) x✝
tactic: ext
state_before: case h
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝³ : NonAssocSemiring α
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : DecidableEq m
x : α
v : m → α
x✝ : m
⊢ ((diagonal fun x_1 => x) *ᵥ v) x✝ = (x • v) x✝
state_after: no goals
tactic: simp [mulVec_diagonal]
Theorem: IsOpen.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
⊢ frontier s = closure s \ s
state_after: no goals
tactic: rw [frontier, hs.interior_eq]
Theorem: CategoryTheory.Limits.imageSubobjectCompIso_inv_arrow
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
X Y Z : C
f✝ : X ⟶ Y
inst✝³ : HasImage f✝
inst✝² : HasEqualizers C
f : X ⟶ Y
inst✝¹ : HasImage f
Y' : C
h : Y ⟶ Y'
inst✝ : IsIso h
⊢ (imageSubobjectCompIso f h).inv ≫ (imageSubobject (f ≫ h)).arrow = (imageSubobject f).arrow ≫ h
state_after: no goals
tactic: simp [imageSubobjectCompIso]
Theorem: AddLECancellable.eq_tsub_iff_add_eq_of_le
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ a = b - c → a + c = b
state_after: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ b - c + c = b
tactic: rintro rfl
state_before: α : Type u_1
inst✝⁵ : AddCommSemigroup α
inst✝⁴ : PartialOrder α
inst✝³ : ExistsAddOfLE α
inst✝² : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝¹ : Sub α
inst✝ : OrderedSub α
b c d : α
hc : AddLECancellable c
h : c ≤ b
⊢ b - c + c = b
state_after: no goals
tactic: exact tsub_add_cancel_of_le h
Theorem: Polynomial.degree_eq_one_of_irreducible_of_root
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
h : IsUnit (X - C x)
⊢ p.degree = 1
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
h : IsUnit (X - C x)
h₁ : (X - C x).degree = 1
⊢ p.degree = 1
tactic: have h₁ : degree (X - C x) = 1 := degree_X_sub_C x
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
h : IsUnit (X - C x)
h₁ : (X - C x).degree = 1
⊢ p.degree = 1
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
h : IsUnit (X - C x)
h₁ : (X - C x).degree = 1
h₂ : (X - C x).degree = 0
⊢ p.degree = 1
tactic: have h₂ : degree (X - C x) = 0 := degree_eq_zero_of_isUnit h
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
h : IsUnit (X - C x)
h₁ : (X - C x).degree = 1
h₂ : (X - C x).degree = 0
⊢ p.degree = 1
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
h : IsUnit (X - C x)
h₁ : (X - C x).degree = 1
h₂ : 1 = 0
⊢ p.degree = 1
tactic: rw [h₁] at h₂
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
h : IsUnit (X - C x)
h₁ : (X - C x).degree = 1
h₂ : 1 = 0
⊢ p.degree = 1
state_after: no goals
tactic: exact absurd h₂ (by decide)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hi : Irreducible p
x : R
hx : p.IsRoot x
g : R[X]
hg : p = (X - C x) * g
this : IsUnit (X - C x) ∨ IsUnit g
hgu : IsUnit g
⊢ p.degree = 1
state_after: no goals
tactic: rw [hg, degree_mul, degree_X_sub_C, degree_eq_zero_of_isUnit hgu, add_zero]
Theorem: AlgebraicIndependent.image
File: Mathlib/RingTheory/AlgebraicIndependent.lean

Proof steps:
state_before: ι✝ : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι✝ → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
ι : Type u_9
s : Set ι
f : ι → A
hs : AlgebraicIndependent R fun x => f ↑x
⊢ AlgebraicIndependent R fun x => ↑x
state_after: no goals
tactic: convert AlgebraicIndependent.image_of_comp s f id hs
Theorem: MvPowerSeries.mul_zero
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n✝ : σ →₀ ℕ
φ ψ : MvPowerSeries σ R
n : σ →₀ ℕ
⊢ (coeff R n) (φ * 0) = (coeff R n) 0
state_after: no goals
tactic: classical simp [coeff_mul]
Theorem: UniqueMul.to_mulOpposite
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
⊢ UniqueMul (map { toFun := op, inj' := ⋯ } (map { toFun := op, inj' := ⋯ } A))
    (map { toFun := op, inj' := ⋯ } (map { toFun := op, inj' := ⋯ } B)) (op (op a0)) (op (op b0))
state_after: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
⊢ UniqueMul (map ({ toFun := op, inj' := ⋯ }.trans { toFun := op, inj' := ⋯ }) A)
    (map ({ toFun := op, inj' := ⋯ }.trans { toFun := op, inj' := ⋯ }) B) (op (op a0)) (op (op b0))
tactic: simp_rw [map_map]
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
⊢ UniqueMul (map ({ toFun := op, inj' := ⋯ }.trans { toFun := op, inj' := ⋯ }) A)
    (map ({ toFun := op, inj' := ⋯ }.trans { toFun := op, inj' := ⋯ }) B) (op (op a0)) (op (op b0))
state_after: no goals
tactic: exact (mulHom_map_iff _ fun _ _ ↦ by rfl).mpr h
Theorem: CategoryTheory.NatTrans.mapHomotopyCategory_app
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : Semiring R
ι : Type u_2
V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : Preadditive V
c✝ : ComplexShape ι
W : Type u_3
inst✝³ : Category.{?u.37324, u_3} W
inst✝² : Preadditive W
F G : V ⥤ W
inst✝¹ : F.Additive
inst✝ : G.Additive
α : F ⟶ G
c : ComplexShape ι
⊢ ∀ ⦃X Y : HomotopyCategory V c⦄ (f : X ⟶ Y),
    (F.mapHomotopyCategory c).map f ≫
        (fun C => (HomotopyCategory.quotient W c).map ((mapHomologicalComplex α c).app C.as)) Y =
      (fun C => (HomotopyCategory.quotient W c).map ((mapHomologicalComplex α c).app C.as)) X ≫
        (G.mapHomotopyCategory c).map f
state_after: case mk.mk.mk
R : Type u_1
inst✝⁶ : Semiring R
ι : Type u_2
V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : Preadditive V
c✝ : ComplexShape ι
W : Type u_3
inst✝³ : Category.{?u.37324, u_3} W
inst✝² : Preadditive W
F G : V ⥤ W
inst✝¹ : F.Additive
inst✝ : G.Additive
α : F ⟶ G
c : ComplexShape ι
C D : HomologicalComplex V c
f✝ : { as := C } ⟶ { as := D }
f : C ⟶ D
⊢ (F.mapHomotopyCategory c).map (Quot.mk (Quotient.CompClosure (homotopic V c)) f) ≫
      (fun C => (HomotopyCategory.quotient W c).map ((mapHomologicalComplex α c).app C.as)) { as := D } =
    (fun C => (HomotopyCategory.quotient W c).map ((mapHomologicalComplex α c).app C.as)) { as := C } ≫
      (G.mapHomotopyCategory c).map (Quot.mk (Quotient.CompClosure (homotopic V c)) f)
tactic: rintro ⟨C⟩ ⟨D⟩ ⟨f : C ⟶ D⟩
state_before: case mk.mk.mk
R : Type u_1
inst✝⁶ : Semiring R
ι : Type u_2
V : Type u
inst✝⁵ : Category.{v, u} V
inst✝⁴ : Preadditive V
c✝ : ComplexShape ι
W : Type u_3
inst✝³ : Category.{?u.37324, u_3} W
inst✝² : Preadditive W
F G : V ⥤ W
inst✝¹ : F.Additive
inst✝ : G.Additive
α : F ⟶ G
c : ComplexShape ι
C D : HomologicalComplex V c
f✝ : { as := C } ⟶ { as := D }
f : C ⟶ D
⊢ (F.mapHomotopyCategory c).map (Quot.mk (Quotient.CompClosure (homotopic V c)) f) ≫
      (fun C => (HomotopyCategory.quotient W c).map ((mapHomologicalComplex α c).app C.as)) { as := D } =
    (fun C => (HomotopyCategory.quotient W c).map ((mapHomologicalComplex α c).app C.as)) { as := C } ≫
      (G.mapHomotopyCategory c).map (Quot.mk (Quotient.CompClosure (homotopic V c)) f)
state_after: no goals
tactic: simp only [HomotopyCategory.quot_mk_eq_quotient_map, Functor.mapHomotopyCategory_map,
      ← Functor.map_comp, NatTrans.naturality]
Theorem: RingHomInvPair.comp_apply_eq₂
File: Mathlib/Algebra/Ring/CompTypeclasses.lean

Proof steps:
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝³ : Semiring R₁
inst✝² : Semiring R₂
inst✝¹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
σ : R₁ →+* R₂
σ' : R₂ →+* R₁
inst✝ : RingHomInvPair σ σ'
x : R₂
⊢ σ (σ' x) = x
state_after: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝³ : Semiring R₁
inst✝² : Semiring R₂
inst✝¹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
σ : R₁ →+* R₂
σ' : R₂ →+* R₁
inst✝ : RingHomInvPair σ σ'
x : R₂
⊢ (RingHom.id R₂) x = x
tactic: rw [← RingHom.comp_apply, comp_eq₂]
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝³ : Semiring R₁
inst✝² : Semiring R₂
inst✝¹ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
σ : R₁ →+* R₂
σ' : R₂ →+* R₁
inst✝ : RingHomInvPair σ σ'
x : R₂
⊢ (RingHom.id R₂) x = x
state_after: no goals
tactic: simp
Theorem: NonUnitalRingHom.range_top_iff_surjective
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

Proof steps:
state_before: F : Type w
R : Type u
S : Type v
T : Type u_1
inst✝⁴ : NonUnitalNonAssocRing R
inst✝³ : NonUnitalNonAssocRing S
inst✝² : NonUnitalNonAssocRing T
inst✝¹ : FunLike F R S
inst✝ : NonUnitalRingHomClass F R S
g : S →ₙ+* T
f✝ : R →ₙ+* S
s : NonUnitalSubring R
f : R →ₙ+* S
⊢ ↑f.range = ↑⊤ ↔ Set.range ⇑f = Set.univ
state_after: no goals
tactic: rw [coe_range, coe_top]
Theorem: Bool.bool_iff_false
File: Mathlib/Data/Bool/Basic.lean

Proof steps:
state_before: b : Bool
⊢ ¬b = true ↔ b = false
state_after: no goals
tactic: cases b <;> decide
Theorem: Polynomial.taylor_taylor
File: Mathlib/Algebra/Polynomial/Taylor.lean

Proof steps:
state_before: R✝ : Type u_1
inst✝¹ : Semiring R✝
r✝ : R✝
f✝ : R✝[X]
R : Type u_2
inst✝ : CommSemiring R
f : R[X]
r s : R
⊢ (taylor r) ((taylor s) f) = (taylor (r + s)) f
state_after: no goals
tactic: simp only [taylor_apply, comp_assoc, map_add, add_comp, X_comp, C_comp, C_add, add_assoc]
Theorem: CategoryTheory.Comma.coneOfPreserves_π_app_left
File: Mathlib/CategoryTheory/Limits/Comma.lean

Proof steps:
state_before: J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ ((Functor.const J).obj
            { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
        t ≫
      (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂ =
    (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t
state_after: case h₁
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
          t ≫
        (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂).left =
    ((fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t).left

case h₂
J : Type w
inst✝⁴ : Category.{w', w} J
A : Type u₁
inst✝³ : Category.{v₁, u₁} A
B : Type u₂
inst✝² : Category.{v₂, u₂} B
T : Type u₃
inst✝¹ : Category.{v₃, u₃} T
L : A ⥤ T
R : B ⥤ T
F : J ⥤ Comma L R
inst✝ : PreservesLimit (F ⋙ snd L R) R
c₁ : Cone (F ⋙ fst L R)
c₂ : Cone (F ⋙ snd L R)
t₂ : IsLimit c₂
j₁ j₂ : J
t : j₁ ⟶ j₂
⊢ (((Functor.const J).obj
              { left := c₁.pt, right := c₂.pt, hom := (isLimitOfPreserves R t₂).lift (limitAuxiliaryCone F c₁) }).map
          t ≫
        (fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₂).right =
    ((fun j => { left := c₁.π.app j, right := c₂.π.app j, w := ⋯ }) j₁ ≫ F.map t).right
tactic: ext
Theorem: Finset.Nonempty.zero_div
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : GroupWithZero α
s t : Finset α
hs : s.Nonempty
⊢ 0 ⊆ 0 / s
state_after: no goals
tactic: simpa [mem_div] using hs
Theorem: Orientation.tan_oangle_add_right_smul_rotation_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 : V
h : x ≠ 0
r : ℝ
⊢ (o.oangle x (x + r • (o.rotation ↑(π / 2)) x)).tan = r
state_after: no goals
tactic: rw [o.oangle_add_right_smul_rotation_pi_div_two h, Real.Angle.tan_coe, Real.tan_arctan]
Theorem: MeasureTheory.IntegrableOn.inter_of_restrict
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s (μ.restrict t)
⊢ IntegrableOn f (s ∩ t) μ
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s (μ.restrict t)
this : IntegrableOn f (s ∩ t) (μ.restrict t)
⊢ IntegrableOn f (s ∩ t) μ
tactic: have := h.mono_set (inter_subset_left (t := t))
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
h : IntegrableOn f s (μ.restrict t)
this : IntegrableOn f (s ∩ t) (μ.restrict t)
⊢ IntegrableOn f (s ∩ t) μ
state_after: no goals
tactic: rwa [IntegrableOn, μ.restrict_restrict_of_subset inter_subset_right] at this
Theorem: CategoryTheory.ShortComplex.homologyπ_naturality
File: Mathlib/Algebra/Homology/ShortComplex/Homology.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝² : S.HasHomology
φ : S₁ ⟶ S₂
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
⊢ S₁.homologyπ ≫ homologyMap φ = cyclesMap φ ≫ S₂.homologyπ
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝² : S.HasHomology
φ : S₁ ⟶ S₂
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
⊢ S₁.homologyπ ≫ S₁.leftHomologyIso.inv ≫ leftHomologyMap φ = cyclesMap φ ≫ S₂.leftHomologyπ
tactic: simp only [← cancel_mono S₂.leftHomologyIso.inv, assoc, ← leftHomologyIso_inv_naturality φ,
    homologyπ_comp_leftHomologyIso_inv]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
S S₁ S₂ S₃ S₄ : ShortComplex C
φ✝ : S₁ ⟶ S₂
h₁ : S₁.HomologyData
h₂ : S₂.HomologyData
A : C
inst✝² : S.HasHomology
φ : S₁ ⟶ S₂
inst✝¹ : S₁.HasHomology
inst✝ : S₂.HasHomology
⊢ S₁.homologyπ ≫ S₁.leftHomologyIso.inv ≫ leftHomologyMap φ = cyclesMap φ ≫ S₂.leftHomologyπ
state_after: no goals
tactic: simp only [homologyπ, assoc, Iso.hom_inv_id_assoc, leftHomologyπ_naturality]
Theorem: Turing.tr_eval
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab : b₁ ∈ eval f₁ a₁
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂
state_after: case intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝ : b₁ ∈ eval f₁ a₁
ab : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂
tactic: cases' mem_eval.1 ab with ab b0
state_before: case intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝ : b₁ ∈ eval f₁ a₁
ab : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂
state_after: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂
tactic: rcases tr_reaches H aa ab with ⟨b₂, bb, ab⟩
state_before: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
⊢ ∃ b₂, tr b₁ b₂ ∧ b₂ ∈ eval f₂ a₂
state_after: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
⊢ f₂ b₂ = none
tactic: refine ⟨_, bb, mem_eval.2 ⟨ab, ?_⟩⟩
state_before: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
⊢ f₂ b₂ = none
state_after: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
this :
  match f₁ b₁ with
  | some b₁ => ∃ b₂_1, tr b₁ b₂_1 ∧ Reaches₁ f₂ b₂ b₂_1
  | none => f₂ b₂ = none
⊢ f₂ b₂ = none
tactic: have := H bb
state_before: case intro.intro.intro
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ b₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
ab✝¹ : b₁ ∈ eval f₁ a₁
ab✝ : Reaches f₁ a₁ b₁
b0 : f₁ b₁ = none
b₂ : σ₂
bb : tr b₁ b₂
ab : Reaches f₂ a₂ b₂
this :
  match f₁ b₁ with
  | some b₁ => ∃ b₂_1, tr b₁ b₂_1 ∧ Reaches₁ f₂ b₂ b₂_1
  | none => f₂ b₂ = none
⊢ f₂ b₂ = none
state_after: no goals
tactic: rwa [b0] at this
Theorem: Nat.card_prod
File: Mathlib/SetTheory/Cardinal/Finite.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
α : Type u_3
β : Type u_4
⊢ Nat.card (α × β) = Nat.card α * Nat.card β
state_after: no goals
tactic: simp only [Nat.card, mk_prod, toNat_mul, toNat_lift]
Theorem: Finset.exists_mem_insert
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
a : α
s : Finset α
p : α → Prop
⊢ (∃ x ∈ insert a s, p x) ↔ p a ∨ ∃ x ∈ s, p x
state_after: no goals
tactic: simp only [mem_insert, or_and_right, exists_or, exists_eq_left]
Theorem: EReal.preimage_coe_Icc
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : ℝ
⊢ Real.toEReal ⁻¹' Icc ↑x ↑y = Icc x y
state_after: x y : ℝ
⊢ Real.toEReal ⁻¹' (Ici ↑x ∩ Iic ↑y) = Ici x ∩ Iic y
tactic: simp_rw [← Ici_inter_Iic]
state_before: x y : ℝ
⊢ Real.toEReal ⁻¹' (Ici ↑x ∩ Iic ↑y) = Ici x ∩ Iic y
state_after: no goals
tactic: simp
Theorem: Cycle.lists_nil
File: Mathlib/Data/List/Cycle.lean

Proof steps:
state_before: α : Type u_1
⊢ nil.lists = ↑[[]]
state_after: no goals
tactic: rw [nil, lists_coe, cyclicPermutations_nil]
Theorem: Basis.addHaar_reindex
File: Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : Fintype ι
inst✝⁶ : Fintype ι'
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ E
inst✝² : NormedSpace ℝ F
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
b : Basis ι ℝ E
e : ι ≃ ι'
⊢ (b.reindex e).addHaar = b.addHaar
state_after: no goals
tactic: rw [Basis.addHaar, b.parallelepiped_reindex e, ← Basis.addHaar]