tasksource/leandojo huggingface dataset:
Theorem: Function.minimalPeriod_pos_iff_mem_periodicPts
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: simp only [minimalPeriod, dif_neg h, lt_irrefl 0, not_false_iff]
state_before: α : Type u_1
β : Type ?u.21811
f fa : α → α
fb : β → β
x y : α
m n : ℕ
h : ¬x ∈ periodicPts f
⊢ ¬0 < minimalPeriod f x
Theorem: PiLp.aux_uniformity_eq
File: Mathlib/Analysis/NormedSpace/PiLp.lean

tactic: have A : UniformInducing (PiLp.equiv p β) :=
  (antilipschitzWith_equiv_aux p β).uniformInducing
    (lipschitzWith_equiv_aux p β).uniformContinuous
state_before: p : ℝ≥0∞
𝕜 : Type ?u.66094
𝕜' : Type ?u.66097
ι : Type u_1
α : ι → Type ?u.66105
β : ι → Type u_2
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
⊢ 𝓤 (PiLp p β) = 𝓤 ((i : ι) → β i)

tactic: have : (fun x : PiLp p β × PiLp p β => ((PiLp.equiv p β) x.fst, (PiLp.equiv p β) x.snd)) = id :=
  by ext i <;> rfl
state_before: p : ℝ≥0∞
𝕜 : Type ?u.66094
𝕜' : Type ?u.66097
ι : Type u_1
α : ι → Type ?u.66105
β : ι → Type u_2
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
A : UniformInducing ↑(PiLp.equiv p β)
⊢ 𝓤 (PiLp p β) = 𝓤 ((i : ι) → β i)

tactic: rw [← A.comap_uniformity, this, comap_id]
state_before: p : ℝ≥0∞
𝕜 : Type ?u.66094
𝕜' : Type ?u.66097
ι : Type u_1
α : ι → Type ?u.66105
β : ι → Type u_2
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
A : UniformInducing ↑(PiLp.equiv p β)
this : (fun x => (↑(PiLp.equiv p β) x.fst, ↑(PiLp.equiv p β) x.snd)) = id
⊢ 𝓤 (PiLp p β) = 𝓤 ((i : ι) → β i)

tactic: ext i <;> rfl
state_before: p : ℝ≥0∞
𝕜 : Type ?u.66094
𝕜' : Type ?u.66097
ι : Type u_1
α : ι → Type ?u.66105
β : ι → Type u_2
inst✝³ : Fact (1 ≤ p)
inst✝² : (i : ι) → PseudoMetricSpace (α i)
inst✝¹ : (i : ι) → PseudoEMetricSpace (β i)
inst✝ : Fintype ι
A : UniformInducing ↑(PiLp.equiv p β)
⊢ (fun x => (↑(PiLp.equiv p β) x.fst, ↑(PiLp.equiv p β) x.snd)) = id
Theorem: seq_eq_bind_map
File: src/lean/Init/Control/Lawful.lean

tactic: rw [← bind_map]
state_before: m : Type u → Type u_1
α β : Type u
inst✝¹ : Monad m
inst✝ : LawfulMonad m
f : m (α → β)
x : m α
⊢ (Seq.seq f fun x_1 => x) = do
    let x_1 ← f
    x_1 <$> x
Theorem: PEquiv.single_subsingleton_eq_refl
File: Mathlib/Data/PEquiv.lean

tactic: ext (i j)
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b : α
⊢ single a b = PEquiv.refl α

tactic: dsimp [single]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b i j : α
⊢ j ∈ ↑(single a b) i ↔ j ∈ ↑(PEquiv.refl α) i

tactic: rw [if_pos (Subsingleton.elim i a), Subsingleton.elim i j, Subsingleton.elim b j]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
inst✝³ : DecidableEq α
inst✝² : DecidableEq β
inst✝¹ : DecidableEq γ
inst✝ : Subsingleton α
a b i j : α
⊢ (j ∈ if i = a then some b else none) ↔ j ∈ some i
Theorem: MeasureTheory.exists_pair_mem_lattice_not_disjoint_vadd
File: Mathlib/MeasureTheory/Group/GeometryOfNumbers.lean

