tasksource/leandojo huggingface dataset:
Theorem: pow_eq_pow_mod
File: Mathlib/Algebra/GroupPower/Basic.lean

tactic: have t : x ^ m = x ^ (n * (m / n) + m % n) :=
  congr_arg (fun a => x ^ a) ((Nat.add_comm _ _).trans (Nat.mod_add_div _ _)).symm
state_before: α : Type ?u.27674
M✝ : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
M : Type u_1
inst✝ : Monoid M
x : M
m n : ℕ
h : x ^ n = 1
⊢ x ^ m = x ^ (m % n)

tactic: dsimp at t
state_before: α : Type ?u.27674
M✝ : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
M : Type u_1
inst✝ : Monoid M
x : M
m n : ℕ
h : x ^ n = 1
t : x ^ m = x ^ (n * (m / n) + m % n)
⊢ x ^ m = x ^ (m % n)

tactic: rw [t, pow_add, pow_mul, h, one_pow, one_mul]
state_before: α : Type ?u.27674
M✝ : Type u
N : Type v
G : Type w
H : Type x
A : Type y
B : Type z
R : Type u₁
S : Type u₂
inst✝² : Monoid M✝
inst✝¹ : AddMonoid A
M : Type u_1
inst✝ : Monoid M
x : M
m n : ℕ
h : x ^ n = 1
t : x ^ m = x ^ (n * (m / n) + m % n)
⊢ x ^ m = x ^ (m % n)
Theorem: SymplecticGroup.symplectic_det
File: Mathlib/LinearAlgebra/SymplecticGroup.lean

tactic: rw [isUnit_iff_exists_inv]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ IsUnit (det A)

tactic: use A.det
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ ∃ b, det A * b = 1

tactic: refine' (isUnit_det_J l R).mul_left_cancel _
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ det A * det A = 1

tactic: rw [mul_one]
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ det (J l R) * (det A * det A) = det (J l R) * 1

tactic: rw [mem_iff] at hA
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ∈ symplecticGroup l R
⊢ det (J l R) * (det A * det A) = det (J l R)

tactic: apply_fun det at hA
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : A ⬝ J l R ⬝ Aᵀ = J l R
⊢ det (J l R) * (det A * det A) = det (J l R)

tactic: simp only [det_mul, det_transpose] at hA
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : det (A ⬝ J l R ⬝ Aᵀ) = det (J l R)
⊢ det (J l R) * (det A * det A) = det (J l R)

tactic: rw [mul_comm A.det, mul_assoc] at hA
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : det A * det (J l R) * det A = det (J l R)
⊢ det (J l R) * (det A * det A) = det (J l R)

tactic: exact hA
state_before: l : Type u_1
R : Type u_2
inst✝² : DecidableEq l
inst✝¹ : Fintype l
inst✝ : CommRing R
A : Matrix (l ⊕ l) (l ⊕ l) R
hA : det (J l R) * (det A * det A) = det (J l R)
⊢ det (J l R) * (det A * det A) = det (J l R)
Theorem: Real.Angle.tan_eq_of_two_nsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [two_nsmul_eq_iff] at h
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ tan θ = tan ψ

tactic: rcases h with (rfl | rfl)
state_before: θ ψ : Angle
h : θ = ψ ∨ θ = ψ + ↑π
⊢ tan θ = tan ψ

tactic: rfl
state_before: case inl
θ : Angle
⊢ tan θ = tan θ

tactic: exact tan_add_pi _
state_before: case inr
ψ : Angle
⊢ tan (ψ + ↑π) = tan ψ
Theorem: Equiv.embeddingCongr_apply_trans
File: Mathlib/Logic/Embedding/Basic.lean

tactic: ext
state_before: α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
⊢ ↑(embeddingCongr ea ec) (Embedding.trans f g) =
    Embedding.trans (↑(embeddingCongr ea eb) f) (↑(embeddingCongr eb ec) g)

tactic: simp
state_before: case h
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
x✝ : α₂
⊢ ↑(↑(embeddingCongr ea ec) (Embedding.trans f g)) x✝ =
    ↑(Embedding.trans (↑(embeddingCongr ea eb) f) (↑(embeddingCongr eb ec) g)) x✝
