ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ContextFreeRule.Rewrites.append_right
File: Mathlib/Computability/ContextFreeGrammar.lean

Proof steps:
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
v w : List (Symbol T N)
hvw : r.Rewrites v w
p : List (Symbol T N)
⊢ r.Rewrites (v ++ p) (w ++ p)
state_after: T : Type uT
N : Type uN
r : ContextFreeRule T N
v w : List (Symbol T N)
hvw : ∃ p q, v = p ++ [Symbol.nonterminal r.input] ++ q ∧ w = p ++ r.output ++ q
p : List (Symbol T N)
⊢ ∃ p_1 q, v ++ p = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ w ++ p = p_1 ++ r.output ++ q
tactic: rw [rewrites_iff] at *
state_before: T : Type uT
N : Type uN
r : ContextFreeRule T N
v w : List (Symbol T N)
hvw : ∃ p q, v = p ++ [Symbol.nonterminal r.input] ++ q ∧ w = p ++ r.output ++ q
p : List (Symbol T N)
⊢ ∃ p_1 q, v ++ p = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ w ++ p = p_1 ++ r.output ++ q
state_after: case intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ ∃ p_1 q, v ++ p = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ w ++ p = p_1 ++ r.output ++ q
tactic: rcases hvw with ⟨x, y, hxy⟩
state_before: case intro.intro
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ ∃ p_1 q, v ++ p = p_1 ++ [Symbol.nonterminal r.input] ++ q ∧ w ++ p = p_1 ++ r.output ++ q
state_after: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ v ++ p = x ++ [Symbol.nonterminal r.input] ++ (y ++ p) ∧ w ++ p = x ++ r.output ++ (y ++ p)
tactic: use x, y ++ p
state_before: case h
T : Type uT
N : Type uN
r : ContextFreeRule T N
v w p x y : List (Symbol T N)
hxy : v = x ++ [Symbol.nonterminal r.input] ++ y ∧ w = x ++ r.output ++ y
⊢ v ++ p = x ++ [Symbol.nonterminal r.input] ++ (y ++ p) ∧ w ++ p = x ++ r.output ++ (y ++ p)
state_after: no goals
tactic: simp_all
Theorem: MeasureTheory.Lp.simpleFunc.coeFn_nonneg
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
E : Type u_4
F : Type u_5
𝕜 : Type u_6
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
G : Type u_7
inst✝ : NormedLatticeAddCommGroup G
f : ↥(simpleFunc G p μ)
⊢ 0 ≤ᶠ[ae μ] ↑↑↑f ↔ 0 ≤ f
state_after: no goals
tactic: rw [← Subtype.coe_le_coe, Lp.coeFn_nonneg, AddSubmonoid.coe_zero]
Theorem: PowerSeries.nat_le_order
File: Mathlib/RingTheory/PowerSeries/Order.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
⊢ ↑n ≤ φ.order
state_after: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
H : ¬↑n ≤ φ.order
⊢ False
tactic: by_contra H
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
H : ¬↑n ≤ φ.order
⊢ False
state_after: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
H : φ.order < ↑n
⊢ False
tactic: rw [not_le] at H
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
H : φ.order < ↑n
⊢ False
state_after: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
H : φ.order < ↑n
this : φ.order.Dom
⊢ False
tactic: have : (order φ).Dom := PartENat.dom_of_le_natCast H.le
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
H : φ.order < ↑n
this : φ.order.Dom
⊢ False
state_after: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
this : φ.order.Dom
H : φ.order.get this < n
⊢ False
tactic: rw [← PartENat.natCast_get this, PartENat.coe_lt_coe] at H
state_before: R : Type u_1
inst✝ : Semiring R
φ✝ φ : R⟦X⟧
n : ℕ
h : ∀ i < n, (coeff R i) φ = 0
this : φ.order.Dom
H : φ.order.get this < n
⊢ False
state_after: no goals
tactic: exact coeff_order this (h _ H)
Theorem: Cardinal.lift_iSup_le_lift_iSup
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
ι : Type v
ι' : Type v'
f : ι → Cardinal.{w}
f' : ι' → Cardinal.{w'}
hf : BddAbove (range f)
hf' : BddAbove (range f')
g : ι → ι'
h : ∀ (i : ι), lift.{w', w} (f i) ≤ lift.{w, w'} (f' (g i))
⊢ lift.{w', w} (iSup f) ≤ lift.{w, w'} (iSup f')
state_after: α β : Type u
ι : Type v
ι' : Type v'
f : ι → Cardinal.{w}
f' : ι' → Cardinal.{w'}
hf : BddAbove (range f)
hf' : BddAbove (range f')
g : ι → ι'
h : ∀ (i : ι), lift.{w', w} (f i) ≤ lift.{w, w'} (f' (g i))
⊢ ⨆ i, lift.{w', w} (f i) ≤ ⨆ i, lift.{w, w'} (f' i)
tactic: rw [lift_iSup hf, lift_iSup hf']
state_before: α β : Type u
ι : Type v
ι' : Type v'
f : ι → Cardinal.{w}
f' : ι' → Cardinal.{w'}
hf : BddAbove (range f)
hf' : BddAbove (range f')
g : ι → ι'
h : ∀ (i : ι), lift.{w', w} (f i) ≤ lift.{w, w'} (f' (g i))
⊢ ⨆ i, lift.{w', w} (f i) ≤ ⨆ i, lift.{w, w'} (f' i)
state_after: no goals
tactic: exact ciSup_mono' (bddAbove_range_comp.{_,_,w} hf' _) fun i => ⟨_, h i⟩
Theorem: Fin.coe_succ_lt_iff_lt
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n✝ m n : ℕ
j k : Fin n
⊢ ↑↑j < ↑↑k ↔ j < k
state_after: no goals
tactic: simp only [coe_eq_castSucc, castSucc_lt_castSucc_iff]
Theorem: Filter.isBounded_ge_map_of_bounded_range
File: Mathlib/Topology/Order/Bounded.lean

Proof steps:
state_before: ι : Type u_1
F : Filter ι
f : ι → ℝ
h : Bornology.IsBounded (range f)
⊢ IsBounded (fun x x_1 => x ≥ x_1) (map f F)
state_after: case intro
ι : Type u_1
F : Filter ι
f : ι → ℝ
h : Bornology.IsBounded (range f)
c : ℝ
hc : c ∈ lowerBounds (range f)
⊢ IsBounded (fun x x_1 => x ≥ x_1) (map f F)
tactic: obtain ⟨c, hc⟩ := h.bddBelow
state_before: case intro
ι : Type u_1
F : Filter ι
f : ι → ℝ
h : Bornology.IsBounded (range f)
c : ℝ
hc : c ∈ lowerBounds (range f)
⊢ IsBounded (fun x x_1 => x ≥ x_1) (map f F)
state_after: no goals
tactic: apply isBoundedUnder_of ⟨c, by simpa [mem_lowerBounds] using hc⟩
Theorem: PiLp.edist_eq_of_L2
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x y : PiLp 2 β
⊢ edist x y = (∑ i : ι, edist (x i) (y i) ^ 2) ^ (1 / 2)
state_after: no goals
tactic: simp [PiLp.edist_eq_sum]
Theorem: AddMonoid.Coprod.induction_on
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
M' : Type u_3
N' : Type u_4
P : Type u_5
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass M'
inst✝¹ : MulOneClass N'
inst✝ : MulOneClass P
C : M ∗ N → Prop
m : M ∗ N
inl : ∀ (m : M), C (Monoid.Coprod.inl m)
inr : ∀ (n : N), C (Monoid.Coprod.inr n)
mul : ∀ (x y : M ∗ N), C x → C y → C (x * y)
⊢ C 1
state_after: no goals
tactic: simpa using inl 1
Theorem: Equiv.Perm.perm_inv_mapsTo_of_mapsTo
File: Mathlib/GroupTheory/Perm/Finite.lean

Proof steps:
state_before: α : Type u
β : Type v
f : Perm α
s : Set α
inst✝ : Finite ↑s
h : Set.MapsTo (⇑f) s s
⊢ Set.MapsTo (⇑f⁻¹) s s
state_after: case intro
α : Type u
β : Type v
f : Perm α
s : Set α
inst✝ : Finite ↑s
h : Set.MapsTo (⇑f) s s
val✝ : Fintype ↑s
⊢ Set.MapsTo (⇑f⁻¹) s s
tactic: cases nonempty_fintype s
state_before: case intro
α : Type u
β : Type v
f : Perm α
s : Set α
inst✝ : Finite ↑s
h : Set.MapsTo (⇑f) s s
val✝ : Fintype ↑s
⊢ Set.MapsTo (⇑f⁻¹) s s
state_after: no goals
tactic: exact fun x hx =>
    Set.mem_toFinset.mp <|
      perm_inv_on_of_perm_on_finset
        (fun a ha => Set.mem_toFinset.mpr (h (Set.mem_toFinset.mp ha)))
        (Set.mem_toFinset.mpr hx)
Theorem: Finsupp.comul_comp_lsingle
File: Mathlib/RingTheory/Coalgebra/Basic.lean

Proof steps:
state_before: R : Type u
ι : Type v
A : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid A
inst✝¹ : Module R A
inst✝ : Coalgebra R A
i : ι
⊢ comul ∘ₗ lsingle i = TensorProduct.map (lsingle i) (lsingle i) ∘ₗ comul
state_after: case h
R : Type u
ι : Type v
A : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid A
inst✝¹ : Module R A
inst✝ : Coalgebra R A
i : ι
x✝ : A
⊢ (comul ∘ₗ lsingle i) x✝ = (TensorProduct.map (lsingle i) (lsingle i) ∘ₗ comul) x✝
tactic: ext
state_before: case h
R : Type u
ι : Type v
A : Type w
inst✝³ : CommSemiring R
inst✝² : AddCommMonoid A
inst✝¹ : Module R A
inst✝ : Coalgebra R A
i : ι
x✝ : A
⊢ (comul ∘ₗ lsingle i) x✝ = (TensorProduct.map (lsingle i) (lsingle i) ∘ₗ comul) x✝
state_after: no goals
tactic: simp
Theorem: WeierstrassCurve.natDegree_preΨ₄_le
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Degree.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ W.preΨ₄.natDegree ≤ 6
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
          C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
        C (W.b₄ * W.b₈ - W.b₆ ^ 2)).natDegree ≤
    6
tactic: rw [preΨ₄]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
⊢ (2 * X ^ 6 + C W.b₂ * X ^ 5 + 5 * C W.b₄ * X ^ 4 + 10 * C W.b₆ * X ^ 3 + 10 * C W.b₈ * X ^ 2 +
          C (W.b₂ * W.b₈ - W.b₄ * W.b₆) * X +
        C (W.b₄ * W.b₈ - W.b₆ ^ 2)).natDegree ≤
    6
state_after: no goals
tactic: compute_degree
Theorem: Ordinal.principal_iff_principal_swap
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: op : Ordinal.{u_1} → Ordinal.{u_1} → Ordinal.{u_1}
o : Ordinal.{u_1}
⊢ Principal op o ↔ Principal (Function.swap op) o
state_after: no goals
tactic: constructor <;> exact fun h a b ha hb => h hb ha
Theorem: Cardinal.lift_succ
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a : Cardinal.{u}
h : lift.{v, u} (succ a) > succ (lift.{v, u} a)
⊢ False
state_after: case intro.intro
α β : Type u
a : Cardinal.{u}
h✝ : lift.{v, u} (succ a) > succ (lift.{v, u} a)
b : Cardinal.{u}
e : lift.{v, u} b = succ (lift.{v, u} a)
h : b < succ a
⊢ False
tactic: rcases lt_lift_iff.1 h with ⟨b, e, h⟩
state_before: case intro.intro
α β : Type u
a : Cardinal.{u}
h✝ : lift.{v, u} (succ a) > succ (lift.{v, u} a)
b : Cardinal.{u}
e : lift.{v, u} b = succ (lift.{v, u} a)
h : b < succ a
⊢ False
state_after: case intro.intro
α β : Type u
a : Cardinal.{u}
h✝ : lift.{v, u} (succ a) > succ (lift.{v, u} a)
b : Cardinal.{u}
e : lift.{v, u} b = succ (lift.{v, u} a)
h : succ (lift.{v, u} a) ≤ lift.{v, u} a
⊢ False
tactic: rw [lt_succ_iff, ← lift_le, e] at h
state_before: case intro.intro
α β : Type u
a : Cardinal.{u}
h✝ : lift.{v, u} (succ a) > succ (lift.{v, u} a)
b : Cardinal.{u}
e : lift.{v, u} b = succ (lift.{v, u} a)
h : succ (lift.{v, u} a) ≤ lift.{v, u} a
⊢ False
state_after: no goals
tactic: exact h.not_lt (lt_succ _)
Theorem: Polynomial.ofFinsupp_pow
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : R[ℕ]
n : ℕ
⊢ { toFinsupp := a ^ n } = { toFinsupp := a } ^ n
state_after: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : R[ℕ]
n : ℕ
⊢ { toFinsupp := a ^ n } = npowRec n { toFinsupp := a }
tactic: change _ = npowRec n _
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
a : R[ℕ]
n : ℕ
⊢ { toFinsupp := a ^ n } = npowRec n { toFinsupp := a }
state_after: no goals
tactic: induction n with
  | zero        => simp [npowRec]
  | succ n n_ih => simp [npowRec, n_ih, pow_succ]
Theorem: Ideal.bot_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ ⊥ * I = ⊥
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Iso.isoCongr_apply
File: Mathlib/CategoryTheory/HomCongr.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X₁ Y₁ X₂ Y₂ : C
f : X₁ ≅ X₂
g : Y₁ ≅ Y₂
⊢ Function.LeftInverse (fun h => f ≪≫ h ≪≫ g.symm) fun h => f.symm ≪≫ h ≪≫ g
state_after: no goals
tactic: aesop_cat
state_before: C : Type u
inst✝ : Category.{v, u} C
X₁ Y₁ X₂ Y₂ : C
f : X₁ ≅ X₂
g : Y₁ ≅ Y₂
⊢ Function.RightInverse (fun h => f ≪≫ h ≪≫ g.symm) fun h => f.symm ≪≫ h ≪≫ g
state_after: no goals
tactic: aesop_cat
Theorem: unitInterval.qRight_zero_left
File: Mathlib/Topology/Homotopy/HSpaces.lean

Proof steps:
state_before: θ : ↑I
⊢ 2 * ↑(0, θ).1 / (1 + ↑(0, θ).2) ≤ 0
state_after: no goals
tactic: simp only [coe_zero, mul_zero, zero_div, le_refl]
Theorem: Filter.eventually_atBot_prod_self'
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : SemilatticeInf α
inst✝ : Nonempty α
p : α × α → Prop
⊢ (∀ᶠ (x : α × α) in atBot, p x) ↔ ∃ a, ∀ k ≤ a, ∀ l ≤ a, p (k, l)
state_after: no goals
tactic: simp only [eventually_atBot_prod_self, forall_cond_comm]
Theorem: nhds_subtype_eq_comap_nhdsWithin
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
inst✝ : TopologicalSpace X
s : Set X
x : { x // x ∈ s }
⊢ 𝓝 x = comap Subtype.val (𝓝[s] ↑x)
state_after: no goals
tactic: rw [nhds_subtype, ← comap_nhdsWithin_range, Subtype.range_val]
Theorem: iSup_eq_dif
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f g s t : ι → α
a✝ b : α
p : Prop
inst✝ : Decidable p
a : p → α
⊢ ⨆ (h : p), a h = if h : p then a h else ⊥
state_after: no goals
tactic: by_cases h : p <;> simp [h]
Theorem: ENNReal.div_eq_one_iff
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hb₀ : b ≠ 0
hb₁ : b ≠ ⊤
h : a / b = 1
⊢ a = b
state_after: no goals
tactic: rw [← (eq_div_iff hb₀ hb₁).mp h.symm, mul_one]
Theorem: LinearMap.stdBasis_eq_pi_diag
File: Mathlib/LinearAlgebra/StdBasis.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
⊢ stdBasis R φ i = pi (diag i)
state_after: case h.h
R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
x : φ i
j : ι
⊢ (stdBasis R φ i) x j = (pi (diag i)) x j
tactic: ext x j
state_before: case h.h
R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
x : φ i
j : ι
⊢ (stdBasis R φ i) x j = (pi (diag i)) x j
state_after: case h.e'_2.h.e'_1
R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
x : φ i
j : ι
⊢ x = id x
tactic: convert (update_apply (R := R) (φ := φ) (ι := ι) 0 x i j _).symm
state_before: case h.e'_2.h.e'_1
R : Type u_1
ι : Type u_2
inst✝³ : Semiring R
φ : ι → Type u_3
inst✝² : (i : ι) → AddCommMonoid (φ i)
inst✝¹ : (i : ι) → Module R (φ i)
inst✝ : DecidableEq ι
i : ι
x : φ i
j : ι
⊢ x = id x
state_after: no goals
tactic: rfl
Theorem: Filter.comap_prod
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 : α → β × γ
b : Filter β
c : Filter γ
⊢ comap f (b ×ˢ c) = comap (Prod.fst ∘ f) b ⊓ comap (Prod.snd ∘ f) c
state_after: no goals
tactic: erw [comap_inf, Filter.comap_comap, Filter.comap_comap]
Theorem: isSimpleGroup_of_prime_card
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

Proof steps:
state_before: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
p : ℕ
hp : Fact (Nat.Prime p)
h : Fintype.card α = p
⊢ IsSimpleGroup α
state_after: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
⊢ IsSimpleGroup α
tactic: subst h
state_before: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
⊢ IsSimpleGroup α
state_after: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
this : Nontrivial α
⊢ IsSimpleGroup α
tactic: have : Nontrivial α := by
    have h' := Nat.Prime.one_lt hp.out
    exact Fintype.one_lt_card_iff_nontrivial.1 h'
state_before: α✝ : Type u
a : α✝
inst✝² : Group α✝
α : Type u
inst✝¹ : Group α
inst✝ : Fintype α
hp : Fact (Nat.Prime (Fintype.card α))
this : Nontrivial α
⊢ IsSimpleGroup α
state_after: no goals
tactic: exact ⟨fun H _ => H.eq_bot_or_eq_top_of_prime_card⟩
Theorem: Nat.card_eq
File: Mathlib/Data/Finite/Card.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0
state_after: case inl
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Finite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0

case inr
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
h✝ : Infinite α
⊢ Nat.card α = if h : Finite α then Fintype.card α else 0
tactic: cases finite_or_infinite α
Theorem: Subsemiring.toNonUnitalSubsemiring_toSubsemiring
File: Mathlib/Algebra/Algebra/Subalgebra/Unitization.lean

Proof steps:
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
S : Subsemiring R
⊢ S.toNonUnitalSubsemiring.toSubsemiring ⋯ = S
state_after: case mk
R : Type u_1
inst✝ : NonAssocSemiring R
toSubmonoid✝ : Submonoid R
add_mem'✝ : ∀ {a b : R}, a ∈ toSubmonoid✝.carrier → b ∈ toSubmonoid✝.carrier → a + b ∈ toSubmonoid✝.carrier
zero_mem'✝ : 0 ∈ toSubmonoid✝.carrier
⊢ { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }.toNonUnitalSubsemiring.toSubsemiring
      ⋯ =
    { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }
tactic: cases S
state_before: case mk
R : Type u_1
inst✝ : NonAssocSemiring R
toSubmonoid✝ : Submonoid R
add_mem'✝ : ∀ {a b : R}, a ∈ toSubmonoid✝.carrier → b ∈ toSubmonoid✝.carrier → a + b ∈ toSubmonoid✝.carrier
zero_mem'✝ : 0 ∈ toSubmonoid✝.carrier
⊢ { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }.toNonUnitalSubsemiring.toSubsemiring
      ⋯ =
    { toSubmonoid := toSubmonoid✝, add_mem' := add_mem'✝, zero_mem' := zero_mem'✝ }
state_after: no goals
tactic: rfl
Theorem: pow_unbounded_of_one_lt
File: Mathlib/Algebra/Order/Archimedean.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
inst✝² : StrictOrderedSemiring α
inst✝¹ : Archimedean α
y : α
inst✝ : ExistsAddOfLE α
x : α
hy1 : 1 < y
⊢ ∃ n, x < y ^ n
state_after: case intro.intro
α : Type u_1
M : Type u_2
inst✝² : StrictOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x z : α
hz : 0 < z
hy1 : 1 < 1 + z
⊢ ∃ n, x < (1 + z) ^ n
tactic: obtain ⟨z, hz, rfl⟩ := exists_pos_add_of_lt' hy1
state_before: case intro.intro
α : Type u_1
M : Type u_2
inst✝² : StrictOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x z : α
hz : 0 < z
hy1 : 1 < 1 + z
⊢ ∃ n, x < (1 + z) ^ n
state_after: case intro.intro
α : Type u_1
M : Type u_2
inst✝² : StrictOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x z : α
hz : 0 < z
hy1 : 1 < 1 + z
⊢ ∃ n, x < (z + 1) ^ n
tactic: rw [add_comm]
state_before: case intro.intro
α : Type u_1
M : Type u_2
inst✝² : StrictOrderedSemiring α
inst✝¹ : Archimedean α
inst✝ : ExistsAddOfLE α
x z : α
hz : 0 < z
hy1 : 1 < 1 + z
⊢ ∃ n, x < (z + 1) ^ n
state_after: no goals
tactic: exact add_one_pow_unbounded_of_pos _ hz
Theorem: CategoryTheory.pullbackShiftFunctorZero_hom_app
File: Mathlib/CategoryTheory/Shift/Pullback.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.7899, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ 0 = φ 0
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝³ : Category.{u_4, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ (shiftFunctorZero (PullbackShift C φ) A).hom.app X =
    (pullbackShiftIso C φ 0 0 ⋯).hom.app X ≫ (shiftFunctorZero C B).hom.app X
state_after: C : Type u_1
inst✝³ : Category.{u_4, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ 𝟙 ((𝟭 (PullbackShift C φ)).obj X) = 𝟙 ((𝟭 C).obj X)
tactic: rw [← cancel_epi ((shiftFunctorZero _ A).inv.app X), Iso.inv_hom_id_app,
    pullbackShiftFunctorZero_inv_app, assoc, Iso.inv_hom_id_app_assoc, Iso.inv_hom_id_app]
state_before: C : Type u_1
inst✝³ : Category.{u_4, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ 𝟙 ((𝟭 (PullbackShift C φ)).obj X) = 𝟙 ((𝟭 C).obj X)
state_after: no goals
tactic: rfl
Theorem: Finset.diag_insert
File: Mathlib/Data/Finset/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Finset α
x : α × α
a : α
⊢ (insert a s).diag = insert (a, a) s.diag
state_after: no goals
tactic: rw [insert_eq, insert_eq, diag_union, diag_singleton]
Theorem: MulAction.orbitRel.Quotient.orbit_eq_orbit_out
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x : Quotient G α
φ : Quotient G α → α
hφ : Function.RightInverse φ Quotient.mk'
⊢ x.orbit = MulAction.orbit G (φ x)
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x : Quotient G α
φ : Quotient G α → α
hφ : Function.RightInverse φ Quotient.mk'
⊢ orbit (Quotient.mk' (φ x)) = MulAction.orbit G (φ x)
tactic: conv_lhs => rw [← hφ x]
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
x : Quotient G α
φ : Quotient G α → α
hφ : Function.RightInverse φ Quotient.mk'
⊢ orbit (Quotient.mk' (φ x)) = MulAction.orbit G (φ x)
state_after: no goals
tactic: rfl
Theorem: AddMonoid.exponent_eq_zero_iff_range_addOrderOf_infinite
File: Mathlib/GroupTheory/Exponent.lean

Proof steps:
state_before: G : Type u
inst✝ : Monoid G
h : ∀ (g : G), 0 < orderOf g
⊢ exponent G = 0 ↔ (Set.range orderOf).Infinite
state_after: G : Type u
inst✝ : Monoid G
h : ∀ (g : G), 0 < orderOf g
this : exponent G ≠ 0 ↔ (Set.range orderOf).Finite
⊢ exponent G = 0 ↔ (Set.range orderOf).Infinite
tactic: have := exponent_ne_zero_iff_range_orderOf_finite h
state_before: G : Type u
inst✝ : Monoid G
h : ∀ (g : G), 0 < orderOf g
this : exponent G ≠ 0 ↔ (Set.range orderOf).Finite
⊢ exponent G = 0 ↔ (Set.range orderOf).Infinite
state_after: no goals
tactic: rwa [Ne, not_iff_comm, Iff.comm] at this
Theorem: SimpleGraph.dist_ne_zero_iff_ne_and_reachable
File: Mathlib/Combinatorics/SimpleGraph/Metric.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
⊢ G.dist u v ≠ 0 ↔ u ≠ v ∧ G.Reachable u v
state_after: V : Type u_1
G : SimpleGraph V
u v w : V
⊢ ¬(u = v ∨ ¬G.Reachable u v) ↔ u ≠ v ∧ G.Reachable u v
tactic: rw [ne_eq, dist_eq_zero_iff_eq_or_not_reachable.not]
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
⊢ ¬(u = v ∨ ¬G.Reachable u v) ↔ u ≠ v ∧ G.Reachable u v
state_after: V : Type u_1
G : SimpleGraph V
u v w : V
⊢ u ≠ v ∧ G.Reachable u v ↔ u ≠ v ∧ G.Reachable u v
tactic: push_neg
state_before: V : Type u_1
G : SimpleGraph V
u v w : V
⊢ u ≠ v ∧ G.Reachable u v ↔ u ≠ v ∧ G.Reachable u v
state_after: no goals
tactic: rfl