tactic: contrapose! h
state_before: E : Type u_2
L : Type u_1
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F
hS : NullMeasurableSet s
h : ↑↑μ F < ↑↑μ s
⊢ ∃ x y, x ≠ y ∧ ¬Disjoint (x +ᵥ s) (y +ᵥ s)

tactic: exact ((fund.measure_eq_tsum _).trans (measure_iUnion₀
  (Pairwise.mono h fun i j hij => (hij.mono inf_le_left inf_le_left).aedisjoint)
    fun _ => (hS.vadd _).inter fund.nullMeasurableSet).symm).trans_le
    (measure_mono <| Set.iUnion_subset fun _ => Set.inter_subset_right _ _)
state_before: E : Type u_2
L : Type u_1
inst✝⁶ : MeasurableSpace E
μ : Measure E
F s : Set E
inst✝⁵ : AddCommGroup L
inst✝⁴ : Countable L
inst✝³ : AddAction L E
inst✝² : MeasurableSpace L
inst✝¹ : MeasurableVAdd L E
inst✝ : VAddInvariantMeasure L E μ
fund : IsAddFundamentalDomain L F
hS : NullMeasurableSet s
h : ∀ (x y : L), x ≠ y → Disjoint (x +ᵥ s) (y +ᵥ s)
⊢ ↑↑μ s ≤ ↑↑μ F
Theorem: FormalMultilinearSeries.congr
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

tactic: subst n
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹⁵ : CommRing 𝕜
inst✝¹⁴ : AddCommGroup E
inst✝¹³ : Module 𝕜 E
inst✝¹² : TopologicalSpace E
inst✝¹¹ : TopologicalAddGroup E
inst✝¹⁰ : ContinuousConstSMul 𝕜 E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module 𝕜 F
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalAddGroup F
inst✝⁵ : ContinuousConstSMul 𝕜 F
inst✝⁴ : AddCommGroup G
inst✝³ : Module 𝕜 G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalAddGroup G
inst✝ : ContinuousConstSMul 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
m n : ℕ
v : Fin m → E
w : Fin n → E
h1 : m = n
h2 : ∀ (i : ℕ) (him : i < m) (hin : i < n), v { val := i, isLt := him } = w { val := i, isLt := hin }
⊢ ↑(p m) v = ↑(p n) w

tactic: congr with ⟨i, hi⟩
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹⁵ : CommRing 𝕜
inst✝¹⁴ : AddCommGroup E
inst✝¹³ : Module 𝕜 E
inst✝¹² : TopologicalSpace E
inst✝¹¹ : TopologicalAddGroup E
inst✝¹⁰ : ContinuousConstSMul 𝕜 E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module 𝕜 F
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalAddGroup F
inst✝⁵ : ContinuousConstSMul 𝕜 F
inst✝⁴ : AddCommGroup G
inst✝³ : Module 𝕜 G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalAddGroup G
inst✝ : ContinuousConstSMul 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
m : ℕ
v w : Fin m → E
h2 : ∀ (i : ℕ) (him hin : i < m), v { val := i, isLt := him } = w { val := i, isLt := hin }
⊢ ↑(p m) v = ↑(p m) w

tactic: exact h2 i hi hi
state_before: case h.e_6.h.h.mk
𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹⁵ : CommRing 𝕜
inst✝¹⁴ : AddCommGroup E
inst✝¹³ : Module 𝕜 E
inst✝¹² : TopologicalSpace E
inst✝¹¹ : TopologicalAddGroup E
inst✝¹⁰ : ContinuousConstSMul 𝕜 E
inst✝⁹ : AddCommGroup F
inst✝⁸ : Module 𝕜 F
inst✝⁷ : TopologicalSpace F
inst✝⁶ : TopologicalAddGroup F
inst✝⁵ : ContinuousConstSMul 𝕜 F
inst✝⁴ : AddCommGroup G
inst✝³ : Module 𝕜 G
inst✝² : TopologicalSpace G
inst✝¹ : TopologicalAddGroup G
inst✝ : ContinuousConstSMul 𝕜 G
p : FormalMultilinearSeries 𝕜 E F
m : ℕ
v w : Fin m → E
h2 : ∀ (i : ℕ) (him hin : i < m), v { val := i, isLt := him } = w { val := i, isLt := hin }
i : ℕ
hi : i < m
⊢ v { val := i, isLt := hi } = w { val := i, isLt := hi }
Theorem: gcd_mul_left
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b c : α
⊢ a = 0 → gcd (a * b) (a * c) = ↑normalize a * gcd b c

