ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ConvexCone.innerDualCone_of_innerDualCone_eq_self
File: Mathlib/Analysis/Convex/Cone/InnerDual.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝² : NormedAddCommGroup H
inst✝¹ : InnerProductSpace ℝ H
s t : Set H
inst✝ : CompleteSpace H
K : ConvexCone ℝ H
ne : (↑K).Nonempty
hc : IsClosed ↑K
⊢ (↑(↑K).innerDualCone).innerDualCone = K
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝² : NormedAddCommGroup H
inst✝¹ : InnerProductSpace ℝ H
s t : Set H
inst✝ : CompleteSpace H
K : ConvexCone ℝ H
ne : (↑K).Nonempty
hc : IsClosed ↑K
x : H
⊢ x ∈ (↑(↑K).innerDualCone).innerDualCone ↔ x ∈ K
tactic: ext x
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝² : NormedAddCommGroup H
inst✝¹ : InnerProductSpace ℝ H
s t : Set H
inst✝ : CompleteSpace H
K : ConvexCone ℝ H
ne : (↑K).Nonempty
hc : IsClosed ↑K
x : H
⊢ x ∈ (↑(↑K).innerDualCone).innerDualCone ↔ x ∈ K
state_after: case h.mp
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝² : NormedAddCommGroup H
inst✝¹ : InnerProductSpace ℝ H
s t : Set H
inst✝ : CompleteSpace H
K : ConvexCone ℝ H
ne : (↑K).Nonempty
hc : IsClosed ↑K
x : H
⊢ x ∈ (↑(↑K).innerDualCone).innerDualCone → x ∈ K

case h.mpr
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝² : NormedAddCommGroup H
inst✝¹ : InnerProductSpace ℝ H
s t : Set H
inst✝ : CompleteSpace H
K : ConvexCone ℝ H
ne : (↑K).Nonempty
hc : IsClosed ↑K
x : H
⊢ x ∈ K → x ∈ (↑(↑K).innerDualCone).innerDualCone
tactic: constructor
Theorem: Int.add_two_le_iff_lt_of_even_sub
File: Mathlib/Algebra/Order/Ring/Int.lean

Proof steps:
state_before: m n : ℤ
even : Even (n - m)
⊢ m + 2 ≤ n ↔ m < n
state_after: m n : ℤ
even : Even (n - m)
⊢ 2 + m ≤ n ↔ m < n
tactic: rw [add_comm]
state_before: m n : ℤ
even : Even (n - m)
⊢ 2 + m ≤ n ↔ m < n
state_after: no goals
tactic: exact le_add_iff_lt_of_dvd_sub (by decide) even.two_dvd
Theorem: MeasureTheory.AEEqFun.le_sup_left
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
⊢ f ≤ f ⊔ g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
⊢ ↑f ≤ᶠ[ae μ] ↑(f ⊔ g)
tactic: rw [← coeFn_le]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
⊢ ↑f ≤ᶠ[ae μ] ↑(f ⊔ g)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊔ g) a✝ = ↑f a✝ ⊔ ↑g a✝
⊢ ↑f a✝ ≤ ↑(f ⊔ g) a✝
tactic: filter_upwards [coeFn_sup f g] with _ ha
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊔ g) a✝ = ↑f a✝ ⊔ ↑g a✝
⊢ ↑f a✝ ≤ ↑(f ⊔ g) a✝
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊔ g) a✝ = ↑f a✝ ⊔ ↑g a✝
⊢ ↑f a✝ ≤ ↑f a✝ ⊔ ↑g a✝
tactic: rw [ha]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁵ : MeasurableSpace α
μ ν : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
inst✝² : TopologicalSpace δ
inst✝¹ : SemilatticeSup β
inst✝ : ContinuousSup β
f g : α →ₘ[μ] β
a✝ : α
ha : ↑(f ⊔ g) a✝ = ↑f a✝ ⊔ ↑g a✝
⊢ ↑f a✝ ≤ ↑f a✝ ⊔ ↑g a✝
state_after: no goals
tactic: exact le_sup_left
Theorem: Algebra.IsAlgebraic.range_eval_eq_rootSet_minpoly_of_splits
File: Mathlib/FieldTheory/Extension.lean

