ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.toUniqueFactorizationMonoid
File: Mathlib/RingTheory/DiscreteValuationRing/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
hR : HasUnitMulPowIrreducibleFactorization R
inst✝ : IsDomain R
p : R := Classical.choose hR
spec : Irreducible (Classical.choose hR) ∧ ∀ {x : R}, x ≠ 0 → ∃ n, Associated (Classical.choose hR ^ n) x :=
  Classical.choose_spec hR
x : R
hx : x ≠ 0
⊢ ∃ f, (∀ b ∈ f, Prime b) ∧ Associated f.prod x
state_after: case h
R : Type u_1
inst✝¹ : CommRing R
hR : HasUnitMulPowIrreducibleFactorization R
inst✝ : IsDomain R
p : R := Classical.choose hR
spec : Irreducible (Classical.choose hR) ∧ ∀ {x : R}, x ≠ 0 → ∃ n, Associated (Classical.choose hR ^ n) x :=
  Classical.choose_spec hR
x : R
hx : x ≠ 0
⊢ (∀ b ∈ Multiset.replicate (Classical.choose ⋯) p, Prime b) ∧
    Associated (Multiset.replicate (Classical.choose ⋯) p).prod x
tactic: use Multiset.replicate (Classical.choose (spec.2 hx)) p
state_before: case h
R : Type u_1
inst✝¹ : CommRing R
hR : HasUnitMulPowIrreducibleFactorization R
inst✝ : IsDomain R
p : R := Classical.choose hR
spec : Irreducible (Classical.choose hR) ∧ ∀ {x : R}, x ≠ 0 → ∃ n, Associated (Classical.choose hR ^ n) x :=
  Classical.choose_spec hR
x : R
hx : x ≠ 0
⊢ (∀ b ∈ Multiset.replicate (Classical.choose ⋯) p, Prime b) ∧
    Associated (Multiset.replicate (Classical.choose ⋯) p).prod x
state_after: case h.left
R : Type u_1
inst✝¹ : CommRing R
hR : HasUnitMulPowIrreducibleFactorization R
inst✝ : IsDomain R
p : R := Classical.choose hR
spec : Irreducible (Classical.choose hR) ∧ ∀ {x : R}, x ≠ 0 → ∃ n, Associated (Classical.choose hR ^ n) x :=
  Classical.choose_spec hR
x : R
hx : x ≠ 0
⊢ ∀ b ∈ Multiset.replicate (Classical.choose ⋯) p, Prime b

case h.right
R : Type u_1
inst✝¹ : CommRing R
hR : HasUnitMulPowIrreducibleFactorization R
inst✝ : IsDomain R
p : R := Classical.choose hR
spec : Irreducible (Classical.choose hR) ∧ ∀ {x : R}, x ≠ 0 → ∃ n, Associated (Classical.choose hR ^ n) x :=
  Classical.choose_spec hR
x : R
hx : x ≠ 0
⊢ Associated (Multiset.replicate (Classical.choose ⋯) p).prod x
tactic: constructor
Theorem: finite_multiples
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m n : ℕ
⊢ (↑(powers a)).Finite ↔ IsOfFinOrder a
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m n : ℕ
h : (↑(powers a)).Finite
⊢ IsOfFinOrder a
tactic: refine ⟨fun h ↦ ?_, IsOfFinOrder.finite_powers⟩
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m n : ℕ
h : (↑(powers a)).Finite
⊢ IsOfFinOrder a
state_after: case intro.intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : (↑(powers a)).Finite
m n : ℕ
hmn : m < n
ha : a ^ m = a ^ n
⊢ IsOfFinOrder a
tactic: obtain ⟨m, n, hmn, ha⟩ := h.exists_lt_map_eq_of_forall_mem (f := fun n : ℕ ↦ a ^ n)
    (fun n ↦ by simp [mem_powers_iff])