tactic: simp only [zero_mul, gcd_zero_left, normalize_zero]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
b c : α
⊢ gcd (0 * b) (0 * c) = ↑normalize 0 * gcd b c

tactic: simpa
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
a b c : α
ha : a ≠ 0
this : gcd (a * b) (a * c) = ↑normalize (a * gcd b c)
⊢ gcd (a * b) (a * c) = ↑normalize a * gcd b c
Theorem: Ordnode.dual_rotateR
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← dual_dual (rotateL _ _ _), dual_rotateL, dual_dual, dual_dual]
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
⊢ dual (rotateR l x r) = rotateL (dual r) x (dual l)
Theorem: Finset.sorted_last_eq_max'
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [length_sort] at h
state_before: α : Type ?u.20499
β : Type ?u.20502
inst✝ : LinearOrder α
s : Finset α
h : List.length (sort (fun x x_1 => x ≤ x_1) s) - 1 < List.length (sort (fun x x_1 => x ≤ x_1) s)
⊢ Finset.Nonempty s

tactic: exact card_pos.1 (lt_of_le_of_lt bot_le h)
state_before: α : Type ?u.20499
β : Type ?u.20502
inst✝ : LinearOrder α
s : Finset α
h : card s - 1 < card s
⊢ Finset.Nonempty s
Theorem: Complex.norm_exp_ofReal_mul_I
File: Mathlib/Analysis/Complex/Basic.lean

tactic: simp only [norm_eq_abs, abs_exp_ofReal_mul_I]
state_before: t : ℝ
⊢ ‖exp (↑t * I)‖ = 1
Theorem: LinearIndependent.union
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: simpa
state_before: ι : Type u'
ι' : Type ?u.376032
R : Type u_2
K : Type ?u.376038
M : Type u_1
M' : Type ?u.376044
M'' : Type ?u.376047
V : Type u
V' : Type ?u.376052
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s t : Set M
hs : LinearIndependent R fun x => ↑x
ht : LinearIndependent R fun x => ↑x
hst : Disjoint (span R s) (span R t)
⊢ Disjoint (span R (range fun x => ↑x)) (span R (range fun x => ↑x))

tactic: simp
state_before: ι : Type u'
ι' : Type ?u.376032
R : Type u_2
K : Type ?u.376038
M : Type u_1
M' : Type ?u.376044
M'' : Type ?u.376047
V : Type u
V' : Type ?u.376052
v : ι → M
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'
inst✝³ : AddCommGroup M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s t : Set M
hs : LinearIndependent R fun x => ↑x
ht : LinearIndependent R fun x => ↑x
hst : Disjoint (span R s) (span R t)
⊢ range (Sum.elim (fun x => ↑x) fun x => ↑x) = s ∪ t
Theorem: Tropical.add_eq_left_iff
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: rw [trop_add_def, trop_eq_iff_eq_untrop, ← untrop_le_iff, min_eq_left_iff]
state_before: R : Type u
inst✝ : LinearOrder R
x y : Tropical R
⊢ x + y = x ↔ x ≤ y
Theorem: Qpf.id_map
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: rw [← abs_repr x]
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
x : F α
⊢ id <$> x = x

tactic: cases' repr x with a f
state_before: F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
x : F α
⊢ id <$> abs (repr x) = abs (repr x)