Proof steps:
state_before: F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
⊢ (Set.range fun ψ => ψ x) = (minpoly F x).rootSet L
state_after: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ a ∈ (minpoly F x).rootSet L
tactic: ext a
state_before: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ a ∈ (minpoly F x).rootSet L
state_after: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ (aeval a) (minpoly F x) = 0
tactic: rw [mem_rootSet_of_ne (minpoly.ne_zero (Algebra.IsIntegral.isIntegral x))]
state_before: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
⊢ (a ∈ Set.range fun ψ => ψ x) ↔ (aeval a) (minpoly F x) = 0
state_after: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
x✝ : a ∈ Set.range fun ψ => ψ x
ψ : K →ₐ[F] L
hψ : (fun ψ => ψ x) ψ = a
⊢ (aeval a) (minpoly F x) = 0
tactic: refine ⟨fun ⟨ψ, hψ⟩ ↦ ?_, fun ha ↦ IntermediateField.exists_algHom_of_splits_of_aeval
    (fun x ↦ ⟨Algebra.IsIntegral.isIntegral x, hA x⟩) ha⟩
state_before: case h
F : Type u_1
K : Type u_2
L : Type u_3
inst✝⁵ : Field F
inst✝⁴ : Field K
inst✝³ : Field L
inst✝² : Algebra F L
inst✝¹ : Algebra F K
hA : ∀ (x : K), Splits (algebraMap F L) (minpoly F x)
inst✝ : Algebra.IsAlgebraic F K
x : K
a : L
x✝ : a ∈ Set.range fun ψ => ψ x
ψ : K →ₐ[F] L
hψ : (fun ψ => ψ x) ψ = a
⊢ (aeval a) (minpoly F x) = 0
state_after: no goals
tactic: rw [← hψ, Polynomial.aeval_algHom_apply ψ x, minpoly.aeval, map_zero]
Theorem: SemiconjBy.eq_one_iff
File: Mathlib/Algebra/Group/Semiconj/Basic.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
a x y : G
h : SemiconjBy a x y
⊢ x = 1 ↔ y = 1
state_after: no goals
tactic: rw [← conj_eq_one_iff (a := a) (b := x), h.eq, mul_inv_cancel_right]
Theorem: Stream'.Seq1.join_cons
File: Mathlib/Data/Seq/Seq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ join ((a, Seq.cons b s), S) = (a, (Seq.cons (b, s) S).join)
state_after: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ (match (Seq.cons b s).destruct with
    | none => (a, S.join)
    | some s' => (a, (Seq.cons s' S).join)) =
    (a, (Seq.cons (b, s) S).join)
tactic: dsimp [join]
state_before: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ (match (Seq.cons b s).destruct with
    | none => (a, S.join)
    | some s' => (a, (Seq.cons s' S).join)) =
    (a, (Seq.cons (b, s) S).join)