Theorem: Submodule.mem_orthogonal'
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: simp_rw [mem_orthogonal, inner_eq_zero_symm]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.19423
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
v : E
⊢ v ∈ Kᗮ ↔ ∀ (u : E), u ∈ K → inner v u = 0
Theorem: intervalIntegral.integral_div
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: simpa only [div_eq_mul_inv] using integral_mul_const r⁻¹ f
state_before: ι : Type ?u.13479101
𝕜✝ : Type ?u.13479104
E : Type ?u.13479107
F : Type ?u.13479110
A : Type ?u.13479113
inst✝³ : NormedAddCommGroup E
inst✝² : CompleteSpace E
inst✝¹ : NormedSpace ℝ E
a b : ℝ
f✝ g : ℝ → E
μ : MeasureTheory.Measure ℝ
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
r : 𝕜
f : ℝ → 𝕜
⊢ (∫ (x : ℝ) in a..b, f x / r ∂μ) = (∫ (x : ℝ) in a..b, f x ∂μ) / r
Theorem: Vector.tendsto_insertNth
File: Mathlib/Topology/List.lean

tactic: rw [insertNth, tendsto_subtype_rng]
state_before: α : Type u_1
β : Type ?u.65317
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : List.length l = n
⊢ Tendsto (fun p => insertNth p.fst i p.snd) (𝓝 a ×ˢ 𝓝 { val := l, property := hl })
    (𝓝 (insertNth a i { val := l, property := hl }))

tactic: simp [insertNth_val]
state_before: α : Type u_1
β : Type ?u.65317
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : List.length l = n
⊢ Tendsto (fun x => ↑(insertNth x.fst i x.snd)) (𝓝 a ×ˢ 𝓝 { val := l, property := hl })
    (𝓝
      ↑{ val := List.insertNth (↑i) a ↑{ val := l, property := hl },
          property := (_ : List.length (List.insertNth (↑i) a ↑{ val := l, property := hl }) = n + 1) })

tactic: exact List.tendsto_insertNth tendsto_fst (Tendsto.comp continuousAt_subtype_val tendsto_snd : _)
state_before: α : Type u_1
β : Type ?u.65317
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
n : ℕ
i : Fin (n + 1)
a : α
l : List α
hl : List.length l = n
⊢ Tendsto (fun x => List.insertNth (↑i) x.fst ↑x.snd) (𝓝 a ×ˢ 𝓝 { val := l, property := hl })
    (𝓝 (List.insertNth (↑i) a l))
Theorem: div_zero
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [div_eq_mul_inv, inv_zero, mul_zero]
state_before: α : Type ?u.23833
M₀ : Type ?u.23836
G₀ : Type u_1
M₀' : Type ?u.23842
G₀' : Type ?u.23845
F : Type ?u.23848
F' : Type ?u.23851
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a / 0 = 0
Theorem: AffineBasis.toMatrix_vecMul_coords
File: Mathlib/LinearAlgebra/AffineSpace/Matrix.lean

tactic: ext j
state_before: ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : Ring k
inst✝² : Module k V
b : AffineBasis ι k P
ι' : Type ?u.37207
inst✝¹ : Fintype ι'
inst✝ : Fintype ι
b₂ : AffineBasis ι k P
x : P
⊢ vecMul (↑(coords b₂) x) (toMatrix b ↑b₂) = ↑(coords b) x

tactic: change _ = b.coord j x
state_before: case h
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : Ring k
inst✝² : Module k V
b : AffineBasis ι k P
ι' : Type ?u.37207
inst✝¹ : Fintype ι'
inst✝ : Fintype ι
b₂ : AffineBasis ι k P
x : P
j : ι
⊢ vecMul (↑(coords b₂) x) (toMatrix b ↑b₂) j = ↑(coords b) x j

tactic: conv_rhs => rw [← b₂.affineCombination_coord_eq_self x]
state_before: case h
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : Ring k
inst✝² : Module k V
b : AffineBasis ι k P
ι' : Type ?u.37207
inst✝¹ : Fintype ι'
inst✝ : Fintype ι
b₂ : AffineBasis ι k P
x : P
j : ι
⊢ vecMul (↑(coords b₂) x) (toMatrix b ↑b₂) j = ↑(coord b j) x

tactic: rw [Finset.map_affineCombination _ _ _ (b₂.sum_coord_apply_eq_one x)]
state_before: case h
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : Ring k
inst✝² : Module k V
b : AffineBasis ι k P
ι' : Type ?u.37207
inst✝¹ : Fintype ι'
inst✝ : Fintype ι
b₂ : AffineBasis ι k P
x : P
j : ι
⊢ vecMul (↑(coords b₂) x) (toMatrix b ↑b₂) j =
    ↑(coord b j) (↑(Finset.affineCombination k Finset.univ ↑b₂) fun i => ↑(coord b₂ i) x)

