ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MonoidAlgebra.lift_of
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

Proof steps:
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝⁶ : CommSemiring k
inst✝⁵ : Monoid G
inst✝⁴ : Monoid H
A : Type u₃
inst✝³ : Semiring A
inst✝² : Algebra k A
B : Type u_3
inst✝¹ : Semiring B
inst✝ : Algebra k B
F : G →* A
x : G
⊢ ((lift k G A) F) ((of k G) x) = F x
state_after: no goals
tactic: simp
Theorem: Real.rpow_intCast_mul
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z✝ : ℝ
n✝ : ℕ
hx : 0 ≤ x
n : ℤ
z : ℝ
⊢ x ^ (↑n * z) = (x ^ n) ^ z
state_after: no goals
tactic: rw [rpow_mul hx, rpow_intCast]
Theorem: MeasureTheory.measurePreserving_mul_prod_inv_right
File: Mathlib/MeasureTheory/Group/Prod.lean

Proof steps:
state_before: G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
⊢ MeasurePreserving (fun z => (z.1 * z.2, z.1⁻¹)) (μ.prod ν) (μ.prod ν)
state_after: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
⊢ (fun z => (z.1 * z.2, z.1⁻¹)) = (fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)
tactic: convert (measurePreserving_prod_div_swap ν μ).comp (measurePreserving_prod_mul_swap_right μ ν)
    using 1
state_before: case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
⊢ (fun z => (z.1 * z.2, z.1⁻¹)) = (fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)
state_after: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
x y : G
⊢ ((x, y).1 * (x, y).2, (x, y).1⁻¹) = ((fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)) (x, y)
tactic: ext1 ⟨x, y⟩
state_before: case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SFinite ν
inst✝³ : SFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : μ.IsMulRightInvariant
inst✝ : ν.IsMulRightInvariant
x y : G
⊢ ((x, y).1 * (x, y).2, (x, y).1⁻¹) = ((fun z => (z.2, z.1 / z.2)) ∘ fun z => (z.2, z.1 * z.2)) (x, y)
state_after: no goals
tactic: simp_rw [Function.comp_apply, div_mul_eq_div_div_swap, div_self', one_div]
Theorem: RingSubgroupsBasis.hasBasis_nhds_zero
File: Mathlib/Topology/Algebra/Nonarchimedean/Bases.lean

Proof steps:
state_before: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
⊢ ∀ (t : Set A), t ∈ 𝓝 0 ↔ ∃ i, True ∧ ↑(B i) ⊆ t
state_after: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
s : Set A
⊢ s ∈ 𝓝 0 ↔ ∃ i, True ∧ ↑(B i) ⊆ s
tactic: intro s
state_before: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
s : Set A
⊢ s ∈ 𝓝 0 ↔ ∃ i, True ∧ ↑(B i) ⊆ s
state_after: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
s : Set A
⊢ (∃ i ∈ RingFilterBasis.toAddGroupFilterBasis, id i ⊆ s) ↔ ∃ i, True ∧ ↑(B i) ⊆ s
tactic: rw [hB.toRingFilterBasis.toAddGroupFilterBasis.nhds_zero_hasBasis.mem_iff]
state_before: A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
s : Set A
⊢ (∃ i ∈ RingFilterBasis.toAddGroupFilterBasis, id i ⊆ s) ↔ ∃ i, True ∧ ↑(B i) ⊆ s
state_after: case mp
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
s : Set A
⊢ (∃ i ∈ RingFilterBasis.toAddGroupFilterBasis, id i ⊆ s) → ∃ i, True ∧ ↑(B i) ⊆ s

case mpr
A : Type u_1
ι : Type u_2
inst✝¹ : Ring A
inst✝ : Nonempty ι
B : ι → AddSubgroup A
hB : RingSubgroupsBasis B
s : Set A
⊢ (∃ i, True ∧ ↑(B i) ⊆ s) → ∃ i ∈ RingFilterBasis.toAddGroupFilterBasis, id i ⊆ s
tactic: constructor
Theorem: Function.extend_add
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Mul γ
f : α → β
g₁ g₂ : α → γ
e₁ e₂ : β → γ
⊢ extend f (g₁ * g₂) (e₁ * e₂) = extend f g₁ e₁ * extend f g₂ e₂
state_after: no goals
tactic: classical
  funext x
  simp only [not_exists, extend_def, Pi.mul_apply, apply_dite₂, dite_eq_ite, ite_self]
Theorem: AlgebraicGeometry.genericPoint_eq_bot_of_affine
File: Mathlib/AlgebraicGeometry/FunctionField.lean

Proof steps:
state_before: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ genericPoint ↑↑(Spec R).toPresheafedSpace = ⊥
state_after: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ IsGenericPoint ⊥ ⊤
tactic: apply (genericPoint_spec (Spec R)).eq
state_before: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ IsGenericPoint ⊥ ⊤
state_after: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ closure {⊥} = ⊤
tactic: rw [isGenericPoint_def]
state_before: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ closure {⊥} = ⊤
state_after: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ PrimeSpectrum.zeroLocus ↑⊥.asIdeal = ⊤
tactic: rw [← PrimeSpectrum.zeroLocus_vanishingIdeal_eq_closure, PrimeSpectrum.vanishingIdeal_singleton]
state_before: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ PrimeSpectrum.zeroLocus ↑⊥.asIdeal = ⊤
state_after: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ PrimeSpectrum.zeroLocus ↑⊥.asIdeal = PrimeSpectrum.zeroLocus {0}
tactic: rw [Set.top_eq_univ, ← PrimeSpectrum.zeroLocus_singleton_zero]
state_before: X : Scheme
R : CommRingCat
inst✝ : IsDomain ↑R
⊢ PrimeSpectrum.zeroLocus ↑⊥.asIdeal = PrimeSpectrum.zeroLocus {0}
state_after: no goals
tactic: rfl
Theorem: groupCohomology.oneCocyclesLequivOfIsTrivial_symm_apply_coe
File: Mathlib/RepresentationTheory/GroupCohomology/LowDegree.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : ↥(oneCocycles A)
⊢ (fun f => ⟨⇑f, ⋯⟩)
      ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
            map_smul' := ⋯ }.toFun
        f) =
    f