state_after: no goals
tactic: rw [destruct_cons]
Theorem: AlgebraicGeometry.Scheme.Hom.image_preimage_eq_opensRange_inter
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : Y.Opens
⊢ f ''ᵁ f ⁻¹ᵁ U = f.opensRange ⊓ U
state_after: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : Y.Opens
⊢ ↑(f ''ᵁ f ⁻¹ᵁ U) = ↑(f.opensRange ⊓ U)
tactic: apply Opens.ext
state_before: case h
C : Type u
inst✝ : Category.{v, u} C
X Y : Scheme
f : X.Hom Y
H : IsOpenImmersion f
U : Y.Opens
⊢ ↑(f ''ᵁ f ⁻¹ᵁ U) = ↑(f.opensRange ⊓ U)
state_after: no goals
tactic: simp [Set.image_preimage_eq_range_inter]
Theorem: Nat.cast_pred
File: Mathlib/Data/Int/Cast/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : AddGroupWithOne R
h : 0 < 0
⊢ ↑(0 - 1) = ↑0 - 1
state_after: no goals
tactic: cases h
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
x✝ : 0 < n + 1
⊢ ↑(n + 1 - 1) = ↑(n + 1) - 1
state_after: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
x✝ : 0 < n + 1
⊢ ↑(n + 1 - 1) = ↑n
tactic: rw [cast_succ, add_sub_cancel_right]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
x✝ : 0 < n + 1
⊢ ↑(n + 1 - 1) = ↑n
state_after: no goals
tactic: rfl
Theorem: Real.multiset_prod_map_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x y z : ℝ
ι : Type u_1
s : Multiset ι
f : ι → ℝ
hs : ∀ i ∈ s, 0 ≤ f i
r : ℝ
⊢ (Multiset.map (fun x => f x ^ r) s).prod = (Multiset.map f s).prod ^ r
state_after: case h
w x y z : ℝ
ι : Type u_1
f : ι → ℝ
r : ℝ
l : List ι
hs : ∀ i ∈ ⟦l⟧, 0 ≤ f i
⊢ (Multiset.map (fun x => f x ^ r) ⟦l⟧).prod = (Multiset.map f ⟦l⟧).prod ^ r
tactic: induction' s using Quotient.inductionOn with l
state_before: case h
w x y z : ℝ
ι : Type u_1
f : ι → ℝ
r : ℝ
l : List ι
hs : ∀ i ∈ ⟦l⟧, 0 ≤ f i
⊢ (Multiset.map (fun x => f x ^ r) ⟦l⟧).prod = (Multiset.map f ⟦l⟧).prod ^ r
state_after: no goals
tactic: simpa using Real.list_prod_map_rpow' l f hs r
Theorem: HahnSeries.order_one
File: Mathlib/RingTheory/HahnSeries/Multiplication.lean

Proof steps:
state_before: Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝² : Zero Γ
inst✝¹ : PartialOrder Γ
inst✝ : MulZeroOneClass R
⊢ order 1 = 0
state_after: case inl
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝² : Zero Γ
inst✝¹ : PartialOrder Γ
inst✝ : MulZeroOneClass R
h✝ : Subsingleton R
⊢ order 1 = 0

case inr
Γ : Type u_1
Γ' : Type u_2
R : Type u_3
V : Type u_4
inst✝² : Zero Γ
inst✝¹ : PartialOrder Γ
inst✝ : MulZeroOneClass R
h✝ : Nontrivial R
⊢ order 1 = 0
tactic: cases subsingleton_or_nontrivial R
Theorem: Stream'.WSeq.destruct_flatten
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
⊢ (flatten c).destruct = c >>= destruct
state_after: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
⊢ Computation.IsBisimulation fun c1 c2 => c1 = c2 ∨ ∃ c, c1 = (flatten c).destruct ∧ c2 = c.bind destruct
tactic: refine
    Computation.eq_of_bisim
      (fun c1 c2 => c1 = c2 ∨ ∃ c, c1 = destruct (flatten c) ∧ c2 = Computation.bind c destruct) ?_
      (Or.inr ⟨c, rfl, rfl⟩)
state_before: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
⊢ Computation.IsBisimulation fun c1 c2 => c1 = c2 ∨ ∃ c, c1 = (flatten c).destruct ∧ c2 = c.bind destruct
state_after: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
c1 c2 : Computation (Option (α × WSeq α))
h : c1 = c2 ∨ ∃ c, c1 = (flatten c).destruct ∧ c2 = c.bind destruct
⊢ Computation.BisimO (fun c1 c2 => c1 = c2 ∨ ∃ c, c1 = (flatten c).destruct ∧ c2 = c.bind destruct) c1.destruct
    c2.destruct
tactic: intro c1 c2 h
Theorem: pow_eq_neg_pow_iff
File: Mathlib/Algebra/Order/Ring/Abs.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝ : LinearOrderedRing R
a b : R
n : ℕ
hb : b ≠ 0
he : Even n
this : a ^ n > -b ^ n
⊢ a ^ n = -b ^ n ↔ a = -b ∧ Odd n
state_after: no goals
tactic: simpa [he] using this.ne'
state_before: α : Type u_1
R : Type u_2
inst✝ : LinearOrderedRing R
a b : R
n : ℕ
hb : b ≠ 0
he : Even n
⊢ -b ^ n < 0
state_after: no goals
tactic: simp [he.pow_pos hb]
state_before: α : Type u_1
R : Type u_2
inst✝ : LinearOrderedRing R
a b : R
n : ℕ
hb : b ≠ 0
ho : Odd n
⊢ a ^ n = -b ^ n ↔ a = -b ∧ Odd n
state_after: no goals
tactic: simp only [ho, and_true, ← ho.neg_pow, (ho.strictMono_pow (R := R)).injective.eq_iff]
Theorem: SetTheory.PGame.add_powHalf_succ_self_eq_powHalf
File: Mathlib/SetTheory/Surreal/Dyadic.lean

