ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: DFinsupp.card_pi
File: Mathlib/Data/DFinsupp/Interval.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
f : Π₀ (i : ι), Finset (α i)
⊢ f.pi.card = f.prod fun i => ↑(f i).card
state_after: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
f : Π₀ (i : ι), Finset (α i)
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card
tactic: rw [pi, card_dfinsupp]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝² : (i : ι) → Zero (α i)
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → DecidableEq (α i)
f : Π₀ (i : ι), Finset (α i)
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card
state_after: no goals
tactic: exact Finset.prod_congr rfl fun i _ => by simp only [Pi.natCast_apply, Nat.cast_id]
Theorem: max_sub_min_eq_abs
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Group α
inst✝² : LinearOrder α
a✝¹ b✝¹ : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a✝ b✝ c : α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ max a b / min a b = mabs (b / a)
state_after: no goals
tactic: rw [mabs_div_comm, max_div_min_eq_mabs']
Theorem: MeasureTheory.laverage_eq
File: Mathlib/MeasureTheory/Integral/Average.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
m0 : MeasurableSpace α
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : CompleteSpace E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
μ ν : Measure α
s t : Set α
f✝ g f : α → ℝ≥0∞
⊢ ⨍⁻ (x : α), f x ∂μ = (∫⁻ (x : α), f x ∂μ) / μ univ
state_after: no goals
tactic: rw [laverage_eq', lintegral_smul_measure, ENNReal.div_eq_inv_mul]
Theorem: Mathlib.Tactic.Ring.inv_congr
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a'✝ a₁ a₂ a₃ b✝ b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a a' b : R
x✝¹ : a = a'
x✝ : a'⁻¹ = b
⊢ a⁻¹ = b
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a'✝ a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a' : R
⊢ a'⁻¹ = a'⁻¹
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a'✝ a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a' : R
⊢ a'⁻¹ = a'⁻¹
state_after: no goals
tactic: rfl
Theorem: Set.Icc.abs_sub_addNSMul_le
File: Mathlib/Topology/UnitInterval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
hδ : 0 ≤ δ
t : ↑(Icc a b)
n : ℕ
ht : t ∈ Icc (addNSMul h δ n) (addNSMul h δ (n + 1))
⊢ (fun a_1 => ↑a_1) t ≤ ↑(projIcc a b h ?m.54392)
state_after: no goals
tactic: exact ht.2
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
hδ : 0 ≤ δ
t : ↑(Icc a b)
n : ℕ
ht : t ∈ Icc (addNSMul h δ n) (addNSMul h δ (n + 1))
⊢ |a + (n + 1) • δ - (a + n • δ)| ≤ δ
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
hδ : 0 ≤ δ
t : ↑(Icc a b)
n : ℕ
ht : t ∈ Icc (addNSMul h δ n) (addNSMul h δ (n + 1))
⊢ |δ| ≤ δ
tactic: rw [add_sub_add_comm, sub_self, zero_add, succ_nsmul', add_sub_cancel_right]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
h : a ≤ b
δ : α
hδ : 0 ≤ δ
t : ↑(Icc a b)
n : ℕ
ht : t ∈ Icc (addNSMul h δ n) (addNSMul h δ (n + 1))
⊢ |δ| ≤ δ
state_after: no goals
tactic: exact (abs_eq_self.mpr hδ).le
Theorem: Polynomial.natSepDegree_X_pow_char_pow_sub_C
File: Mathlib/FieldTheory/SeparableDegree.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁵ : Field F
inst✝⁴ : Field E
inst✝³ : Algebra F E
K : Type w
inst✝² : Field K
inst✝¹ : Algebra F K
f : F[X]
q : ℕ
inst✝ : ExpChar F q
n : ℕ
y : F
⊢ (X ^ q ^ n - C y).natSepDegree = 1
state_after: no goals
tactic: rw [← expand_X, ← expand_C (q ^ n), ← map_sub, natSepDegree_expand, natSepDegree_X_sub_C]
Theorem: MeasureTheory.eLpNormEssSup_const_smul
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝⁴ : NormedDivisionRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : Module 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
c : 𝕜
f : α → F
⊢ eLpNormEssSup (c • f) μ = ↑‖c‖₊ * eLpNormEssSup f μ
state_after: no goals
tactic: simp_rw [eLpNormEssSup, Pi.smul_apply, nnnorm_smul, ENNReal.coe_mul, ENNReal.essSup_const_mul]
Theorem: max_le
File: Mathlib/Init/Order/LinearOrder.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
a b c : α
h₁ : a ≤ c
h₂ : b ≤ c
⊢ max a b ≤ c
state_after: no goals
tactic: if h : a ≤ b
  then simp [max_def, if_pos h]; exact h₂
  else simp [max_def, if_neg h]; exact h₁
Theorem: Fin.castPred_lt_iff
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
j : Fin n
i : Fin (n + 1)
hi : i ≠ last n
⊢ i.castPred hi < j ↔ i < j.castSucc
state_after: no goals
tactic: rw [← castSucc_lt_castSucc_iff, castSucc_castPred]
Theorem: Cardinal.toPartENat_apply_of_lt_aleph0
File: Mathlib/SetTheory/Cardinal/PartENat.lean

Proof steps:
state_before: α : Type u
c : Cardinal.{u_1}
h : c < ℵ₀
⊢ toPartENat c = ↑(toNat c)
state_after: case intro
α : Type u
c : ℕ
⊢ toPartENat ↑c = ↑(toNat ↑c)
tactic: lift c to ℕ using h
state_before: case intro
α : Type u
c : ℕ
⊢ toPartENat ↑c = ↑(toNat ↑c)
state_after: no goals
tactic: simp
Theorem: FirstOrder.Language.Hom.realize_term
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
g : M →[L] N
t : L.Term α
v : α → M
⊢ Term.realize (⇑g ∘ v) t = g (Term.realize v t)
state_after: case var
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
g : M →[L] N
v : α → M
a✝ : α
⊢ Term.realize (⇑g ∘ v) (var a✝) = g (Term.realize v (var a✝))

case func
L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
g : M →[L] N
v : α → M
l✝ : ℕ
_f✝ : L.Functions l✝
_ts✝ : Fin l✝ → L.Term α
_ts_ih✝ : ∀ (a : Fin l✝), Term.realize (⇑g ∘ v) (_ts✝ a) = g (Term.realize v (_ts✝ a))
⊢ Term.realize (⇑g ∘ v) (func _f✝ _ts✝) = g (Term.realize v (func _f✝ _ts✝))
tactic: induction t
Theorem: vadd_vsub_assoc
File: Mathlib/Algebra/AddTorsor.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p₁ p₂ : P
⊢ g +ᵥ p₁ -ᵥ p₂ = g + (p₁ -ᵥ p₂)
state_after: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p₁ p₂ : P
⊢ g +ᵥ p₁ -ᵥ p₂ +ᵥ p₂ = g + (p₁ -ᵥ p₂) +ᵥ p₂
tactic: apply vadd_right_cancel p₂
state_before: G : Type u_1
P : Type u_2
inst✝ : AddGroup G
T : AddTorsor G P
g : G
p₁ p₂ : P
⊢ g +ᵥ p₁ -ᵥ p₂ +ᵥ p₂ = g + (p₁ -ᵥ p₂) +ᵥ p₂
state_after: no goals
tactic: rw [vsub_vadd, add_vadd, vsub_vadd]
Theorem: Equiv.prod_assoc_symm_image
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ✝ : Sort w
α : Type u_1
β : Type u_2
γ : Type u_3
s : Set α
t : Set β
u : Set γ
⊢ ⇑(prodAssoc α β γ).symm '' s ×ˢ t ×ˢ u = (s ×ˢ t) ×ˢ u
state_after: no goals
tactic: simpa only [Equiv.image_eq_preimage] using prod_assoc_preimage
Theorem: Polynomial.natDegree_hasseDeriv
File: Mathlib/Algebra/Polynomial/HasseDeriv.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
⊢ ((hasseDeriv n) p).natDegree = p.natDegree - n
state_after: case inl
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : p.natDegree < n
⊢ ((hasseDeriv n) p).natDegree = p.natDegree - n

case inr
R : Type u_1
inst✝¹ : Semiring R
k : ℕ
f : R[X]
inst✝ : NoZeroSMulDivisors ℕ R
p : R[X]
n : ℕ
hn : n ≤ p.natDegree
⊢ ((hasseDeriv n) p).natDegree = p.natDegree - n
tactic: cases' lt_or_le p.natDegree n with hn hn
Theorem: wittStructureInt_rename
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ wittStructureInt p ((rename f) Φ) n = (rename (Prod.map f id)) (wittStructureInt p Φ n)
state_after: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (map (Int.castRingHom ℚ)) (wittStructureInt p ((rename f) Φ) n) =
    (map (Int.castRingHom ℚ)) ((rename (Prod.map f id)) (wittStructureInt p Φ n))
tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (map (Int.castRingHom ℚ)) (wittStructureInt p ((rename f) Φ) n) =
    (map (Int.castRingHom ℚ)) ((rename (Prod.map f id)) (wittStructureInt p Φ n))
state_after: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (bind₁ fun k => (bind₁ ((fun i => (rename (Prod.mk i)) (W_ ℚ k)) ∘ f)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n) =
    (bind₁ fun i => (bind₁ fun i_1 => (rename (Prod.map f id ∘ Prod.mk i_1)) (W_ ℚ i)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n)
tactic: simp only [map_rename, map_wittStructureInt, wittStructureRat, rename_bind₁, rename_rename,
    bind₁_rename]
state_before: case a
p : ℕ
R : Type u_1
idx : Type u_2
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
σ : Type u_3
Φ : MvPolynomial idx ℤ
f : idx → σ
n : ℕ
⊢ (bind₁ fun k => (bind₁ ((fun i => (rename (Prod.mk i)) (W_ ℚ k)) ∘ f)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n) =
    (bind₁ fun i => (bind₁ fun i_1 => (rename (Prod.map f id ∘ Prod.mk i_1)) (W_ ℚ i)) ((map (Int.castRingHom ℚ)) Φ))
      (xInTermsOfW p ℚ n)
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.exists_measurableEmbedding_real
File: Mathlib/MeasureTheory/Constructions/Polish/EmbeddingReal.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
⊢ ∃ f, MeasurableEmbedding f
state_after: case intro.intro.intro
α : Type u_1
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
s : Set ℝ
hs : MeasurableSet s
e : α ≃ᵐ ↑s
⊢ ∃ f, MeasurableEmbedding f
tactic: obtain ⟨s, hs, ⟨e⟩⟩ := exists_subset_real_measurableEquiv α
state_before: case intro.intro.intro
α : Type u_1
inst✝¹ : MeasurableSpace α
inst✝ : StandardBorelSpace α
s : Set ℝ
hs : MeasurableSet s
e : α ≃ᵐ ↑s
⊢ ∃ f, MeasurableEmbedding f
state_after: no goals
tactic: exact ⟨(↑) ∘ e, (MeasurableEmbedding.subtype_coe hs).comp e.measurableEmbedding⟩
Theorem: Sylow.mem_fixedPoints_mul_left_cosets_iff_mem_normalizer
File: Mathlib/GroupTheory/Sylow.lean

Proof steps:
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints (↥H) (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit ↥H ↑x → y = ↑x
n : G
hn : n ∈ H
this : (n⁻¹ * x)⁻¹ * x ∈ H
⊢ x⁻¹ * n * x⁻¹⁻¹ ∈ H
state_after: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints (↥H) (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit ↥H ↑x → y = ↑x
n : G
hn : n ∈ H
this : x⁻¹ * n * x ∈ H
⊢ x⁻¹ * n * x⁻¹⁻¹ ∈ H
tactic: rw [mul_inv_rev, inv_inv] at this
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints (↥H) (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit ↥H ↑x → y = ↑x
n : G
hn : n ∈ H
this : x⁻¹ * n * x ∈ H
⊢ x⁻¹ * n * x⁻¹⁻¹ ∈ H
state_after: case h.e'_4.h.e'_6
G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints (↥H) (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit ↥H ↑x → y = ↑x
n : G
hn : n ∈ H
this : x⁻¹ * n * x ∈ H
⊢ x⁻¹⁻¹ = x
tactic: convert this
state_before: case h.e'_4.h.e'_6
G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ↑x ∈ MulAction.fixedPoints (↥H) (G ⧸ H)
ha : ∀ {y : G ⧸ H}, y ∈ orbit ↥H ↑x → y = ↑x
n : G
hn : n ∈ H
this : x⁻¹ * n * x ∈ H
⊢ x⁻¹⁻¹ = x
state_after: no goals
tactic: rw [inv_inv]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ∀ (n : G), n ∈ H ↔ x * n * x⁻¹ ∈ H
y✝ : G ⧸ H
y : G
hy : Quotient.mk'' y ∈ orbit ↥H ↑x
b : G
hb₁ : b ∈ H
hb₂✝ : (fun m => m • ↑x) ⟨b, hb₁⟩ = Quotient.mk'' y
hb₂ : (b * x)⁻¹ * y ∈ H
⊢ b⁻¹ * (x * (y⁻¹ * x)⁻¹ * x⁻¹) ∈ H
state_after: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ∀ (n : G), n ∈ H ↔ x * n * x⁻¹ ∈ H
y✝ : G ⧸ H
y : G
hy : Quotient.mk'' y ∈ orbit ↥H ↑x
b : G
hb₁ : b ∈ H
hb₂✝ : (fun m => m • ↑x) ⟨b, hb₁⟩ = Quotient.mk'' y
hb₂ : x * ((b * x)⁻¹ * y) * x⁻¹ ∈ H
⊢ b⁻¹ * (x * (y⁻¹ * x)⁻¹ * x⁻¹) ∈ H
tactic: rw [hx] at hb₂
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
H : Subgroup G
inst✝ : Finite ↑↑H
x : G
hx : ∀ (n : G), n ∈ H ↔ x * n * x⁻¹ ∈ H
y✝ : G ⧸ H
y : G
hy : Quotient.mk'' y ∈ orbit ↥H ↑x
b : G
hb₁ : b ∈ H
hb₂✝ : (fun m => m • ↑x) ⟨b, hb₁⟩ = Quotient.mk'' y
hb₂ : x * ((b * x)⁻¹ * y) * x⁻¹ ∈ H
⊢ b⁻¹ * (x * (y⁻¹ * x)⁻¹ * x⁻¹) ∈ H
state_after: no goals
tactic: simpa [mul_inv_rev, mul_assoc] using hb₂
Theorem: Set.image_val_sInter
File: Mathlib/Data/Set/Subset.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
hT : T.Nonempty
⊢ ↑(⋂₀ T) = ⋂₀ {x | ∃ B ∈ T, ↑B = x}
state_after: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
hT : T.Nonempty
⊢ ↑(⋂₀ T) = ⋂ x ∈ T, ↑x
tactic: erw [sInter_image]
state_before: ι : Sort u_1
α : Type u_2
A B C : Set α
D E : Set ↑A
S : Set (Set α)
T : Set (Set ↑A)
s : ι → Set α
t : ι → Set ↑A
hT : T.Nonempty
⊢ ↑(⋂₀ T) = ⋂ x ∈ T, ↑x
state_after: no goals
tactic: rw [sInter_eq_biInter, Subtype.val_injective.injOn.image_biInter_eq hT]
Theorem: IsIntegralCurve.periodic_of_eq
File: Mathlib/Geometry/Manifold/IntegralCurve.lean

Proof steps:
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
H : Type u_2
inst✝⁵ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
x₀ : M
inst✝¹ : T2Space M
a b : ℝ
inst✝ : BoundarylessManifold I M
hγ : IsIntegralCurve γ v
hv : ContMDiff I I.tangent 1 fun x => { proj := x, snd := v x }
heq : γ a = γ b
⊢ Periodic γ (a - b)
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
H : Type u_2
inst✝⁵ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
x₀ : M
inst✝¹ : T2Space M
a b : ℝ
inst✝ : BoundarylessManifold I M
hγ : IsIntegralCurve γ v
hv : ContMDiff I I.tangent 1 fun x => { proj := x, snd := v x }
heq : γ a = γ b
t : ℝ
⊢ γ (t + (a - b)) = γ t
tactic: intro t
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
H : Type u_2
inst✝⁵ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
x₀ : M
inst✝¹ : T2Space M
a b : ℝ
inst✝ : BoundarylessManifold I M
hγ : IsIntegralCurve γ v
hv : ContMDiff I I.tangent 1 fun x => { proj := x, snd := v x }
heq : γ a = γ b
t : ℝ
⊢ γ (t + (a - b)) = γ t
state_after: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
H : Type u_2
inst✝⁵ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
x₀ : M
inst✝¹ : T2Space M
a b : ℝ
inst✝ : BoundarylessManifold I M
hγ : IsIntegralCurve γ v
hv : ContMDiff I I.tangent 1 fun x => { proj := x, snd := v x }
heq : γ a = γ b
t : ℝ
⊢ (γ ∘ fun x => x + (a - b)) b = γ b
tactic: apply congrFun <|
    isIntegralCurve_Ioo_eq_of_contMDiff_boundaryless (t₀ := b) hv (hγ.comp_add _) hγ _
state_before: E : Type u_1
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : CompleteSpace E
H : Type u_2
inst✝⁵ : TopologicalSpace H
I : ModelWithCorners ℝ E H
M : Type u_3
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : SmoothManifoldWithCorners I M
γ γ' : ℝ → M
v : (x : M) → TangentSpace I x
s s' : Set ℝ
t₀ : ℝ
x₀ : M
inst✝¹ : T2Space M
a b : ℝ
inst✝ : BoundarylessManifold I M
hγ : IsIntegralCurve γ v
hv : ContMDiff I I.tangent 1 fun x => { proj := x, snd := v x }
heq : γ a = γ b
t : ℝ
⊢ (γ ∘ fun x => x + (a - b)) b = γ b
state_after: no goals
tactic: rw [comp_apply, add_sub_cancel, heq]
Theorem: Stream'.WSeq.exists_of_mem_map
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
o : Option α
om : o ∈ ⟨g, al⟩
oe : Option.map f o = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
tactic: let ⟨o, om, oe⟩ := Seq.exists_of_mem_map h
state_before: α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
o : Option α
om : o ∈ ⟨g, al⟩
oe : Option.map f o = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: case none
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
om : none ∈ ⟨g, al⟩
oe : Option.map f none = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b

case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
tactic: cases' o with a
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
oe : Option.map f (some a) = some b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
h' : f a = b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
tactic: injection oe with h'
state_before: case some
α : Type u
β : Type v
γ : Type w
f : α → β
b : β
g : Stream' (Option (Option α))
al : g.IsSeq
h : b ∈ map f ⟨g, al⟩
a : α
om : some a ∈ ⟨g, al⟩
h' : f a = b
⊢ ∃ a, a ∈ ⟨g, al⟩ ∧ f a = b
state_after: no goals
tactic: exact ⟨a, om, h'⟩
Theorem: Nat.prime_of_fac_equiv_neg_one
File: Mathlib/NumberTheory/Wilson.lean

Proof steps:
state_before: n : ℕ
h : ↑(n - 1)! = -1
h1 : n ≠ 1
⊢ Prime n
state_after: case inl
h : ↑(0 - 1)! = -1
h1 : 0 ≠ 1
⊢ Prime 0

case inr
n : ℕ
h : ↑(n - 1)! = -1
h1 : n ≠ 1
h0 : n ≠ 0
⊢ Prime n
tactic: rcases eq_or_ne n 0 with (rfl | h0)
state_before: case inr
n : ℕ
h : ↑(n - 1)! = -1
h1 : n ≠ 1
h0 : n ≠ 0
⊢ Prime n
state_after: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
⊢ Prime n
tactic: replace h1 : 1 < n := n.two_le_iff.mpr ⟨h0, h1⟩
state_before: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
⊢ Prime n
state_after: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
⊢ False
tactic: by_contra h2
state_before: case inr
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
⊢ False
state_after: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
⊢ False
tactic: obtain ⟨m, hm1, hm2 : 1 < m, hm3⟩ := exists_dvd_of_not_prime2 h1 h2
state_before: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
⊢ False
state_after: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ False
tactic: have hm : m ∣ (n - 1)! := Nat.dvd_factorial (pos_of_gt hm2) (le_pred_of_lt hm3)
state_before: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ False
state_after: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ n ∣ (n - 1)! + 1
tactic: refine hm2.ne' (Nat.dvd_one.mp ((Nat.dvd_add_right hm).mp (hm1.trans ?_)))
state_before: case inr.intro.intro.intro
n : ℕ
h : ↑(n - 1)! = -1
h0 : n ≠ 0
h1 : 1 < n
h2 : ¬Prime n
m : ℕ
hm1 : m ∣ n
hm2 : 1 < m
hm3 : m < n
hm : m ∣ (n - 1)!
⊢ n ∣ (n - 1)! + 1
state_after: no goals
tactic: rw [← ZMod.natCast_zmod_eq_zero_iff_dvd, cast_add, cast_one, h, add_left_neg]
Theorem: Mathlib.Meta.Positivity.nonneg_of_isNat
File: Mathlib/Tactic/Positivity/Core.lean

Proof steps:
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : OrderedSemiring A
h : NormNum.IsNat e n
⊢ 0 ≤ e
state_after: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : OrderedSemiring A
h : NormNum.IsNat e n
⊢ 0 ≤ ↑n
tactic: rw [NormNum.IsNat.to_eq h rfl]
state_before: u : Level
α : Q(Type u)
zα : Q(Zero «$α»)
pα : Q(PartialOrder «$α»)
A : Type u_1
e : A
n : ℕ
inst✝ : OrderedSemiring A
h : NormNum.IsNat e n
⊢ 0 ≤ ↑n
state_after: no goals
tactic: exact Nat.cast_nonneg n
Theorem: JordanHolderLattice.isMaximal_inf_right_of_isMaximal_sup
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
x y : X
hxz : IsMaximal x (x ⊔ y)
hyz : IsMaximal y (x ⊔ y)
⊢ IsMaximal (x ⊓ y) y
state_after: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
x y : X
hxz : IsMaximal x (x ⊔ y)
hyz : IsMaximal y (x ⊔ y)
⊢ IsMaximal (y ⊓ x) y
tactic: rw [inf_comm]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
x y : X
hxz : IsMaximal x (x ⊔ y)
hyz : IsMaximal y (x ⊔ y)
⊢ IsMaximal (y ⊓ x) y
state_after: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
x y : X
hxz : IsMaximal x (y ⊔ x)
hyz : IsMaximal y (y ⊔ x)
⊢ IsMaximal (y ⊓ x) y
tactic: rw [sup_comm] at hxz hyz
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
x y : X
hxz : IsMaximal x (y ⊔ x)
hyz : IsMaximal y (y ⊔ x)
⊢ IsMaximal (y ⊓ x) y
state_after: no goals
tactic: exact isMaximal_inf_left_of_isMaximal_sup hyz hxz