state_before: case intro.intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : (↑(powers a)).Finite
m n : ℕ
hmn : m < n
ha : a ^ m = a ^ n
⊢ IsOfFinOrder a
state_after: case intro.intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : (↑(powers a)).Finite
m n : ℕ
hmn : m < n
ha : a ^ m = a ^ n
⊢ a ^ (n - m) = 1
tactic: refine isOfFinOrder_iff_pow_eq_one.2 ⟨n - m, tsub_pos_iff_lt.2 hmn, ?_⟩
state_before: case intro.intro.intro
G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : LeftCancelMonoid G
x y a : G
m✝ n✝ : ℕ
h : (↑(powers a)).Finite
m n : ℕ
hmn : m < n
ha : a ^ m = a ^ n
⊢ a ^ (n - m) = 1
state_after: no goals
tactic: rw [← mul_left_cancel_iff (a := a ^ m), ← pow_add, add_tsub_cancel_of_le hmn.le, ha, mul_one]
Theorem: List.permutations'Aux_eq_permutationsAux2
File: Mathlib/Data/List/Permutation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
t : α
ts : List α
⊢ permutations'Aux t ts = (permutationsAux2 t [] [ts ++ [t]] ts id).2
state_after: case nil
α : Type u_1
β : Type u_2
t : α
⊢ permutations'Aux t [] = (permutationsAux2 t [] [[] ++ [t]] [] id).2

case cons
α : Type u_1
β : Type u_2
t a : α
ts : List α
ih : permutations'Aux t ts = (permutationsAux2 t [] [ts ++ [t]] ts id).2
⊢ permutations'Aux t (a :: ts) = (permutationsAux2 t [] [a :: ts ++ [t]] (a :: ts) id).2
tactic: induction' ts with a ts ih
state_before: case cons
α : Type u_1
β : Type u_2
t a : α
ts : List α
ih : permutations'Aux t ts = (permutationsAux2 t [] [ts ++ [t]] ts id).2
⊢ permutations'Aux t (a :: ts) = (permutationsAux2 t [] [a :: ts ++ [t]] (a :: ts) id).2
state_after: case cons
α : Type u_1
β : Type u_2
t a : α
ts : List α
ih : permutations'Aux t ts = (permutationsAux2 t [] [ts ++ [t]] ts id).2
⊢ map (cons a) (permutationsAux2 t [] [ts ++ [t]] ts id).2 =
    (permutationsAux2 t [] [a :: (ts ++ [t])] ts fun x => a :: x).2
tactic: simp only [permutations'Aux, ih, cons_append, permutationsAux2_snd_cons, append_nil, id_eq,
    cons.injEq, true_and]
state_before: case cons
α : Type u_1
β : Type u_2
t a : α
ts : List α
ih : permutations'Aux t ts = (permutationsAux2 t [] [ts ++ [t]] ts id).2
⊢ map (cons a) (permutationsAux2 t [] [ts ++ [t]] ts id).2 =
    (permutationsAux2 t [] [a :: (ts ++ [t])] ts fun x => a :: x).2
state_after: case cons
α : Type u_1
β : Type u_2
t a : α
ts : List α
ih : permutations'Aux t ts = (permutationsAux2 t [] [ts ++ [t]] ts id).2
⊢ map (cons a) ((permutationsAux2 t [] [] ts id).2 ++ [ts ++ [t]]) =
    (permutationsAux2 t [] [] ts fun x => a :: x).2 ++ [a :: (ts ++ [t])]
tactic: simp (config := { singlePass := true }) only [← permutationsAux2_append]
state_before: case cons
α : Type u_1
β : Type u_2
t a : α
ts : List α
ih : permutations'Aux t ts = (permutationsAux2 t [] [ts ++ [t]] ts id).2
⊢ map (cons a) ((permutationsAux2 t [] [] ts id).2 ++ [ts ++ [t]]) =
    (permutationsAux2 t [] [] ts fun x => a :: x).2 ++ [a :: (ts ++ [t])]