tactic: rw [← abs_map]
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ id <$> abs { fst := a, snd := f } = abs { fst := a, snd := f }

tactic: rfl
state_before: case mk
F : Type u → Type u
inst✝ : Functor F
q : Qpf F
α : Type u
x : F α
a : (P F).A
f : PFunctor.B (P F) a → α
⊢ abs (id <$> { fst := a, snd := f }) = abs { fst := a, snd := f }
Theorem: Fin.cons_injective_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: refine' ⟨fun h ↦ ⟨_, _⟩, fun h ↦ cons_injective_of_injective h.1 h.2⟩
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
x₀ : α
x : Fin n → α
⊢ Injective (cons x₀ x) ↔ ¬x₀ ∈ Set.range x ∧ Injective x

tactic: rintro ⟨i, hi⟩
state_before: case refine'_1
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
x₀ : α
x : Fin n → α
h : Injective (cons x₀ x)
⊢ ¬x₀ ∈ Set.range x

tactic: replace h := @h i.succ 0
state_before: case refine'_1.intro
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i✝ : Fin n
y : α✝ (succ i✝)
z : α✝ 0
α : Type u_1
x₀ : α
x : Fin n → α
h : Injective (cons x₀ x)
i : Fin n
hi : x i = x₀
⊢ False

tactic: simp [hi, succ_ne_zero] at h
state_before: case refine'_1.intro
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i✝ : Fin n
y : α✝ (succ i✝)
z : α✝ 0
α : Type u_1
x₀ : α
x : Fin n → α
i : Fin n
hi : x i = x₀
h : cons x₀ x (succ i) = cons x₀ x 0 → succ i = 0
⊢ False

tactic: simpa [Function.comp] using h.comp (Fin.succ_injective _)
state_before: case refine'_2
m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
x₀ : α
x : Fin n → α
h : Injective (cons x₀ x)
⊢ Injective x
Theorem: Matrix.eq_zero_of_vecMul_eq_zero
File: Mathlib/LinearAlgebra/Matrix/Nondegenerate.lean

tactic: rw [dotProduct_mulVec, hv, zero_dotProduct]
state_before: m : Type u_1
R : Type ?u.16431
A : Type u_2
inst✝⁴ : Fintype m
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : DecidableEq m
M : Matrix m m A
hM : det M ≠ 0
v : m → A
hv : vecMul v M = 0
w : m → A
⊢ v ⬝ᵥ mulVec M w = 0
Theorem: Subsemiring.coe_closure_eq
File: Mathlib/RingTheory/Subsemiring/Basic.lean

tactic: simp [← Submonoid.subsemiringClosure_toAddSubmonoid, Submonoid.subsemiringClosure_eq_closure]
state_before: R : Type u
S : Type v
T : Type w
inst✝² : NonAssocSemiring R
M : Submonoid R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
s : Set R
⊢ ↑(closure s) = ↑(AddSubmonoid.closure ↑(Submonoid.closure s))
Theorem: TopCat.coinduced_of_isColimit
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

tactic: let homeo := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
c : Cocone F
hc : IsColimit c
⊢ c.pt.str = ⨆ (j : J), coinduced ((forget TopCat).map (c.ι.app j)) (F.obj j).str

tactic: ext
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (IsColimit.coconePointUniqueUpToIso hc (colimitCoconeIsColimit F))
⊢ c.pt.str = ⨆ (j : J), coinduced ((forget TopCat).map (c.ι.app j)) (F.obj j).str

tactic: refine' homeo.symm.isOpen_preimage.symm.trans (Iff.trans _ isOpen_iSup_iff.symm)
state_before: case a.h.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (IsColimit.coconePointUniqueUpToIso hc (colimitCoconeIsColimit F))
x✝ : Set ↑c.pt
⊢ IsOpen x✝ ↔ IsOpen x✝