tactic: simp [Matrix.vecMul, Matrix.dotProduct, toMatrix_apply, coords]
state_before: case h
ι : Type u₁
k : Type u₂
V : Type u₃
P : Type u₄
inst✝⁵ : AddCommGroup V
inst✝⁴ : AffineSpace V P
inst✝³ : Ring k
inst✝² : Module k V
b : AffineBasis ι k P
ι' : Type ?u.37207
inst✝¹ : Fintype ι'
inst✝ : Fintype ι
b₂ : AffineBasis ι k P
x : P
j : ι
⊢ vecMul (↑(coords b₂) x) (toMatrix b ↑b₂) j =
    ↑(Finset.affineCombination ((fun a => k) x) Finset.univ (↑(coord b j) ∘ ↑b₂)) fun i => ↑(coord b₂ i) x
Theorem: WittVector.mulN_isPoly
File: Mathlib/RingTheory/WittVector/MulP.lean

tactic: funext k
state_before: p : ℕ
R✝ : Type ?u.50758
hp : Fact (Nat.Prime p)
inst✝ : CommRing R✝
n : ℕ
R : Type u_1
_Rcr : CommRing R
x : 𝕎 R
⊢ (x * ↑n).coeff = fun n_1 => ↑(aeval x.coeff) (wittMulN p n n_1)

tactic: exact mulN_coeff n x k
state_before: case h
p : ℕ
R✝ : Type ?u.50758
hp : Fact (Nat.Prime p)
inst✝ : CommRing R✝
n : ℕ
R : Type u_1
_Rcr : CommRing R
x : 𝕎 R
k : ℕ
⊢ coeff (x * ↑n) k = ↑(aeval x.coeff) (wittMulN p n k)
Theorem: Set.toFinset_prod
File: Mathlib/Data/Fintype/Prod.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.32
s✝ t✝ s : Set α
t : Set β
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ×ˢ t)
⊢ toFinset (s ×ˢ t) = toFinset s ×ˢ toFinset t

tactic: simp
state_before: case a
α : Type u_1
β : Type u_2
γ : Type ?u.32
s✝ t✝ s : Set α
t : Set β
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ×ˢ t)
a✝ : α × β
⊢ a✝ ∈ toFinset (s ×ˢ t) ↔ a✝ ∈ toFinset s ×ˢ toFinset t
Theorem: right_div_gcd_ne_zero
File: Mathlib/RingTheory/EuclideanDomain.lean

tactic: obtain ⟨r, hr⟩ := GCDMonoid.gcd_dvd_right p q
state_before: R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p q : R
hq : q ≠ 0
⊢ q / GCDMonoid.gcd p q ≠ 0

tactic: obtain ⟨pq0, r0⟩ : GCDMonoid.gcd p q ≠ 0 ∧ r ≠ 0 := mul_ne_zero_iff.mp (hr ▸ hq)
state_before: case intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
⊢ q / GCDMonoid.gcd p q ≠ 0

tactic: nth_rw 1 [hr]
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ q / GCDMonoid.gcd p q ≠ 0

tactic: rw [mul_comm, EuclideanDomain.mul_div_cancel _ pq0]
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ GCDMonoid.gcd p q * r / GCDMonoid.gcd p q ≠ 0

tactic: exact r0
state_before: case intro.intro
R : Type u_1
inst✝¹ : EuclideanDomain R
inst✝ : GCDMonoid R
p q : R
hq : q ≠ 0
r : R
hr : q = GCDMonoid.gcd p q * r
pq0 : GCDMonoid.gcd p q ≠ 0
r0 : r ≠ 0
⊢ r ≠ 0
Theorem: Cardinal.mk_finsupp_of_fintype
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α✝ β✝ α β : Type u
inst✝¹ : Fintype α
inst✝ : Zero β
⊢ (#α →₀ β) = (#β) ^ Fintype.card α
Theorem: Complex.sinh_sub_cosh
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← neg_sub, cosh_sub_sinh]
state_before: x y : ℂ
⊢ sinh x - cosh x = -exp (-x)
Theorem: List.foldrIdx_eq_foldrIdxSpec
File: Mathlib/Data/List/Indexes.lean

tactic: induction as generalizing start
state_before: α : Type u
β : Type v
f : ℕ → α → β → β
b : β
as : List α
start : ℕ
⊢ foldrIdx f b as start = foldrIdxSpec f b as start