state_after: no goals
tactic: simp [map_permutationsAux2]
Theorem: intervalIntegral.integral_non_aestronglyMeasurable_of_le
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
h : a ≤ b
hf : ¬AEStronglyMeasurable f (μ.restrict (Ioc a b))
⊢ ¬AEStronglyMeasurable f (μ.restrict (Ι a b))
state_after: no goals
tactic: rwa [uIoc_of_le h]
Theorem: NNRat.cast_pos
File: Mathlib/Data/Rat/Cast/Order.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
K : Type u_5
inst✝ : LinearOrderedSemifield K
p q : ℚ≥0
⊢ 0 < ↑q ↔ 0 < q
state_after: no goals
tactic: norm_cast
Theorem: LaurentPolynomial.commute_T
File: Mathlib/Algebra/Polynomial/Laurent.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
f : R[T;T⁻¹]
m : ℤ
a : R
⊢ T n * (C a * T m) = C a * T m * T n
state_after: R : Type u_1
inst✝ : Semiring R
n : ℤ
f : R[T;T⁻¹]
m : ℤ
a : R
⊢ AddMonoidAlgebra.single (n + (0 + m)) (1 * (a * 1)) = AddMonoidAlgebra.single (0 + m + n) (a * 1 * 1)
tactic: rw [T, T, ← single_eq_C, single_mul_single, single_mul_single, single_mul_single]
state_before: R : Type u_1
inst✝ : Semiring R
n : ℤ
f : R[T;T⁻¹]
m : ℤ
a : R
⊢ AddMonoidAlgebra.single (n + (0 + m)) (1 * (a * 1)) = AddMonoidAlgebra.single (0 + m + n) (a * 1 * 1)
state_after: no goals
tactic: simp [add_comm]
Theorem: finprod_one
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
⊢ ∏ᶠ (x : α), 1 = 1
state_after: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
this : (mulSupport fun x => (fun x => 1) x.down) ⊆ ↑∅
⊢ ∏ᶠ (x : α), 1 = 1
tactic: have : (mulSupport fun x : PLift α => (fun _ => 1 : α → M) x.down) ⊆ (∅ : Finset (PLift α)) :=
    fun x h => by simp at h
state_before: G : Type u_1
M : Type u_2
N : Type u_3
α : Sort u_4
β : Sort u_5
ι : Sort u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
this : (mulSupport fun x => (fun x => 1) x.down) ⊆ ↑∅
⊢ ∏ᶠ (x : α), 1 = 1
state_after: no goals
tactic: rw [finprod_eq_prod_plift_of_mulSupport_subset this, Finset.prod_empty]
Theorem: MulAction.not_commute_of_disjoint_movedBy_preimage
File: Mathlib/GroupTheory/GroupAction/FixedPoints.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
inst✝⁵ : Group G
inst✝⁴ : MulAction G α
M : Type u_3
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : FaithfulSMul G α
inst✝ : FaithfulSMul M α
g h : G
ne_one : g ≠ 1
disjoint : Disjoint (fixedBy α g)ᶜ (h • (fixedBy α g)ᶜ)
⊢ ¬Commute g h
state_after: α : Type u_1
G : Type u_2
inst✝⁵ : Group G
inst✝⁴ : MulAction G α
M : Type u_3
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : FaithfulSMul G α
inst✝ : FaithfulSMul M α
g h : G
disjoint : Disjoint (fixedBy α g)ᶜ (h • (fixedBy α g)ᶜ)
comm : Commute g h
⊢ g = 1
tactic: contrapose! ne_one with comm
state_before: α : Type u_1
G : Type u_2
inst✝⁵ : Group G
inst✝⁴ : MulAction G α
M : Type u_3
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : FaithfulSMul G α
inst✝ : FaithfulSMul M α
g h : G
disjoint : Disjoint (fixedBy α g)ᶜ (h • (fixedBy α g)ᶜ)
comm : Commute g h
⊢ g = 1
state_after: no goals
tactic: rwa [movedBy_mem_fixedBy_of_commute comm, disjoint_self, Set.bot_eq_empty, ← Set.compl_univ,
    compl_inj_iff, fixedBy_eq_univ_iff_eq_one] at disjoint
