ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Fintype.mem_piFinset
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ f ∈ piFinset t ↔ ∀ (a : α), f a ∈ t a
state_after: case mp
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ f ∈ piFinset t → ∀ (a : α), f a ∈ t a

case mpr
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
t : (a : α) → Finset (δ a)
f : (a : α) → δ a
⊢ (∀ (a : α), f a ∈ t a) → f ∈ piFinset t
tactic: constructor
Theorem: Module.annihilator_le_of_mem_support
File: Mathlib/RingTheory/Support.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
hp : p ∈ support R M
⊢ annihilator R M ≤ p.asIdeal
state_after: case intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
hp : p ∈ support R M
m : M
hm : (Submodule.span R {m}).annihilator ≤ p.asIdeal
⊢ annihilator R M ≤ p.asIdeal
tactic: obtain ⟨m, hm⟩ := mem_support_iff_exists_annihilator.mp hp
state_before: case intro
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p : PrimeSpectrum R
hp : p ∈ support R M
m : M
hm : (Submodule.span R {m}).annihilator ≤ p.asIdeal
⊢ annihilator R M ≤ p.asIdeal
state_after: no goals
tactic: exact le_trans ((Submodule.subtype _).annihilator_le_of_injective Subtype.val_injective) hm
Theorem: MeasureTheory.Measure.haar.is_left_invariant_addHaarContent
File: Mathlib/MeasureTheory/Measure/Haar/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
K₀ : PositiveCompacts G
g : G
K : Compacts G
⊢ (fun s => ↑((haarContent K₀).toFun s)) (Compacts.map (fun b => g * b) ⋯ K) = (fun s => ↑((haarContent K₀).toFun s)) K
state_after: no goals
tactic: simpa only [ENNReal.coe_inj, ← NNReal.coe_inj, haarContent_apply] using
    is_left_invariant_chaar g K
Theorem: CategoryTheory.Limits.diagonalObjPullbackFstIso_inv_fst_fst
File: Mathlib/CategoryTheory/Limits/Shapes/Diagonal.lean

Proof steps:
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (diagonalObjPullbackFstIso f g).inv ≫ fst (fst f g) (fst f g) ≫ fst f g = snd (snd g g ≫ g) f
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g (fst f g) ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst g g ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      fst (fst f g) (fst f g) ≫ fst f g =
    snd (snd g g ≫ g) f
tactic: delta diagonalObjPullbackFstIso
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
X✝ Y✝ Z✝ : C
inst✝⁴ : HasPullbacks C
S T : C
f✝ : X✝ ⟶ T
g✝ : Y✝ ⟶ T
i : T ⟶ S
inst✝³ : HasPullback i i
inst✝² : HasPullback f✝ g✝
inst✝¹ : HasPullback (f✝ ≫ i) (g✝ ≫ i)
inst✝ : HasPullback (diagonal i) (map (f✝ ≫ i) (g✝ ≫ i) i i f✝ g✝ (𝟙 S) ⋯ ⋯)
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackRightPullbackFstIso f g (fst f g) ≪≫
          congrHom ⋯ ⋯ ≪≫ pullbackAssoc f g g g ≪≫ pullbackSymmetry f (fst g g ≫ g) ≪≫ congrHom ⋯ ⋯).inv ≫
      fst (fst f g) (fst f g) ≫ fst f g =
    snd (snd g g ≫ g) f
state_after: no goals
tactic: simp
Theorem: Finset.memberSubfamily_inter
File: Mathlib/Combinatorics/SetFamily/Compression/Down.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ memberSubfamily a (𝒜 ∩ ℬ) = memberSubfamily a 𝒜 ∩ memberSubfamily a ℬ
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ image (fun s => s.erase a) (filter (fun s => a ∈ s) (𝒜 ∩ ℬ)) =
    image (fun s => s.erase a) (filter (fun s => a ∈ s) 𝒜) ∩ image (fun s => s.erase a) (filter (fun s => a ∈ s) ℬ)