tactic: rfl
state_before: case nil
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
start : ℕ
⊢ foldrIdx f b [] start = foldrIdxSpec f b [] start

tactic: simp only [foldrIdx, foldrIdxSpec_cons, *]
state_before: case cons
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (start : ℕ), foldrIdx f b tail✝ start = foldrIdxSpec f b tail✝ start
start : ℕ
⊢ foldrIdx f b (head✝ :: tail✝) start = foldrIdxSpec f b (head✝ :: tail✝) start
Theorem: Real.toNNReal_prod_of_nonneg
File: Mathlib/Data/Real/NNReal.lean

tactic: rw [← NNReal.coe_eq, NNReal.coe_prod, Real.coe_toNNReal _ (Finset.prod_nonneg hf)]
state_before: α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ (a : α), a ∈ s → 0 ≤ f a
⊢ Real.toNNReal (∏ a in s, f a) = ∏ a in s, Real.toNNReal (f a)

tactic: exact Finset.prod_congr rfl fun x hxs => by rw [Real.coe_toNNReal _ (hf x hxs)]
state_before: α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ (a : α), a ∈ s → 0 ≤ f a
⊢ ∏ i in s, f i = ∏ a in s, ↑(Real.toNNReal (f a))

tactic: rw [Real.coe_toNNReal _ (hf x hxs)]
state_before: α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ (a : α), a ∈ s → 0 ≤ f a
x : α
hxs : x ∈ s
⊢ f x = ↑(Real.toNNReal (f x))
Theorem: SimpleGraph.Walk.reverse_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [map_append, *]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
⊢ reverse (Walk.map f p) = Walk.map f (reverse p)
Theorem: dvd_sub_left
File: Mathlib/Algebra/Ring/Divisibility.lean

tactic: simpa only [← sub_eq_add_neg] using dvd_add_left ((dvd_neg (α := α)).2 h)
state_before: α : Type u_1
β : Type ?u.10227
inst✝ : NonUnitalRing α
a b c : α
h : a ∣ c
⊢ a ∣ b - c ↔ a ∣ b
Theorem: Function.Antiperiodic.neg
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [sub_eq_add_neg, Antiperiodic] using h.sub_eq
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.156251
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddGroup α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
⊢ Antiperiodic f (-c)
Theorem: AlgebraicGeometry.StructureSheaf.stalkSpecializes_stalk_to_fiber
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: change _ ≫ (StructureSheaf.stalkIso R x).hom = (StructureSheaf.stalkIso R y).hom ≫ _
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h ≫ stalkToFiberRingHom R x =
    stalkToFiberRingHom R y ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this

tactic: rw [← Iso.eq_comp_inv, Category.assoc, ← Iso.inv_comp_eq]
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h ≫ (stalkIso R x).hom =
    (stalkIso R y).hom ≫
      let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this

tactic: exact localizationToStalk_stalkSpecializes h
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ (stalkIso R y).inv ≫ stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h =
    (let_fun this := PrimeSpectrum.localizationMapOfSpecializes h;
      this) ≫
      (stalkIso R x).inv
Theorem: Fin.induction_succ
File: Mathlib/Data/Fin/Basic.lean

tactic: cases i
state_before: n m : ℕ
C : Fin (n + 1) → Sort u_1
h0 : C 0
hs : (i : Fin n) → C (↑castSucc i) → C (succ i)
i : Fin n
⊢ (fun i => induction h0 hs i) (succ i) = hs i (induction h0 hs (↑castSucc i))

tactic: rfl
state_before: case mk
n m : ℕ
C : Fin (n + 1) → Sort u_1
h0 : C 0
hs : (i : Fin n) → C (↑castSucc i) → C (succ i)
val✝ : ℕ
isLt✝ : val✝ < n
⊢ (fun i => induction h0 hs i) (succ { val := val✝, isLt := isLt✝ }) =
    hs { val := val✝, isLt := isLt✝ } (induction h0 hs (↑castSucc { val := val✝, isLt := isLt✝ }))