tactic: exact isOpen_iSup_iff
state_before: case a.h.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCatMax
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (IsColimit.coconePointUniqueUpToIso hc (colimitCoconeIsColimit F))
x✝ : Set ↑c.pt
⊢ IsOpen (↑(Homeomorph.symm homeo) ⁻¹' x✝) ↔ ∀ (i : J), IsOpen x✝
Theorem: exists_pow_eq_self_of_coprime
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: by_cases h0 : orderOf x = 0
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime n (orderOf x)
⊢ ∃ m, (x ^ n) ^ m = x

tactic: by_cases h1 : orderOf x = 1
state_before: case neg
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime n (orderOf x)
h0 : ¬orderOf x = 0
⊢ ∃ m, (x ^ n) ^ m = x

tactic: obtain ⟨m, h⟩ := exists_mul_emod_eq_one_of_coprime h (one_lt_iff_ne_zero_and_ne_one.mpr ⟨h0, h1⟩)
state_before: case neg
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime n (orderOf x)
h0 : ¬orderOf x = 0
h1 : ¬orderOf x = 1
⊢ ∃ m, (x ^ n) ^ m = x

tactic: exact ⟨m, by rw [← pow_mul, pow_eq_mod_orderOf, h, pow_one]⟩
state_before: case neg.intro
G : Type u
A : Type v
x y : G
a b : A
n m✝ : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h✝ : coprime n (orderOf x)
h0 : ¬orderOf x = 0
h1 : ¬orderOf x = 1
m : ℕ
h : n * m % orderOf x = 1
⊢ ∃ m, (x ^ n) ^ m = x

tactic: rw [h0, coprime_zero_right] at h
state_before: case pos
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime n (orderOf x)
h0 : orderOf x = 0
⊢ ∃ m, (x ^ n) ^ m = x

tactic: exact ⟨1, by rw [h, pow_one, pow_one]⟩
state_before: case pos
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : n = 1
h0 : orderOf x = 0
⊢ ∃ m, (x ^ n) ^ m = x

tactic: rw [h, pow_one, pow_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : n = 1
h0 : orderOf x = 0
⊢ (x ^ n) ^ 1 = x

tactic: exact ⟨0, by rw [orderOf_eq_one_iff.mp h1, one_pow, one_pow]⟩
state_before: case pos
G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime n (orderOf x)
h0 : ¬orderOf x = 0
h1 : orderOf x = 1
⊢ ∃ m, (x ^ n) ^ m = x

tactic: rw [orderOf_eq_one_iff.mp h1, one_pow, one_pow]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : coprime n (orderOf x)
h0 : ¬orderOf x = 0
h1 : orderOf x = 1
⊢ (x ^ n) ^ 0 = x

tactic: rw [← pow_mul, pow_eq_mod_orderOf, h, pow_one]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m✝ : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h✝ : coprime n (orderOf x)
h0 : ¬orderOf x = 0
h1 : ¬orderOf x = 1
m : ℕ
h : n * m % orderOf x = 1
⊢ (x ^ n) ^ m = x
Theorem: List.length_revzip
File: Mathlib/Data/List/Zip.lean

tactic: simp only [revzip, length_zip, length_reverse, min_self]
state_before: α : Type u
β : Type ?u.93218
γ : Type ?u.93221
δ : Type ?u.93224
ε : Type ?u.93227
l : List α
⊢ length (revzip l) = length l
Theorem: List.sublists_eq_sublists'
File: Mathlib/Data/List/Sublists.lean

tactic: rw [← sublists_reverse, reverse_reverse]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ sublists l = map reverse (sublists' (reverse l))
Theorem: ZMod.pow_card_pow
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: induction' n with n ih
state_before: K : Type ?u.1002572
R : Type ?u.1002575
n p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
⊢ x ^ p ^ n = x

tactic: simp
state_before: case zero
K : Type ?u.1002572
R : Type ?u.1002575
p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
⊢ x ^ p ^ Nat.zero = x

tactic: simp [pow_succ, pow_mul, ih, pow_card]
state_before: case succ
K : Type ?u.1002572
R : Type ?u.1002575
p : ℕ
inst✝ : Fact (Nat.Prime p)
x : ZMod p
n : ℕ
ih : x ^ p ^ n = x
⊢ x ^ p ^ Nat.succ n = x
Theorem: Int.clog_mono_right
File: Mathlib/Data/Int/Log.lean

tactic: rw [← neg_log_inv_eq_clog, ← neg_log_inv_eq_clog, neg_le_neg_iff]
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r₁ r₂ : R
h₀ : 0 < r₁
h : r₁ ≤ r₂
⊢ clog b r₁ ≤ clog b r₂

tactic: exact log_mono_right (inv_pos.mpr <| h₀.trans_le h) (inv_le_inv_of_le h₀ h)
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
r₁ r₂ : R
h₀ : 0 < r₁
h : r₁ ≤ r₂
⊢ log b r₂⁻¹ ≤ log b r₁⁻¹
Theorem: MeasureTheory.lintegral_prod_mul
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: simp [lintegral_prod _ (hf.fst.mul hg.snd), lintegral_lintegral_mul hf hg]
state_before: α : Type u_1
α' : Type ?u.5367515
β : Type u_2
β' : Type ?u.5367521
γ : Type ?u.5367524
E : Type ?u.5367527
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SigmaFinite ν
f : α → ℝ≥0∞
g : β → ℝ≥0∞
hf : AEMeasurable f
hg : AEMeasurable g
⊢ (∫⁻ (z : α × β), f z.fst * g z.snd ∂Measure.prod μ ν) = (∫⁻ (x : α), f x ∂μ) * ∫⁻ (y : β), g y ∂ν
Theorem: Ordinal.eq_enumOrd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: constructor
state_before: S : Set Ordinal
f : Ordinal → Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ StrictMono f ∧ range f = S ↔ f = enumOrd S

tactic: rintro ⟨h₁, h₂⟩
state_before: case mp
S : Set Ordinal
f : Ordinal → Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ StrictMono f ∧ range f = S → f = enumOrd S

tactic: rwa [← lt_wf.eq_strictMono_iff_eq_range h₁ (enumOrd_strictMono hS), range_enumOrd hS]
state_before: case mp.intro
S : Set Ordinal
f : Ordinal → Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
h₁ : StrictMono f
h₂ : range f = S
⊢ f = enumOrd S

tactic: rintro rfl
state_before: case mpr
S : Set Ordinal
f : Ordinal → Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ f = enumOrd S → StrictMono f ∧ range f = S

tactic: exact ⟨enumOrd_strictMono hS, range_enumOrd hS⟩
state_before: case mpr
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ StrictMono (enumOrd S) ∧ range (enumOrd S) = S
Theorem: List.drop_append_eq_append_drop
File: Mathlib/Data/List/Basic.lean

tactic: induction l₁ generalizing n
state_before: ι : Type ?u.204814
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁✝ l₂✝ l₁ l₂ : List α
n : ℕ
⊢ drop n (l₁ ++ l₂) = drop n l₁ ++ drop (n - length l₁) l₂

tactic: cases n <;> simp [*]
state_before: case cons
ι : Type ?u.204814
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ {n : ℕ}, drop n (tail✝ ++ l₂) = drop n tail✝ ++ drop (n - length tail✝) l₂
n : ℕ
⊢ drop n (head✝ :: tail✝ ++ l₂) = drop n (head✝ :: tail✝) ++ drop (n - length (head✝ :: tail✝)) l₂

tactic: simp
state_before: case nil
ι : Type ?u.204814
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂✝ l₂ : List α
n : ℕ
⊢ drop n ([] ++ l₂) = drop n [] ++ drop (n - length []) l₂
Theorem: Commute.inv_mul_cancel
File: Mathlib/Algebra/Group/Commute.lean

tactic: rw [h.inv_left.eq, inv_mul_cancel_right]
state_before: G : Type u_1
inst✝ : Group G
a b : G
h : Commute a b
⊢ a⁻¹ * b * a = b
Theorem: one_lt_mersenne
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: rw [one_add_one_eq_two, pow_one]
state_before: p : ℕ
hp : 1 < p
⊢ 1 + 1 = 2 ^ 1
Theorem: exists_nat_pow_near_of_lt_one
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rcases exists_nat_pow_near (one_le_inv_iff.2 ⟨xpos, hx⟩) (one_lt_inv_iff.2 ⟨ypos, hy⟩) with
  ⟨n, hn, h'n⟩
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
xpos : 0 < x
hx : x ≤ 1
ypos : 0 < y
hy : y < 1
⊢ ∃ n, y ^ (n + 1) < x ∧ x ≤ y ^ n

tactic: refine' ⟨n, _, _⟩
state_before: case intro.intro
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
xpos : 0 < x
hx : x ≤ 1
ypos : 0 < y
hy : y < 1
n : ℕ
hn : y⁻¹ ^ n ≤ x⁻¹
h'n : x⁻¹ < y⁻¹ ^ (n + 1)
⊢ ∃ n, y ^ (n + 1) < x ∧ x ≤ y ^ n

tactic: rwa [inv_pow, inv_lt_inv xpos (pow_pos ypos _)] at h'n
state_before: case intro.intro.refine'_1
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
xpos : 0 < x
hx : x ≤ 1
ypos : 0 < y
hy : y < 1
n : ℕ
hn : y⁻¹ ^ n ≤ x⁻¹
h'n : x⁻¹ < y⁻¹ ^ (n + 1)
⊢ y ^ (n + 1) < x

tactic: rwa [inv_pow, inv_le_inv (pow_pos ypos _) xpos] at hn
state_before: case intro.intro.refine'_2
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε : α
xpos : 0 < x
hx : x ≤ 1
ypos : 0 < y
hy : y < 1
n : ℕ
hn : y⁻¹ ^ n ≤ x⁻¹
h'n : x⁻¹ < y⁻¹ ^ (n + 1)
⊢ x ≤ y ^ n
Theorem: Set.iUnion_unpair_prod
File: Mathlib/Data/Nat/Pairing.lean

tactic: rw [← Set.iUnion_prod]
state_before: α : Type u_1
β : Type u_2
s : ℕ → Set α
t : ℕ → Set β
⊢ (⋃ (n : ℕ), s (unpair n).fst ×ˢ t (unpair n).snd) = (⋃ (n : ℕ), s n) ×ˢ ⋃ (n : ℕ), t n

tactic: exact surjective_unpair.iUnion_comp (fun x => s x.fst ×ˢ t x.snd)
state_before: α : Type u_1
β : Type u_2
s : ℕ → Set α
t : ℕ → Set β
⊢ (⋃ (n : ℕ), s (unpair n).fst ×ˢ t (unpair n).snd) = ⋃ (x : ℕ × ℕ), s x.fst ×ˢ t x.snd
Theorem: PGame.le_zero
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [le_def]
state_before: x : PGame
⊢ x ≤ 0 ↔ ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0

tactic: simp
state_before: x : PGame
⊢ ((∀ (i : LeftMoves x), (∃ i', moveLeft x i ≤ moveLeft 0 i') ∨ ∃ j, moveRight (moveLeft x i) j ≤ 0) ∧
      ∀ (j : RightMoves 0), (∃ i, x ≤ moveLeft (moveRight 0 j) i) ∨ ∃ j', moveRight x j' ≤ moveRight 0 j) ↔
    ∀ (i : LeftMoves x), ∃ j, moveRight (moveLeft x i) j ≤ 0
Theorem: Filter.map₂_right_identity
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [map₂_pure_right, funext h, map_id']
state_before: α : Type u_1
α' : Type ?u.45411
β : Type u_2
β' : Type ?u.45417
γ : Type ?u.45420
γ' : Type ?u.45423
δ : Type ?u.45426
δ' : Type ?u.45429
ε : Type ?u.45432
ε' : Type ?u.45435
m : α → β → γ
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
h✝ h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b✝ : β
c : γ
f : α → β → α
b : β
h : ∀ (a : α), f a b = a
l : Filter α
⊢ map₂ f l (pure b) = l