state_after: case a.h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : ↥(oneCocycles A)
x✝ : G
⊢ ↑((fun f => ⟨⇑f, ⋯⟩)
          ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
                map_smul' := ⋯ }.toFun
            f))
      x✝ =
    ↑f x✝
tactic: ext
state_before: case a.h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : ↥(oneCocycles A)
x✝ : G
⊢ ↑((fun f => ⟨⇑f, ⋯⟩)
          ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
                map_smul' := ⋯ }.toFun
            f))
      x✝ =
    ↑f x✝
state_after: no goals
tactic: rfl
state_before: k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : Additive G →+ CoeSort.coe A
⊢ { toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
          map_smul' := ⋯ }.toFun
      ((fun f => ⟨⇑f, ⋯⟩) f) =
    f
state_after: case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : Additive G →+ CoeSort.coe A
x✝ : Additive G
⊢ ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
            map_smul' := ⋯ }.toFun
        ((fun f => ⟨⇑f, ⋯⟩) f))
      x✝ =
    f x✝
tactic: ext
state_before: case h
k G : Type u
inst✝¹ : CommRing k
inst✝ : Group G
A : Rep k G
hA : A.IsTrivial
f : Additive G →+ CoeSort.coe A
x✝ : Additive G
⊢ ({ toFun := fun f => { toFun := ↑f ∘ ⇑Additive.toMul, map_zero' := ⋯, map_add' := ⋯ }, map_add' := ⋯,
            map_smul' := ⋯ }.toFun
        ((fun f => ⟨⇑f, ⋯⟩) f))
      x✝ =
    f x✝
state_after: no goals
tactic: rfl
Theorem: Orientation.inner_rightAngleRotation_self
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x : E
⊢ ⟪o.rightAngleRotation x, x⟫_ℝ = 0
state_after: no goals
tactic: simp
Theorem: CharP.false_of_nontrivial_of_char_one
File: Mathlib/Algebra/CharP/Defs.lean

Proof steps:
state_before: R : Type u_1
inst✝² : NonAssocSemiring R
inst✝¹ : Nontrivial R
inst✝ : CharP R 1
⊢ False
state_after: R : Type u_1
inst✝² : NonAssocSemiring R
inst✝¹ : Nontrivial R
inst✝ : CharP R 1
this : Subsingleton R
⊢ False
tactic: have : Subsingleton R := CharOne.subsingleton
state_before: R : Type u_1
inst✝² : NonAssocSemiring R
inst✝¹ : Nontrivial R
inst✝ : CharP R 1
this : Subsingleton R
⊢ False
state_after: no goals
tactic: exact false_of_nontrivial_of_subsingleton R
Theorem: HomologicalComplex.Hom.next_eq
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 C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
i j : ι
w : c.Rel i j
⊢ f.next i = (C₁.xNextIso w).hom ≫ f.f j ≫ (C₂.xNextIso w).inv
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
i : ι
w : c.Rel i (c.next i)
⊢ f.next i = (C₁.xNextIso w).hom ≫ f.f (c.next i) ≫ (C₂.xNextIso w).inv
tactic: obtain rfl := c.next_eq' w
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C C₁ C₂ C₃ : HomologicalComplex V c
f : C₁.Hom C₂
i : ι
w : c.Rel i (c.next i)
⊢ f.next i = (C₁.xNextIso w).hom ≫ f.f (c.next i) ≫ (C₂.xNextIso w).inv
state_after: no goals
tactic: simp only [xNextIso, eqToIso_refl, Iso.refl_hom, Iso.refl_inv, comp_id, id_comp]
Theorem: CategoryTheory.ComposableArrows.isoMk₃_inv
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{?u.256266, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 3
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
⊢ g.map' 0 1 ⋯ ⋯ ≫ app₁.inv = app₀.inv ≫ f.map' 0 1 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₀.hom, ← reassoc_of% w₀, app₁.hom_inv_id,
      comp_id, app₀.hom_inv_id_assoc]
state_before: C : Type u_1
inst✝ : Category.{?u.256266, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 3
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
⊢ g.map' 1 2 ⋯ ⋯ ≫ app₂.inv = app₁.inv ≫ f.map' 1 2 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₁.hom, ← reassoc_of% w₁, app₂.hom_inv_id,
      comp_id, app₁.hom_inv_id_assoc]
state_before: C : Type u_1
inst✝ : Category.{?u.256266, u_1} C
n m : ℕ
F G : ComposableArrows C n
f g : ComposableArrows C 3
app₀ : f.obj' 0 ⋯ ≅ g.obj' 0 ⋯
app₁ : f.obj' 1 ⋯ ≅ g.obj' 1 ⋯
app₂ : f.obj' 2 ⋯ ≅ g.obj' 2 ⋯
app₃ : f.obj' 3 ⋯ ≅ g.obj' 3 ⋯
w₀ : f.map' 0 1 ⋯ ⋯ ≫ app₁.hom = app₀.hom ≫ g.map' 0 1 ⋯ ⋯
w₁ : f.map' 1 2 ⋯ ⋯ ≫ app₂.hom = app₁.hom ≫ g.map' 1 2 ⋯ ⋯
w₂ : f.map' 2 3 ⋯ ⋯ ≫ app₃.hom = app₂.hom ≫ g.map' 2 3 ⋯ ⋯
⊢ g.map' 2 3 ⋯ ⋯ ≫ app₃.inv = app₂.inv ≫ f.map' 2 3 ⋯ ⋯
state_after: no goals
tactic: rw [← cancel_epi app₂.hom, ← reassoc_of% w₂, app₃.hom_inv_id,
      comp_id, app₂.hom_inv_id_assoc]
Theorem: tsub_eq_tsub_min
File: Mathlib/Algebra/Order/Sub/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a✝ b✝ c d a b : α
⊢ a - b = a - min a b
state_after: case inl
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a✝ b✝ c d a b : α
h : a ≤ b
⊢ a - b = a - min a b

case inr
α : Type u_1
inst✝² : CanonicallyLinearOrderedAddCommMonoid α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a✝ b✝ c d a b : α
h : b ≤ a
⊢ a - b = a - min a b
tactic: rcases le_total a b with h | h
Theorem: Stream'.Seq.mem_append_left
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ a ∈ s₁.append s₂
state_after: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ ∀ (b : α) (s' : Seq α), a = b ∨ a ∈ s'.append s₂ → a ∈ (cons b s').append s₂
tactic: apply mem_rec_on h
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
⊢ ∀ (b : α) (s' : Seq α), a = b ∨ a ∈ s'.append s₂ → a ∈ (cons b s').append s₂
state_after: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
b✝ : α
s'✝ : Seq α
a✝ : a = b✝ ∨ a ∈ s'✝.append s₂
⊢ a ∈ (cons b✝ s'✝).append s₂
tactic: intros
state_before: α : Type u
β : Type v
γ : Type w
s₁ s₂ : Seq α
a : α
h : a ∈ s₁
b✝ : α
s'✝ : Seq α
a✝ : a = b✝ ∨ a ∈ s'✝.append s₂
⊢ a ∈ (cons b✝ s'✝).append s₂
state_after: no goals
tactic: simp [*]
Theorem: Matroid.mem_closure_iff_forall_mem_flat
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Matroid α
F X✝ Y : Set α
e : α
X : Set α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ e ∈ M.closure X ↔ ∀ (F : Set α), M.Flat F → X ⊆ F → e ∈ F
state_after: no goals
tactic: simp_rw [M.closure_def' X, mem_sInter, mem_setOf, and_imp]
Theorem: LightProfinite.pullback_snd_eq
File: Mathlib/Topology/Category/LightProfinite/Limits.lean

Proof steps:
state_before: X Y B : LightProfinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g = (pullbackIsoPullback f g).hom ≫ Limits.pullback.snd f g
state_after: X Y B : LightProfinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.snd f g
tactic: dsimp [pullbackIsoPullback]
state_before: X Y B : LightProfinite
f : X ⟶ B
g : Y ⟶ B
⊢ pullback.snd f g =
    ((pullback.isLimit f g).conePointUniqueUpToIso (limit.isLimit (cospan f g))).hom ≫ Limits.pullback.snd f g
state_after: no goals
tactic: simp only [Limits.limit.conePointUniqueUpToIso_hom_comp, pullback.cone_pt, pullback.cone_π]
Theorem: SimpleGraph.cliqueFree_bot
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
⊢ ⊥.CliqueFree n
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
t : Finset α
ht : ⊥.IsNClique n t
⊢ False
tactic: intro t ht
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
t : Finset α
ht : ⊥.IsNClique n t
⊢ False
state_after: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
t : Finset α
ht : ⊥.IsNClique n t
this : 2 ≤ 1
⊢ False
tactic: have := le_trans h (isNClique_bot_iff.1 ht).1
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
m n : ℕ
s : Finset α
h : 2 ≤ n
t : Finset α
ht : ⊥.IsNClique n t
this : 2 ≤ 1
⊢ False
state_after: no goals
tactic: contradiction
Theorem: IsPrimitiveRoot.subOneIntegralPowerBasis_gen_prime
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝² : Field K
inst✝¹ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} ℚ K
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
⊢ Prime hζ.subOneIntegralPowerBasis.gen
state_after: no goals
tactic: simpa only [subOneIntegralPowerBasis_gen] using hζ.zeta_sub_one_prime
Theorem: ContextFreeRule.Rewrites.exists_parts
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
u v : List (Symbol T N)
hyp : r.Rewrites u v
⊢ ∃ p q, u = p ++ [Symbol.nonterminal r.input] ++ q ∧ v = p ++ r.output ++ q
state_after: no goals
tactic: induction hyp with
  | head s =>
    use [], s
    simp
  | cons x _ ih =>
    rcases ih with ⟨p', q', rfl, rfl⟩
    use x :: p', q'
    simp
Theorem: CategoryTheory.Limits.coneOfIsSplitMono_pt
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f g : X ⟶ Y
inst✝ : IsSplitMono f
⊢ f ≫ 𝟙 Y = f ≫ retraction f ≫ f
state_after: no goals
tactic: simp
Theorem: hasFDerivAt_of_restrictScalars
File: Mathlib/Analysis/Calculus/FDeriv/RestrictScalars.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
𝕜' : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NormedAlgebra 𝕜 𝕜'
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜' E
inst✝⁴ : IsScalarTower 𝕜 𝕜' E
F : Type u_4
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
f : E → F
f' : E →L[𝕜'] F
s : Set E
x : E
g' : E →L[𝕜] F
h : HasFDerivAt f g' x
H : restrictScalars 𝕜 f' = g'
⊢ HasFDerivAt f f' x
state_after: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
𝕜' : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NormedAlgebra 𝕜 𝕜'
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜' E
inst✝⁴ : IsScalarTower 𝕜 𝕜' E
F : Type u_4
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
f : E → F
f' : E →L[𝕜'] F
s : Set E
x : E
g' : E →L[𝕜] F
h : HasFDerivAt f (restrictScalars 𝕜 f') x
H : restrictScalars 𝕜 f' = g'
⊢ HasFDerivAt f f' x
tactic: rw [← H] at h
state_before: 𝕜 : Type u_1
inst✝¹⁰ : NontriviallyNormedField 𝕜
𝕜' : Type u_2
inst✝⁹ : NontriviallyNormedField 𝕜'
inst✝⁸ : NormedAlgebra 𝕜 𝕜'
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedSpace 𝕜' E
inst✝⁴ : IsScalarTower 𝕜 𝕜' E
F : Type u_4
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace 𝕜' F
inst✝ : IsScalarTower 𝕜 𝕜' F
f : E → F
f' : E →L[𝕜'] F
s : Set E
x : E
g' : E →L[𝕜] F
h : HasFDerivAt f (restrictScalars 𝕜 f') x
H : restrictScalars 𝕜 f' = g'
⊢ HasFDerivAt f f' x
state_after: no goals
tactic: exact .of_isLittleO h.1
Theorem: tsum_ne_zero_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Order.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
inst✝² : CanonicallyOrderedCommMonoid α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
f : ι → α
a : α
hf : Multipliable f
⊢ ∏' (i : ι), f i ≠ 1 ↔ ∃ x, f x ≠ 1
state_after: no goals
tactic: rw [Ne, tprod_eq_one_iff hf, not_forall]
Theorem: Commute.list_prod_right
File: Mathlib/Algebra/BigOperators/Group/List.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
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a : M
l : List M
y : M
h : ∀ x ∈ l, Commute y x
⊢ Commute y l.prod
state_after: case nil
ι : 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
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a y : M
h : ∀ x ∈ [], Commute y x
⊢ Commute y [].prod

case cons
ι : 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
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l✝ l₁ l₂ : List M
a y z : M
l : List M
IH : (∀ x ∈ l, Commute y x) → Commute y l.prod
h : ∀ x ∈ z :: l, Commute y x
⊢ Commute y (z :: l).prod
tactic: induction' l with z l IH
Theorem: Filter.iInf_neBot_of_directed'
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f✝ g : Filter α
s t : Set α
f : ι → Filter α
inst✝ : Nonempty ι
hd : Directed (fun x x_1 => x ≥ x_1) f
⊢ ¬(iInf f).NeBot → ¬∀ (i : ι), (f i).NeBot
state_after: no goals
tactic: simpa only [not_forall, not_neBot, ← empty_mem_iff_bot,
    mem_iInf_of_directed hd] using id
Theorem: writtenInExtChartAt_chartAt
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
M : Type u_3
H : Type u_4
E' : Type u_5
M' : Type u_6
H' : Type u_7
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : PartialHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
x : M
y : E
h : y ∈ (extChartAt I x).target
⊢ writtenInExtChartAt I I x (↑(chartAt H x)) y = y
state_after: no goals
tactic: simp_all only [mfld_simps]
Theorem: Quiver.Path.reverse_comp
File: Mathlib/Combinatorics/Quiver/Symmetric.lean

Proof steps:
state_before: U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
inst✝ : HasReverse V
a b c : V
p : Path a b
q : Path b c
⊢ (p.comp q).reverse = q.reverse.comp p.reverse
state_after: case nil
U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
inst✝ : HasReverse V
a b c : V
p : Path a b
⊢ (p.comp nil).reverse = nil.reverse.comp p.reverse

case cons
U : Type u_1
V : Type u_2
W : Type u_3
inst✝³ : Quiver U
inst✝² : Quiver V
inst✝¹ : Quiver W
inst✝ : HasReverse V
a b c : V
p : Path a b
b✝ c✝ : V
a✝¹ : Path b b✝
a✝ : b✝ ⟶ c✝
h : (p.comp a✝¹).reverse = a✝¹.reverse.comp p.reverse
⊢ (p.comp (a✝¹.cons a✝)).reverse = (a✝¹.cons a✝).reverse.comp p.reverse
tactic: induction' q with _ _ _ _ h
Theorem: MeasureTheory.Supermartingale.sub_submartingale
File: Mathlib/Probability/Martingale/Basic.lean

Proof steps:
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
hg : Submartingale g ℱ μ
⊢ Supermartingale (f - g) ℱ μ
state_after: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
hg : Submartingale g ℱ μ
⊢ Supermartingale (f + -g) ℱ μ
tactic: rw [sub_eq_add_neg]
state_before: Ω : Type u_1
E : Type u_2
ι : Type u_3
inst✝⁵ : Preorder ι
m0 : MeasurableSpace Ω
μ : Measure Ω
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f g : ι → Ω → E
ℱ : Filtration ι m0
inst✝¹ : Preorder E
inst✝ : CovariantClass E E (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
hf : Supermartingale f ℱ μ
hg : Submartingale g ℱ μ
⊢ Supermartingale (f + -g) ℱ μ
state_after: no goals
tactic: exact hf.add hg.neg
Theorem: PrimeSpectrum.zeroLocus_empty_iff_eq_top
File: Mathlib/RingTheory/PrimeSpectrum.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
I : Ideal R
⊢ zeroLocus ↑I = ∅ ↔ I = ⊤
state_after: case mp
R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
I : Ideal R
⊢ zeroLocus ↑I = ∅ → I = ⊤

case mpr
R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
I : Ideal R
⊢ I = ⊤ → zeroLocus ↑I = ∅
tactic: constructor