Proof steps:
state_before: n : ℕ
⊢ powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n
state_after: case h
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n
tactic: induction' n using Nat.strong_induction_on with n hn
state_before: case h
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ powHalf (n + 1) + powHalf (n + 1) ≈ powHalf n
state_after: case h.left.left
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (i : (powHalf (n + 1) + powHalf (n + 1)).LeftMoves), (powHalf (n + 1) + powHalf (n + 1)).moveLeft i ⧏ powHalf n

case h.left.right
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (j : (powHalf n).RightMoves), powHalf (n + 1) + powHalf (n + 1) ⧏ (powHalf n).moveRight j

case h.right.left
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (i : (powHalf n).LeftMoves), (powHalf n).moveLeft i ⧏ powHalf (n + 1) + powHalf (n + 1)

case h.right.right
n : ℕ
hn : ∀ m < n, powHalf (m + 1) + powHalf (m + 1) ≈ powHalf m
⊢ ∀ (j : (powHalf (n + 1) + powHalf (n + 1)).RightMoves), powHalf n ⧏ (powHalf (n + 1) + powHalf (n + 1)).moveRight j
tactic: constructor <;> rw [le_iff_forall_lf] <;> constructor
Theorem: Set.monotoneOn_or_antitoneOn_iff_uIcc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ MonotoneOn f s ∨ AntitoneOn f s ↔ ∀ a ∈ s, ∀ b ∈ s, ∀ c ∈ s, c ∈ [[a, b]] → f c ∈ [[f a, f b]]
state_after: no goals
tactic: simp [monotoneOn_iff_monotone, antitoneOn_iff_antitone, monotone_or_antitone_iff_uIcc,
    mem_uIcc]
Theorem: Polynomial.coeff_pow_mul_natDegree
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
p : R[X]
n : ℕ
⊢ (p ^ n).coeff (n * p.natDegree) = p.leadingCoeff ^ n
state_after: case zero
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
p : R[X]
⊢ (p ^ 0).coeff (0 * p.natDegree) = p.leadingCoeff ^ 0

case succ
R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝¹ p✝ q : R[X]
ι : Type u_1
p : R[X]
i : ℕ
hi : (p ^ i).coeff (i * p.natDegree) = p.leadingCoeff ^ i
⊢ (p ^ (i + 1)).coeff ((i + 1) * p.natDegree) = p.leadingCoeff ^ (i + 1)
tactic: induction' n with i hi
Theorem: _private.Mathlib.GroupTheory.SpecificGroups.Cyclic.0.card_nsmul_eq_zero_eq_addOrderOf_aux
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → (filter (fun a => a ^ n = 1) univ).card ≤ n
a : α
b : ↥(zpowers a)
⊢ ↑b ^ orderOf a = 1
state_after: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → (filter (fun a => a ^ n = 1) univ).card ≤ n
a : α
b : ↥(zpowers a)
i : ℤ
hi : (fun x => a ^ x) i = ↑b
⊢ ↑b ^ orderOf a = 1
tactic: let ⟨i, hi⟩ := b.2
state_before: α : Type u
a✝ : α
inst✝² : Group α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → (filter (fun a => a ^ n = 1) univ).card ≤ n
a : α
b : ↥(zpowers a)
i : ℤ
hi : (fun x => a ^ x) i = ↑b
⊢ ↑b ^ orderOf a = 1
state_after: no goals
tactic: rw [← hi, ← zpow_natCast, ← zpow_mul, mul_comm, zpow_mul, zpow_natCast,
                    pow_orderOf_eq_one, one_zpow]
Theorem: UV.compress_idem
File: Mathlib/Combinatorics/SetFamily/Compression/UV.lean