Theorem: norm_le_zero_iff'''
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: letI : NormedGroup E :=
  { ‹SeminormedGroup E› with toMetricSpace := MetricSpace.ofT0PseudoMetricSpace E }
state_before: 𝓕 : Type ?u.499976
𝕜 : Type ?u.499979
α : Type ?u.499982
ι : Type ?u.499985
κ : Type ?u.499988
E : Type u_1
F : Type ?u.499994
G : Type ?u.499997
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : T0Space E
a : E
⊢ ‖a‖ ≤ 0 ↔ a = 1

tactic: rw [← dist_one_right, dist_le_zero]
state_before: 𝓕 : Type ?u.499976
𝕜 : Type ?u.499979
α : Type ?u.499982
ι : Type ?u.499985
κ : Type ?u.499988
E : Type u_1
F : Type ?u.499994
G : Type ?u.499997
inst✝³ : SeminormedGroup E
inst✝² : SeminormedGroup F
inst✝¹ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
inst✝ : T0Space E
a : E
this : NormedGroup E :=
  let src := inst✝³;
  NormedGroup.mk
⊢ ‖a‖ ≤ 0 ↔ a = 1
Theorem: MeasureTheory.extend_union
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [union_eq_iUnion,
  extend_iUnion P0 m0 PU mU (pairwise_disjoint_on_bool.2 hd) (Bool.forall_bool.2 ⟨h₂, h₁⟩),
  tsum_fintype]
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
hd : Disjoint s₁ s₂
h₁ : P s₁
h₂ : P s₂
⊢ extend m (s₁ ∪ s₂) = extend m s₁ + extend m s₂

tactic: simp
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
s₁ s₂ : Set α
hd : Disjoint s₁ s₂
h₁ : P s₁
h₂ : P s₂
⊢ ∑ b : Bool, extend m (bif b then s₁ else s₂) = extend m s₁ + extend m s₂
Theorem: card_comm_eq_card_conjClasses_mul_card
File: Mathlib/GroupTheory/CommutingProbability.lean

tactic: haveI := Fintype.ofFinite G
state_before: M : Type ?u.6837
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_1
inst✝¹ : Group G
inst✝ : Finite G
⊢ Nat.card { p // p.fst * p.snd = p.snd * p.fst } = Nat.card (ConjClasses G) * Nat.card G

tactic: simp only [Nat.card_eq_fintype_card]
state_before: M : Type ?u.6837
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_1
inst✝¹ : Group G
inst✝ : Finite G
this : Fintype G
⊢ Nat.card { p // p.fst * p.snd = p.snd * p.fst } = Nat.card (ConjClasses G) * Nat.card G

tactic: rw [card_congr (Equiv.subtypeProdEquivSigmaSubtype fun g h : G ↦ g * h = h * g), card_sigma,
  sum_equiv ConjAct.toConjAct.toEquiv (fun a ↦ card { b // a * b = b * a })
    (fun g ↦ card (MulAction.fixedBy (ConjAct G) G g))
    fun g ↦ card_congr' <| congr_arg _ <| funext fun h ↦ mul_inv_eq_iff_eq_mul.symm.to_eq,
  MulAction.sum_card_fixedBy_eq_card_orbits_mul_card_group, ConjAct.card,
  (Setoid.ext fun g h ↦ (Setoid.comm' _).trans isConj_iff.symm :
    MulAction.orbitRel (ConjAct G) G = IsConj.setoid G),
  @card_congr' (Quotient (IsConj.setoid G)) (ConjClasses G) _ _ rfl]
state_before: M : Type ?u.6837
inst✝³ : Mul M
inst✝² : Finite M
G : Type u_1
inst✝¹ : Group G
inst✝ : Finite G
this : Fintype G
⊢ card { p // p.fst * p.snd = p.snd * p.fst } = card (ConjClasses G) * card G
Theorem: List.nnnorm_prod_le'
File: Mathlib/Analysis/Normed/Field/Basic.lean

tactic: simp [NNReal.coe_list_prod, List.map_map]
state_before: α : Type u_1
β : Type ?u.112914
γ : Type ?u.112917
ι : Type ?u.112920
inst✝ : SeminormedRing α
l : List α
hl : l ≠ []
⊢ prod (map norm l) = (fun a => ↑a) (prod (map nnnorm l))
Theorem: EReal.continuousAt_add_bot_coe
File: Mathlib/Topology/Instances/EReal.lean

tactic: simp only [ContinuousAt, tendsto_nhds_bot_iff_real, bot_add]
state_before: α : Type ?u.23308
inst✝ : TopologicalSpace α
a : ℝ
⊢ ContinuousAt (fun p => p.fst + p.snd) (⊥, ↑a)

tactic: refine fun r ↦ ((gt_mem_nhds (bot_lt_coe (r - (a + 1)))).prod_nhds
  (gt_mem_nhds <| EReal.coe_lt_coe_iff.2 <| lt_add_one _)).mono fun _ h ↦ ?_
state_before: α : Type ?u.23308
inst✝ : TopologicalSpace α
a : ℝ
⊢ ∀ (x : ℝ), ∀ᶠ (a : EReal × EReal) in 𝓝 (⊥, ↑a), a.fst + a.snd < ↑x

tactic: simpa only [← coe_add, sub_add_cancel] using add_lt_add h.1 h.2
state_before: α : Type ?u.23308
inst✝ : TopologicalSpace α
a r : ℝ
x✝ : EReal × EReal
h : x✝.fst < ↑(r - (a + 1)) ∧ x✝.snd < ↑(a + 1)
⊢ x✝.fst + x✝.snd < ↑r
Theorem: CategoryTheory.Iso.trans_conjAut
File: Mathlib/CategoryTheory/Conj.lean

tactic: simp only [conjAut_apply, Iso.trans_symm, Iso.trans_assoc]
state_before: C : Type u
inst✝ : Category C
X Y : C
α : X ≅ Y
Z : C
β : Y ≅ Z
f : Aut X
⊢ ↑(conjAut (α ≪≫ β)) f = ↑(conjAut β) (↑(conjAut α) f)
Theorem: Finset.mem_upShadow_iff
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: simp_rw [upShadow, mem_sup, mem_image, exists_prop, mem_compl]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ s ∈ (∂⁺ ) 𝒜 ↔ ∃ t, t ∈ 𝒜 ∧ ∃ a x, insert a t = s
Theorem: Polynomial.degree_mul_X
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simp [monic_X.degree_mul]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
⊢ degree (p * X) = degree p + 1
Theorem: Real.one_lt_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← one_rpow z]
state_before: x✝ y z✝ x z : ℝ
hx : 1 < x
hz : 0 < z
⊢ 1 < x ^ z

tactic: exact rpow_lt_rpow zero_le_one hx hz
state_before: x✝ y z✝ x z : ℝ
hx : 1 < x
hz : 0 < z
⊢ 1 ^ z < x ^ z
Theorem: Multiset.disjoint_list_sum_left
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: induction' l with b bs ih
state_before: ι : Type ?u.892330
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a : Multiset α
l : List (Multiset α)
⊢ Disjoint (List.sum l) a ↔ ∀ (b : Multiset α), b ∈ l → Disjoint b a

tactic: simp only [zero_disjoint, List.not_mem_nil, IsEmpty.forall_iff, forall_const, List.sum_nil]
state_before: case nil
ι : Type ?u.892330
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a : Multiset α
⊢ Disjoint (List.sum []) a ↔ ∀ (b : Multiset α), b ∈ [] → Disjoint b a

tactic: simp_rw [List.sum_cons, disjoint_add_left, List.mem_cons, forall_eq_or_imp]
state_before: case cons
ι : Type ?u.892330
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a b : Multiset α
bs : List (Multiset α)
ih : Disjoint (List.sum bs) a ↔ ∀ (b : Multiset α), b ∈ bs → Disjoint b a
⊢ Disjoint (List.sum (b :: bs)) a ↔ ∀ (b_1 : Multiset α), b_1 ∈ b :: bs → Disjoint b_1 a

tactic: simp [and_congr_left_iff, iff_self_iff, ih]
state_before: case cons
ι : Type ?u.892330
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a b : Multiset α
bs : List (Multiset α)
ih : Disjoint (List.sum bs) a ↔ ∀ (b : Multiset α), b ∈ bs → Disjoint b a
⊢ Disjoint b a ∧ Disjoint (List.sum bs) a ↔ Disjoint b a ∧ ∀ (a_1 : Multiset α), a_1 ∈ bs → Disjoint a_1 a
Theorem: Real.Angle.coe_toIocMod
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: rw [angle_eq_iff_two_pi_dvd_sub]
state_before: θ ψ : ℝ
⊢ ↑(toIocMod two_pi_pos ψ θ) = ↑θ

tactic: refine' ⟨-toIocDiv two_pi_pos ψ θ, _⟩
state_before: θ ψ : ℝ
⊢ ∃ k, toIocMod two_pi_pos ψ θ - θ = 2 * π * ↑k

tactic: rw [toIocMod_sub_self, zsmul_eq_mul, mul_comm]
state_before: θ ψ : ℝ
⊢ toIocMod two_pi_pos ψ θ - θ = 2 * π * ↑(-toIocDiv two_pi_pos ψ θ)
Theorem: Matrix.one_div_pow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: simp only [one_div, inv_pow']
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
⊢ (1 / A) ^ n = 1 / A ^ n