tactic: unfold memberSubfamily
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ image (fun s => s.erase a) (filter (fun s => a ∈ s) (𝒜 ∩ ℬ)) =
    image (fun s => s.erase a) (filter (fun s => a ∈ s) 𝒜) ∩ image (fun s => s.erase a) (filter (fun s => a ∈ s) ℬ)
state_after: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ ↑(filter (fun s => a ∈ s) 𝒜) ∪ ↑(filter (fun s => a ∈ s) ℬ) ⊆ {s | a ∈ s}
tactic: rw [filter_inter_distrib, image_inter_of_injOn _ _ ((erase_injOn' _).mono _)]
state_before: α : Type u_1
inst✝ : DecidableEq α
𝒜✝ ℬ✝ : Finset (Finset α)
s : Finset α
a✝ a : α
𝒜 ℬ : Finset (Finset α)
⊢ ↑(filter (fun s => a ∈ s) 𝒜) ∪ ↑(filter (fun s => a ∈ s) ℬ) ⊆ {s | a ∈ s}
state_after: no goals
tactic: simp
Theorem: PrimeSpectrum.iSup_basicOpen_eq_top_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ι : Type u_1
f : ι → R
⊢ ⨆ i, basicOpen (f i) = ⊤ ↔ Ideal.span (Set.range f) = ⊤
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ι : Type u_1
f : ι → R
⊢ ⋃ i, ↑(basicOpen (f i)) = ↑⊤ ↔ Ideal.span (Set.range f) = ⊤
tactic: rw [SetLike.ext'_iff, Opens.coe_iSup]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ι : Type u_1
f : ι → R
⊢ ⋃ i, ↑(basicOpen (f i)) = ↑⊤ ↔ Ideal.span (Set.range f) = ⊤
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ι : Type u_1
f : ι → R
⊢ (zeroLocus (⋃ i, {f i}))ᶜ = Set.univ ↔ Ideal.span (Set.range f) = ⊤
tactic: simp only [PrimeSpectrum.basicOpen_eq_zeroLocus_compl, Opens.coe_top, ← Set.compl_iInter,
    ← PrimeSpectrum.zeroLocus_iUnion]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ι : Type u_1
f : ι → R
⊢ (zeroLocus (⋃ i, {f i}))ᶜ = Set.univ ↔ Ideal.span (Set.range f) = ⊤
state_after: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ι : Type u_1
f : ι → R
⊢ zeroLocus (⋃ i, {f i}) = Set.univᶜ ↔ zeroLocus ↑(Ideal.span (Set.range f)) = ∅
tactic: rw [← PrimeSpectrum.zeroLocus_empty_iff_eq_top, compl_involutive.eq_iff]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
ι : Type u_1
f : ι → R
⊢ zeroLocus (⋃ i, {f i}) = Set.univᶜ ↔ zeroLocus ↑(Ideal.span (Set.range f)) = ∅
state_after: no goals
tactic: simp only [Set.iUnion_singleton_eq_range,  Set.compl_univ, PrimeSpectrum.zeroLocus_span]
Theorem: NonAssocSemiring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : NonAssocSemiring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : NonAssocSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : NonAssocSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: IsCoprime.of_mul_add_right_right
File: Mathlib/RingTheory/Coprime/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (z * x + y)
⊢ IsCoprime x y
state_after: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + z * x)
⊢ IsCoprime x y
tactic: rw [add_comm] at h
state_before: R : Type u
inst✝ : CommSemiring R
x y z : R
h : IsCoprime x (y + z * x)
⊢ IsCoprime x y
state_after: no goals
tactic: exact h.of_add_mul_right_right
Theorem: one_le_div_iff
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
⊢ 1 ≤ a / b ↔ 0 < b ∧ b ≤ a ∨ b < 0 ∧ a ≤ b
state_after: case inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ 1 ≤ a / b ↔ 0 < b ∧ b ≤ a ∨ b < 0 ∧ a ≤ b

case inr.inl
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a c d : α
n : ℤ
⊢ 1 ≤ a / 0 ↔ 0 < 0 ∧ 0 ≤ a ∨ 0 < 0 ∧ a ≤ 0

case inr.inr
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : 0 < b
⊢ 1 ≤ a / b ↔ 0 < b ∧ b ≤ a ∨ b < 0 ∧ a ≤ b
tactic: rcases lt_trichotomy b 0 with (hb | rfl | hb)
Theorem: isCyclic_iff_exists_ofOrder_eq_natCard
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
⊢ IsCyclic α ↔ ∃ g, orderOf g = Nat.card α
state_after: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
h : ∃ g, orderOf g = Nat.card α
⊢ IsCyclic α
tactic: refine ⟨fun h ↦ h.exists_ofOrder_eq_natCard, fun h ↦ ?_⟩
state_before: α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
h : ∃ g, orderOf g = Nat.card α
⊢ IsCyclic α
state_after: case intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
⊢ IsCyclic α
tactic: obtain ⟨g, hg⟩ := h
state_before: case intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
⊢ IsCyclic α
state_after: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ IsCyclic α
tactic: cases nonempty_fintype α
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ IsCyclic α
state_after: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ orderOf g = Fintype.card α
tactic: refine isCyclic_of_orderOf_eq_card g ?_
state_before: case intro.intro
α : Type u
a : α
inst✝¹ : Group α
inst✝ : Finite α
g : α
hg : orderOf g = Nat.card α
val✝ : Fintype α
⊢ orderOf g = Fintype.card α
state_after: no goals
tactic: simp [hg]
Theorem: norm_smul_of_nonneg
File: Mathlib/Analysis/NormedSpace/Real.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : SeminormedAddCommGroup E
inst✝ : NormedSpace ℝ E
t : ℝ
ht : 0 ≤ t
x : E
⊢ ‖t • x‖ = t * ‖x‖
state_after: no goals
tactic: rw [norm_smul, Real.norm_eq_abs, abs_of_nonneg ht]
Theorem: ModuleCat.Derivation.desc_d
File: Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean

Proof steps:
state_before: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
state_after: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this : Algebra ↑A ↑B := RingHom.toAlgebra f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
tactic: letI := f.toAlgebra
state_before: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this : Algebra ↑A ↑B := RingHom.toAlgebra f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
state_after: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this✝ : Algebra ↑A ↑B := RingHom.toAlgebra f
this : Module ↑A ↑M := Module.compHom (↑M) f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
tactic: letI := Module.compHom M f
state_before: A B : CommRingCat
f : A ⟶ B
M : ModuleCat ↑B
D : M.Derivation f
b : ↑B
this✝ : Algebra ↑A ↑B := RingHom.toAlgebra f
this : Module ↑A ↑M := Module.compHom (↑M) f
⊢ D.desc (CommRingCat.KaehlerDifferential.d b) = D.d b
state_after: no goals
tactic: apply D.liftKaehlerDifferential_comp_D
Theorem: MeasureTheory.IntegrableAtFilter.sub
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 α
l l' : Filter α
f g : α → E
hf : IntegrableAtFilter f l μ
hg : IntegrableAtFilter g l μ
⊢ IntegrableAtFilter (f - g) l μ
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 α
l l' : Filter α
f g : α → E
hf : IntegrableAtFilter f l μ
hg : IntegrableAtFilter g l μ
⊢ IntegrableAtFilter (f + -g) l μ
tactic: rw [sub_eq_add_neg]
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 α
l l' : Filter α
f g : α → E
hf : IntegrableAtFilter f l μ
hg : IntegrableAtFilter g l μ
⊢ IntegrableAtFilter (f + -g) l μ
state_after: no goals
tactic: exact hf.add hg.neg
Theorem: Ordnode.dual_node3L
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ (l.node3L x m y r).dual = r.dual.node3R y m.dual x l.dual
state_after: no goals
tactic: simp [node3L, node3R, dual_node', add_comm]
Theorem: Right.pow_neg
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
n✝ : ℕ
x : M
hn : 0 < n✝
h : x < 1
n : ℕ
x✝ : Nat.succ 0 ≤ n
ih : x ^ n < 1
⊢ x ^ (n + 1) < 1
state_after: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
n✝ : ℕ
x : M
hn : 0 < n✝
h : x < 1
n : ℕ
x✝ : Nat.succ 0 ≤ n
ih : x ^ n < 1
⊢ x ^ n * x < 1
tactic: rw [pow_succ]
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
n✝ : ℕ
x : M
hn : 0 < n✝
h : x < 1
n : ℕ
x✝ : Nat.succ 0 ≤ n
ih : x ^ n < 1
⊢ x ^ n * x < 1
state_after: no goals
tactic: exact Right.mul_lt_one ih h
Theorem: Nat.maxPowDiv.pow_dvd
File: Mathlib/Data/Nat/MaxPowDiv.lean

Proof steps:
state_before: p n : ℕ
⊢ p ^ p.maxPowDiv n ∣ n
state_after: p n : ℕ
⊢ p ^ go 0 p n ∣ n
tactic: dsimp [maxPowDiv]
state_before: p n : ℕ
⊢ p ^ go 0 p n ∣ n
state_after: p n : ℕ
⊢ (p ^ if 1 < p ∧ 0 < n ∧ n % p = 0 then go (0 + 1) p (n / p) else 0) ∣ n
tactic: rw [go]
state_before: p n : ℕ
⊢ (p ^ if 1 < p ∧ 0 < n ∧ n % p = 0 then go (0 + 1) p (n / p) else 0) ∣ n
state_after: case pos
p n : ℕ
h : 1 < p ∧ 0 < n ∧ n % p = 0
⊢ (p ^ if 1 < p ∧ 0 < n ∧ n % p = 0 then go (0 + 1) p (n / p) else 0) ∣ n

case neg
p n : ℕ
h : ¬(1 < p ∧ 0 < n ∧ n % p = 0)
⊢ (p ^ if 1 < p ∧ 0 < n ∧ n % p = 0 then go (0 + 1) p (n / p) else 0) ∣ n
tactic: by_cases h : (1 < p ∧ 0 < n ∧ n % p = 0)
Theorem: HomologicalComplex.XIsoOfEq_inv_naturality
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
n n' : ι
h : n = n'
⊢ φ.f n' ≫ (L.XIsoOfEq h).inv = (K.XIsoOfEq h).inv ≫ φ.f n
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
n : ι
⊢ φ.f n ≫ (L.XIsoOfEq ⋯).inv = (K.XIsoOfEq ⋯).inv ≫ φ.f n
tactic: subst h
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C K L : HomologicalComplex V c
φ : K ⟶ L
n : ι
⊢ φ.f n ≫ (L.XIsoOfEq ⋯).inv = (K.XIsoOfEq ⋯).inv ≫ φ.f n
state_after: no goals
tactic: simp
Theorem: Complex.tan_mul_cos
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℂ
hx : cos x ≠ 0
⊢ tan x * cos x = sin x
state_after: no goals
tactic: rw [tan_eq_sin_div_cos, div_mul_cancel₀ _ hx]
Theorem: CategoryTheory.StructuredArrow.homMk_right
File: Mathlib/CategoryTheory/Comma/StructuredArrow.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ (Functor.fromPUnit S).map (𝟙 f.left) ≫ f'.hom = f.hom ≫ T.map g
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ 𝟙 S ≫ f'.hom = f.hom ≫ T.map g
tactic: dsimp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' Y'' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ 𝟙 S ≫ f'.hom = f.hom ≫ T.map g
state_after: no goals
tactic: simpa using w.symm
Theorem: Pi.induced_restrict
File: Mathlib/Topology/Constructions.lean

Proof steps:
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
ι : Type u_5
π : ι → Type u_6
κ : Type u_7
inst✝ : TopologicalSpace X
T : (i : ι) → TopologicalSpace (π i)
f : X → (i : ι) → π i
S : Set ι
⊢ induced S.restrict topologicalSpace = ⨅ i ∈ S, induced (eval i) (T i)
state_after: no goals
tactic: simp (config := { unfoldPartialApp := true }) [← iInf_subtype'', ← induced_precomp' ((↑) : S → ι),
    restrict]
Theorem: CompleteLattice.sSup_continuous
File: Mathlib/Order/OmegaCompletePartialOrder.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
⊢ Continuous (sSup s)
state_after: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ (sSup s) (ωSup c) = ωSup (c.map (sSup s))
tactic: intro c
state_before: α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ (sSup s) (ωSup c) = ωSup (c.map (sSup s))
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ ∀ (c_1 : β), (sSup s) (ωSup c) ≤ c_1 ↔ ωSup (c.map (sSup s)) ≤ c_1
tactic: apply eq_of_forall_ge_iff
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
⊢ ∀ (c_1 : β), (sSup s) (ωSup c) ≤ c_1 ↔ ωSup (c.map (sSup s)) ≤ c_1
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (sSup s) (ωSup c) ≤ z ↔ ωSup (c.map (sSup s)) ≤ z
tactic: intro z
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (sSup s) (ωSup c) ≤ z ↔ ωSup (c.map (sSup s)) ≤ z
state_after: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (∀ f ∈ s, ∀ (n : ℕ), f (c n) ≤ z) ↔ ∀ (n : ℕ), ∀ f ∈ s, f (c n) ≤ z
tactic: suffices (∀ f ∈ s, ∀ (n), (f : _) (c n) ≤ z) ↔ ∀ (n), ∀ f ∈ s, (f : _) (c n) ≤ z by
    simpa (config := { contextual := true }) [ωSup_le_iff, hs _ _ _] using this
state_before: case H
α : Type u
β : Type v
inst✝¹ : OmegaCompletePartialOrder α
inst✝ : CompleteLattice β
s : Set (α →o β)
hs : ∀ f ∈ s, Continuous f
c : Chain α
z : β
⊢ (∀ f ∈ s, ∀ (n : ℕ), f (c n) ≤ z) ↔ ∀ (n : ℕ), ∀ f ∈ s, f (c n) ≤ z
state_after: no goals
tactic: exact ⟨fun H n f hf => H f hf n, fun H f hf n => H n f hf⟩
Theorem: legendreSym.prime_dvd_of_eq_neg_one
File: Mathlib/NumberTheory/LegendreSymbol/Basic.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : legendreSym p a = -1
x y : ℤ
hxy : ↑p ∣ x ^ 2 - a * y ^ 2
⊢ ↑p ∣ x ∧ ↑p ∣ y
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : legendreSym p a = -1
x y : ℤ
hxy : ↑(x ^ 2 - a * y ^ 2) = 0
⊢ ↑x = 0 ∧ ↑y = 0
tactic: simp_rw [← ZMod.intCast_zmod_eq_zero_iff_dvd] at hxy ⊢
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : legendreSym p a = -1
x y : ℤ
hxy : ↑(x ^ 2 - a * y ^ 2) = 0
⊢ ↑x = 0 ∧ ↑y = 0
state_after: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : legendreSym p a = -1
x y : ℤ
hxy : ↑x ^ 2 - ↑a * ↑y ^ 2 = 0
⊢ ↑x = 0 ∧ ↑y = 0
tactic: push_cast at hxy
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
a : ℤ
h : legendreSym p a = -1
x y : ℤ
hxy : ↑x ^ 2 - ↑a * ↑y ^ 2 = 0
⊢ ↑x = 0 ∧ ↑y = 0
state_after: no goals
tactic: exact eq_zero_mod_of_eq_neg_one h hxy
Theorem: MeasureTheory.smul_ae
File: Mathlib/MeasureTheory/Group/Action.lean

Proof steps:
state_before: G : Type u
M : Type v
α : Type w
s : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
c : G
⊢ c • ae μ = ae μ
state_after: case h
G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
c : G
s : Set α
⊢ s ∈ c • ae μ ↔ s ∈ ae μ
tactic: ext s
state_before: case h
G : Type u
M : Type v
α : Type w
s✝ : Set α
m : MeasurableSpace α
inst✝³ : MeasurableSpace G
inst✝² : Group G
inst✝¹ : MulAction G α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
c : G
s : Set α
⊢ s ∈ c • ae μ ↔ s ∈ ae μ
state_after: no goals
tactic: simp only [mem_smul_filter, preimage_smul, smul_mem_ae]
Theorem: Matrix.trace_mul_comm
File: Mathlib/LinearAlgebra/Matrix/Trace.lean

Proof steps:
state_before: ι : Type u_1
m : Type u_2
n : Type u_3
p : Type u_4
α : Type u_5
R : Type u_6
S : Type u_7
inst✝⁴ : Fintype m
inst✝³ : Fintype n
inst✝² : Fintype p
inst✝¹ : AddCommMonoid R
inst✝ : CommSemigroup R
A : Matrix m n R
B : Matrix n m R
⊢ (A * B).trace = (B * A).trace
state_after: no goals
tactic: rw [← trace_transpose, ← trace_transpose_mul, transpose_mul]
Theorem: Filter.prod_map_right
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f✝ : Filter α
g : Filter β
f : β → γ
F : Filter α
G : Filter β
⊢ F ×ˢ map f G = map (Prod.map id f) (F ×ˢ G)
state_after: no goals
tactic: rw [← prod_map_map_eq', map_id]
Theorem: Polynomial.intCast_coeff_zero
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R✝ : Type u
S : Type v
a b : R✝
n m : ℕ
inst✝¹ : Semiring R✝
p q r : R✝[X]
i : ℤ
R : Type u_1
inst✝ : Ring R
⊢ (↑i).coeff 0 = ↑i
state_after: no goals
tactic: cases i <;> simp
Theorem: Polynomial.support_trinomial
File: Mathlib/Algebra/Polynomial/Coeff.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n✝ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m n : ℕ
hkm : k < m
hmn : m < n
x y z : R
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ (C x * X ^ k + C y * X ^ m + C z * X ^ n).support = {k, m, n}
state_after: R : Type u
S : Type v
a b : R
n✝ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m n : ℕ
hkm : k < m
hmn : m < n
x y z : R
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ {k, m, n} ⊆ (C x * X ^ k + C y * X ^ m + C z * X ^ n).support
tactic: apply subset_antisymm (support_trinomial' k m n x y z)
state_before: R : Type u
S : Type v
a b : R
n✝ m✝ : ℕ
inst✝ : Semiring R
p q r : R[X]
k m n : ℕ
hkm : k < m
hmn : m < n
x y z : R
hx : x ≠ 0
hy : y ≠ 0
hz : z ≠ 0
⊢ {k, m, n} ⊆ (C x * X ^ k + C y * X ^ m + C z * X ^ n).support
state_after: no goals
tactic: simp_rw [insert_subset_iff, singleton_subset_iff, mem_support_iff, coeff_add, coeff_C_mul,
    coeff_X_pow_self, mul_one, coeff_X_pow, if_neg hkm.ne, if_neg hkm.ne', if_neg hmn.ne,
    if_neg hmn.ne', if_neg (hkm.trans hmn).ne, if_neg (hkm.trans hmn).ne', mul_zero, add_zero,
    zero_add, Ne, hx, hy, hz, not_false_eq_true, and_true]