Proof steps:
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
⊢ compress u v (compress u v a) = compress u v a
state_after: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
⊢ (if
        Disjoint u (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ∧
          v ≤ if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a then
      ((if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ⊔ u) \ v
    else if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) =
    if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a
tactic: unfold compress
state_before: α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
⊢ (if
        Disjoint u (if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ∧
          v ≤ if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a then
      ((if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) ⊔ u) \ v
    else if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a) =
    if Disjoint u a ∧ v ≤ a then (a ⊔ u) \ v else a
state_after: case pos
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
h : Disjoint u a ∧ v ≤ a
h' : Disjoint u ((a ⊔ u) \ v) ∧ v ≤ (a ⊔ u) \ v
⊢ ((a ⊔ u) \ v ⊔ u) \ v = (a ⊔ u) \ v

case neg
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
h : Disjoint u a ∧ v ≤ a
h' : ¬(Disjoint u ((a ⊔ u) \ v) ∧ v ≤ (a ⊔ u) \ v)
⊢ (a ⊔ u) \ v = (a ⊔ u) \ v

case neg
α : Type u_1
inst✝² : GeneralizedBooleanAlgebra α
inst✝¹ : DecidableRel Disjoint
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s : Finset α
u✝ v✝ a✝ b u v a : α
h : ¬(Disjoint u a ∧ v ≤ a)
⊢ a = a
tactic: split_ifs with h h'
Theorem: AddSubgroup.index_ker
File: Mathlib/GroupTheory/Index.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
⊢ f.ker.index = Nat.card ↑(Set.range ⇑f)
state_after: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
⊢ Nat.card ↥f.range = Nat.card ↑(Set.range ⇑f)
tactic: rw [← MonoidHom.comap_bot, index_comap, relindex_bot_left]
state_before: G : Type u_1
G' : Type u_2
inst✝¹ : Group G
inst✝ : Group G'
H K L : Subgroup G
f : G →* G'
⊢ Nat.card ↥f.range = Nat.card ↑(Set.range ⇑f)
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.lintegral_mul_const''
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
r : ℝ≥0∞
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (a : α), f a * r ∂μ = (∫⁻ (a : α), f a ∂μ) * r
state_after: no goals
tactic: simp_rw [mul_comm, lintegral_const_mul'' r hf]
Theorem: QuaternionGroup.orderOf_a_one
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

Proof steps:
state_before: n : ℕ
⊢ orderOf (a 1) = 2 * n
state_after: case inl
n : ℕ
hn : n = 0
⊢ orderOf (a 1) = 2 * n

case inr
n : ℕ
hn : NeZero n
⊢ orderOf (a 1) = 2 * n
tactic: cases' eq_zero_or_neZero n with hn hn
state_before: case inr
n : ℕ
hn : NeZero n
⊢ orderOf (a 1) = 2 * n
state_after: case inr
n : ℕ
hn : NeZero n
⊢ ¬orderOf (a 1) < 2 * n
tactic: apply (Nat.le_of_dvd
    (NeZero.pos _) (orderOf_dvd_of_pow_eq_one (@a_one_pow_n n))).lt_or_eq.resolve_left
state_before: case inr
n : ℕ
hn : NeZero n
⊢ ¬orderOf (a 1) < 2 * n
state_after: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
⊢ False
tactic: intro h
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
⊢ False
state_after: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h1 : a 1 ^ orderOf (a 1) = 1
⊢ False
tactic: have h1 : (a 1 : QuaternionGroup n) ^ orderOf (a 1) = 1 := pow_orderOf_eq_one _
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h1 : a 1 ^ orderOf (a 1) = 1
⊢ False
state_after: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h1 : a ↑(orderOf (a 1)) = 1
⊢ False
tactic: rw [a_one_pow] at h1
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h1 : a ↑(orderOf (a 1)) = 1
⊢ False
state_after: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h2 : ↑(orderOf (a 1)) = 0
⊢ False
tactic: injection h1 with h2
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h2 : ↑(orderOf (a 1)) = 0
⊢ False
state_after: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h2 : orderOf (a 1) = 0
⊢ False
tactic: rw [← ZMod.val_eq_zero, ZMod.val_natCast, Nat.mod_eq_of_lt h] at h2
state_before: case inr
n : ℕ
hn : NeZero n
h : orderOf (a 1) < 2 * n
h2 : orderOf (a 1) = 0
⊢ False
state_after: no goals
tactic: exact absurd h2.symm (orderOf_pos _).ne
Theorem: Nat.primeFactorsList_one
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: ⊢ primeFactorsList 1 = []
state_after: no goals
tactic: rw [primeFactorsList]
Theorem: Stream'.WSeq.destruct_cons
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
⊢ (cons a s).destruct.destruct = Sum.inl (some (a, s))
state_after: no goals
tactic: simp [destruct, cons, Computation.rmap]
Theorem: Set.neg_op_vadd_set_distrib
File: Mathlib/Data/Set/Pointwise/SMul.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
⊢ (op a • s)⁻¹ = a⁻¹ • s⁻¹
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (op a • s)⁻¹ ↔ x✝ ∈ a⁻¹ • s⁻¹
tactic: ext
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝¹ : Group α
inst✝ : MulAction α β
s✝ t A B : Set β
a✝ : α
x : β
a : α
s : Set α
x✝ : α
⊢ x✝ ∈ (op a • s)⁻¹ ↔ x✝ ∈ a⁻¹ • s⁻¹
state_after: no goals
tactic: simp [mem_smul_set_iff_inv_smul_mem]
Theorem: CategoryTheory.id_nonzero
File: Mathlib/CategoryTheory/Simple.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : HasZeroMorphisms C
X : C
inst✝ : Simple X
⊢ IsIso (𝟙 X)
state_after: no goals
tactic: infer_instance
Theorem: Quotient.finChoice_eq
File: Mathlib/Data/Fintype/Quotient.lean

Proof steps:
state_before: ι : Type u_1
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
α : ι → Type u_2
inst✝ : (i : ι) → Setoid (α i)
f : (i : ι) → α i
⊢ (finChoice fun i => ⟦f i⟧) = ⟦f⟧
state_after: ι : Type u_1
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
α : ι → Type u_2
inst✝ : (i : ι) → Setoid (α i)
f : (i : ι) → α i
⊢ (Quotient.recOn Finset.univ.val (fun l => finChoiceAux l fun i x => ⟦f i⟧) ⋯).liftOn (fun f => ⟦fun i => f i ⋯⟧) ⋯ =
    ⟦f⟧
tactic: dsimp only [Quotient.finChoice]
state_before: ι : Type u_1
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
α : ι → Type u_2
inst✝ : (i : ι) → Setoid (α i)
f : (i : ι) → α i
⊢ (Quotient.recOn Finset.univ.val (fun l => finChoiceAux l fun i x => ⟦f i⟧) ⋯).liftOn (fun f => ⟦fun i => f i ⋯⟧) ⋯ =
    ⟦f⟧
state_after: ι : Type u_1
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
α : ι → Type u_2
inst✝ : (i : ι) → Setoid (α i)
f : (i : ι) → α i
⊢ ⟦fun i x => f i⟧.liftOn (fun f => ⟦fun i => f i ⋯⟧) ⋯ = ⟦f⟧
tactic: conv_lhs =>
    enter [1]
    tactic =>
      change _ = ⟦fun i _ => f i⟧
      exact Quotient.inductionOn (@Finset.univ ι _).1 fun l => Quotient.finChoiceAux_eq _ _
state_before: ι : Type u_1
inst✝² : DecidableEq ι
inst✝¹ : Fintype ι
α : ι → Type u_2
inst✝ : (i : ι) → Setoid (α i)
f : (i : ι) → α i
⊢ ⟦fun i x => f i⟧.liftOn (fun f => ⟦fun i => f i ⋯⟧) ⋯ = ⟦f⟧
state_after: no goals
tactic: rfl
Theorem: PartENat.withTopEquiv_symm_lt
File: Mathlib/Data/Nat/PartENat.lean

Proof steps:
state_before: x y : ℕ∞
⊢ withTopEquiv.symm x < withTopEquiv.symm y ↔ x < y
state_after: no goals
tactic: simp