Theorem: Part.sdiff_get_eq
File: Mathlib/Data/Part.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : SDiff α
a b : Part α
hab : (a \ b).Dom
⊢ (a \ b).get hab = a.get ⋯ \ b.get ⋯
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : SDiff α
a b : Part α
hab : (a \ b).Dom
⊢ (a.bind fun y => map (fun x => y \ x) b).get ⋯ = a.get ⋯ \ b.get ⋯
tactic: simp [sdiff_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : SDiff α
a b : Part α
hab : (a \ b).Dom
⊢ (a.bind fun y => map (fun x => y \ x) b).get ⋯ = a.get ⋯ \ b.get ⋯
state_after: no goals
tactic: aesop
Theorem: List.getElem?_set'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
m n : Nat
l : List α
⊢ (l.set m a)[n]? = if m = n then (fun x => a) <$> l[n]? else l[n]?
state_after: no goals
tactic: by_cases m = n <;> simp [*]
Theorem: Turing.TM1.stmts_supportsStmt
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
inst✝ : Inhabited Λ
M : Λ → Stmt₁
S : Finset Λ
q : Stmt₁
ss : Supports M S
⊢ some q ∈ stmts M S → SupportsStmt S q
state_after: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
inst✝ : Inhabited Λ
M : Λ → Stmt₁
S : Finset Λ
q : Stmt₁
ss : Supports M S
⊢ ∀ x ∈ S, q ∈ stmts₁ (M x) → SupportsStmt S q
tactic: simp only [stmts, Finset.mem_insertNone, Finset.mem_biUnion, Option.mem_def, Option.some.injEq,
    forall_eq', exists_imp, and_imp]
state_before: Γ : Type u_1
inst✝¹ : Inhabited Γ
Λ : Type u_2
σ : Type u_3
inst✝ : Inhabited Λ
M : Λ → Stmt₁
S : Finset Λ
q : Stmt₁
ss : Supports M S
⊢ ∀ x ∈ S, q ∈ stmts₁ (M x) → SupportsStmt S q
state_after: no goals
tactic: exact fun l ls h ↦ stmts₁_supportsStmt_mono h (ss.2 _ ls)
Theorem: Matrix.fromBlocks_conjTranspose
File: Mathlib/Data/Matrix/Block.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α : Type u_12
β : Type u_13
inst✝ : Star α
A : Matrix n l α
B : Matrix n m α
C : Matrix o l α
D : Matrix o m α
⊢ (fromBlocks A B C D)ᴴ = fromBlocks Aᴴ Cᴴ Bᴴ Dᴴ
state_after: no goals
tactic: simp only [conjTranspose, fromBlocks_transpose, fromBlocks_map]
Theorem: CategoryTheory.Center.whiskerRight_comm
File: Mathlib/CategoryTheory/Monoidal/Center.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X₁ X₂ : Center C
f : X₁ ⟶ X₂
Y : Center C
U : C
⊢ f.f ▷ Y.fst ▷ U ≫ ((X₂.tensorObj Y).snd.β U).hom = ((X₁.tensorObj Y).snd.β U).hom ≫ U ◁ f.f ▷ Y.fst
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X₁ X₂ : Center C
f : X₁ ⟶ X₂
Y : Center C
U : C
⊢ f.f ▷ Y.fst ▷ U ≫
      (α_ X₂.fst Y.fst U).hom ≫
        X₂.fst ◁ (Y.snd.β U).hom ≫ (α_ X₂.fst U Y.fst).inv ≫ (X₂.snd.β U).hom ▷ Y.fst ≫ (α_ U X₂.fst Y.fst).hom =
    ((α_ X₁.fst Y.fst U).hom ≫
        X₁.fst ◁ (Y.snd.β U).hom ≫ (α_ X₁.fst U Y.fst).inv ≫ (X₁.snd.β U).hom ▷ Y.fst ≫ (α_ U X₁.fst Y.fst).hom) ≫
      U ◁ f.f ▷ Y.fst
tactic: dsimp only [tensorObj_fst, tensorObj_snd_β, Iso.trans_hom, whiskerLeftIso_hom,
    Iso.symm_hom, whiskerRightIso_hom]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : MonoidalCategory C
X₁ X₂ : Center C
f : X₁ ⟶ X₂
Y : Center C
U : C
⊢ f.f ▷ Y.fst ▷ U ≫
      (α_ X₂.fst Y.fst U).hom ≫
        X₂.fst ◁ (Y.snd.β U).hom ≫ (α_ X₂.fst U Y.fst).inv ≫ (X₂.snd.β U).hom ▷ Y.fst ≫ (α_ U X₂.fst Y.fst).hom =
    ((α_ X₁.fst Y.fst U).hom ≫
        X₁.fst ◁ (Y.snd.β U).hom ≫ (α_ X₁.fst U Y.fst).inv ≫ (X₁.snd.β U).hom ▷ Y.fst ≫ (α_ U X₁.fst Y.fst).hom) ≫
      U ◁ f.f ▷ Y.fst
state_after: no goals
tactic: calc
    _ = 𝟙 _ ⊗≫
      (f.f ▷ (Y.fst ⊗ U) ≫ X₂.fst ◁ (HalfBraiding.β Y.snd U).hom) ⊗≫
        (HalfBraiding.β X₂.snd U).hom ▷ Y.fst ⊗≫ 𝟙 _ := by coherence
    _ = 𝟙 _ ⊗≫
      X₁.fst ◁ (HalfBraiding.β Y.snd U).hom ⊗≫
        (f.f ▷ U ≫ (HalfBraiding.β X₂.snd U).hom) ▷ Y.fst ⊗≫ 𝟙 _ := by
      rw [← whisker_exchange]; coherence
    _ = _ := by rw [f.comm]; coherence
Theorem: MeasureTheory.Measure.map_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
f : α → β
⊢ map f 0 = 0
state_after: no goals
tactic: by_cases hf : AEMeasurable f (0 : Measure α) <;> simp [map, hf]
Theorem: continuousAdd_iInf
File: Mathlib/Topology/Algebra/Monoid.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
X : Type u_5
inst✝¹ : TopologicalSpace X
ι' : Sort u_6
inst✝ : Mul M
ts : ι' → TopologicalSpace M
h' : ∀ (i : ι'), ContinuousMul M
⊢ ContinuousMul M
state_after: no goals
tactic: exact continuousMul_sInf (Set.forall_mem_range.mpr h')
Theorem: ProbabilityTheory.Kernel.withDensity_apply'
File: Mathlib/Probability/Kernel/WithDensity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : Kernel α β
f : α → β → ℝ≥0∞
κ : Kernel α β
inst✝ : IsSFiniteKernel κ
hf : Measurable (Function.uncurry f)
a : α
s : Set β
⊢ ((κ.withDensity f) a) s = ∫⁻ (b : β) in s, f a b ∂κ a
state_after: no goals
tactic: rw [Kernel.withDensity_apply κ hf, withDensity_apply' _ s]
Theorem: image_subset_closure_compl_image_compl_of_isOpen
File: Mathlib/Topology/ExtremallyDisconnected.lean

Proof steps:
state_before: X : Type u
inst✝³ : TopologicalSpace X
A D E : Type u
inst✝² : TopologicalSpace A
inst✝¹ : TopologicalSpace D
inst✝ : TopologicalSpace E
ρ : E → A
ρ_cont : Continuous ρ
ρ_surj : Surjective ρ
zorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ
G : Set E
hG : IsOpen G
⊢ ρ '' G ⊆ closure (ρ '' Gᶜ)ᶜ
state_after: case pos
X : Type u
inst✝³ : TopologicalSpace X
A D E : Type u
inst✝² : TopologicalSpace A
inst✝¹ : TopologicalSpace D
inst✝ : TopologicalSpace E
ρ : E → A
ρ_cont : Continuous ρ
ρ_surj : Surjective ρ
zorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ
G : Set E
hG : IsOpen G
G_empty : G = ∅
⊢ ρ '' G ⊆ closure (ρ '' Gᶜ)ᶜ

case neg
X : Type u
inst✝³ : TopologicalSpace X
A D E : Type u
inst✝² : TopologicalSpace A
inst✝¹ : TopologicalSpace D
inst✝ : TopologicalSpace E
ρ : E → A
ρ_cont : Continuous ρ
ρ_surj : Surjective ρ
zorn_subset : ∀ (E₀ : Set E), E₀ ≠ univ → IsClosed E₀ → ρ '' E₀ ≠ univ
G : Set E
hG : IsOpen G
G_empty : ¬G = ∅
⊢ ρ '' G ⊆ closure (ρ '' Gᶜ)ᶜ
tactic: by_cases G_empty : G = ∅
Theorem: Matrix.det_ne_zero_of_sum_col_pos
File: Mathlib/LinearAlgebra/Matrix/ToLinearEquiv.lean

Proof steps:
state_before: n : Type u_1
inst✝² : Fintype n
inst✝¹ : DecidableEq n
S : Type u_2
inst✝ : LinearOrderedCommRing S
A : Matrix n n S
h1 : Pairwise fun i j => A i j < 0
h2 : ∀ (j : n), 0 < ∑ i : n, A i j
⊢ A.det ≠ 0
state_after: case inl
n : Type u_1
inst✝² : Fintype n
inst✝¹ : DecidableEq n
S : Type u_2
inst✝ : LinearOrderedCommRing S
A : Matrix n n S
h1 : Pairwise fun i j => A i j < 0
h2 : ∀ (j : n), 0 < ∑ i : n, A i j
h✝ : IsEmpty n
⊢ A.det ≠ 0

case inr
n : Type u_1
inst✝² : Fintype n
inst✝¹ : DecidableEq n
S : Type u_2
inst✝ : LinearOrderedCommRing S
A : Matrix n n S
h1 : Pairwise fun i j => A i j < 0
h2 : ∀ (j : n), 0 < ∑ i : n, A i j
h✝ : Nonempty n
⊢ A.det ≠ 0
tactic: cases isEmpty_or_nonempty n
Theorem: PNat.sub_le
File: Mathlib/Data/PNat/Basic.lean

Proof steps:
state_before: a b : ℕ+
⊢ a - b ≤ a
state_after: a b : ℕ+
⊢ (if b < a then ↑a - ↑b else 1) ≤ ↑a
tactic: rw [← coe_le_coe, sub_coe]
state_before: a b : ℕ+
⊢ (if b < a then ↑a - ↑b else 1) ≤ ↑a
state_after: case pos
a b : ℕ+
h : b < a
⊢ ↑a - ↑b ≤ ↑a

case neg
a b : ℕ+
h : ¬b < a
⊢ 1 ≤ ↑a
tactic: split_ifs with h
Theorem: IsPrimitiveRoot.prod_one_sub_pow_eq_order
File: Mathlib/RingTheory/RootsOfUnity/Lemmas.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : X ^ (n + 1) - C 1 = ∏ i ∈ range (n + 1), (X - C (μ ^ i * 1))
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
tactic: have := X_pow_sub_C_eq_prod hμ n.zero_lt_succ (one_pow (n + 1))
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : X ^ (n + 1) - C 1 = ∏ i ∈ range (n + 1), (X - C (μ ^ i * 1))
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : (∏ k ∈ range n, (X - C (μ ^ (k + 1) * 1))) * (X - C 1) = (∑ i ∈ range (n + 1), X ^ i) * (X - 1)
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
tactic: rw [C_1, ← mul_geom_sum, prod_range_succ', pow_zero, mul_one, mul_comm, eq_comm] at this
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : (∏ k ∈ range n, (X - C (μ ^ (k + 1) * 1))) * (X - C 1) = (∑ i ∈ range (n + 1), X ^ i) * (X - 1)
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : ∏ k ∈ range n, (X - C (μ ^ (k + 1) * 1)) = ∑ i ∈ range (n + 1), X ^ i
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
tactic: replace this := mul_right_cancel₀ (Polynomial.X_sub_C_ne_zero 1) this
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : ∏ k ∈ range n, (X - C (μ ^ (k + 1) * 1)) = ∑ i ∈ range (n + 1), X ^ i
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : eval 1 (∏ k ∈ range n, (X - C (μ ^ (k + 1) * 1))) = eval 1 (∑ i ∈ range (n + 1), X ^ i)
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
tactic: apply_fun Polynomial.eval 1 at this
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsDomain R
n : ℕ
μ : R
hμ : IsPrimitiveRoot μ (n + 1)
this : eval 1 (∏ k ∈ range n, (X - C (μ ^ (k + 1) * 1))) = eval 1 (∑ i ∈ range (n + 1), X ^ i)
⊢ ∏ k ∈ range n, (1 - μ ^ (k + 1)) = ↑n + 1
state_after: no goals
tactic: simpa only [mul_one, map_pow, eval_prod, eval_sub, eval_X, eval_pow, eval_C, eval_geom_sum,
    one_pow, sum_const, card_range, nsmul_eq_mul, Nat.cast_add, Nat.cast_one] using this
Theorem: CategoryTheory.IsIso.of_epi_section'
File: Mathlib/CategoryTheory/EpiMono.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
hf : SplitEpi f
inst✝ : Epi hf.section_
⊢ hf.section_ ≫ f ≫ hf.section_ = hf.section_
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y : C
f : X ⟶ Y
hf : SplitEpi f
inst✝ : Epi hf.section_
⊢ hf.section_ ≫ f = 𝟙 Y
state_after: no goals
tactic: simp
Theorem: Set.exists_seq_iSup_eq_top_iff_countable
File: Mathlib/Data/Set/Countable.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝ : CompleteLattice α
p : α → Prop
h : ∃ x, p x
⊢ (∃ s, (∀ (n : ℕ), p (s n)) ∧ ⨆ n, s n = ⊤) ↔ ∃ S, S.Countable ∧ (∀ s ∈ S, p s) ∧ sSup S = ⊤
state_after: case mp
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝ : CompleteLattice α
p : α → Prop
h : ∃ x, p x
⊢ (∃ s, (∀ (n : ℕ), p (s n)) ∧ ⨆ n, s n = ⊤) → ∃ S, S.Countable ∧ (∀ s ∈ S, p s) ∧ sSup S = ⊤

case mpr
α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝ : CompleteLattice α
p : α → Prop
h : ∃ x, p x
⊢ (∃ S, S.Countable ∧ (∀ s ∈ S, p s) ∧ sSup S = ⊤) → ∃ s, (∀ (n : ℕ), p (s n)) ∧ ⨆ n, s n = ⊤
tactic: constructor
Theorem: Int.odd_iff_not_even
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n : ℤ
⊢ Odd n ↔ ¬Even n
state_after: no goals
tactic: rw [not_even_iff, odd_iff]
Theorem: _private.Mathlib.Algebra.Order.ToIntervalMod.0.toIxxMod_antisymm
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
⊢ b ≡ a [PMOD p] ∨ c ≡ b [PMOD p] ∨ a ≡ c [PMOD p]
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬b ≡ a [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
tactic: by_contra! h
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬b ≡ a [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
tactic: rw [modEq_comm] at h
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
tactic: rw [← (not_modEq_iff_toIcoMod_eq_toIocMod hp).mp h.2.2] at h₁₂₃
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIcoMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
tactic: rw [← (not_modEq_iff_toIcoMod_eq_toIocMod hp).mp h.1] at h₁₃₂
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIcoMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: no goals
tactic: exact h.2.1 ((toIcoMod_inj _).1 <| h₁₃₂.antisymm h₁₂₃)