tasksource/leandojo huggingface dataset:
Theorem: Subgroup.index_map_dvd
File: Mathlib/GroupTheory/Index.lean

tactic: rw [index_map, f.range_top_of_surjective hf, index_top, mul_one]
state_before: G : Type u_2
inst✝¹ : Group G
H K L : Subgroup G
G' : Type u_1
inst✝ : Group G'
f : G →* G'
hf : Function.Surjective ↑f
⊢ index (map f H) ∣ index H

tactic: exact index_dvd_of_le le_sup_left
state_before: G : Type u_2
inst✝¹ : Group G
H K L : Subgroup G
G' : Type u_1
inst✝ : Group G'
f : G →* G'
hf : Function.Surjective ↑f
⊢ index (H ⊔ MonoidHom.ker f) ∣ index H
Theorem: strictMono_pow_bit1
File: Mathlib/Algebra/GroupPower/Lemmas.lean

tactic: intro a b hab
state_before: α : Type ?u.310657
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✝ : LinearOrderedRing R
a : R
n✝ n : ℕ
⊢ StrictMono fun a => a ^ bit1 n

tactic: cases' le_total a 0 with ha ha
state_before: α : Type ?u.310657
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✝ : LinearOrderedRing R
a✝ : R
n✝ n : ℕ
a b : R
hab : a < b
⊢ (fun a => a ^ bit1 n) a < (fun a => a ^ bit1 n) b

tactic: cases' le_or_lt b 0 with hb hb
state_before: case inl
α : Type ?u.310657
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✝ : LinearOrderedRing R
a✝ : R
n✝ n : ℕ
a b : R
hab : a < b
ha : a ≤ 0
⊢ (fun a => a ^ bit1 n) a < (fun a => a ^ bit1 n) b

tactic: rw [← neg_lt_neg_iff, ← neg_pow_bit1, ← neg_pow_bit1]
state_before: case inl.inl
α : Type ?u.310657
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✝ : LinearOrderedRing R
a✝ : R
n✝ n : ℕ
a b : R
hab : a < b
ha : a ≤ 0
hb : b ≤ 0
⊢ (fun a => a ^ bit1 n) a < (fun a => a ^ bit1 n) b

tactic: exact pow_lt_pow_of_lt_left (neg_lt_neg hab) (neg_nonneg.2 hb) (bit1_pos (zero_le n))
state_before: case inl.inl
α : Type ?u.310657
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✝ : LinearOrderedRing R
a✝ : R
n✝ n : ℕ
a b : R
hab : a < b
ha : a ≤ 0
hb : b ≤ 0
⊢ (-b) ^ bit1 n < (-a) ^ bit1 n

tactic: exact (pow_bit1_nonpos_iff.2 ha).trans_lt (pow_bit1_pos_iff.2 hb)
state_before: case inl.inr
α : Type ?u.310657
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✝ : LinearOrderedRing R
a✝ : R
n✝ n : ℕ
a b : R
hab : a < b
ha : a ≤ 0
hb : 0 < b
⊢ (fun a => a ^ bit1 n) a < (fun a => a ^ bit1 n) b

tactic: exact pow_lt_pow_of_lt_left hab ha (bit1_pos (zero_le n))
state_before: case inr
α : Type ?u.310657
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✝ : LinearOrderedRing R
a✝ : R
n✝ n : ℕ
a b : R
hab : a < b
ha : 0 ≤ a
⊢ (fun a => a ^ bit1 n) a < (fun a => a ^ bit1 n) b
Theorem: forall_apply_eq_imp_iff'
File: Mathlib/Logic/Basic.lean

tactic: simp [forall_swap]
state_before: ι : Sort ?u.18928
α : Sort ?u.18933
κ : ι → Sort ?u.18930
p✝ q : α → Prop
β : Sort u_1
f : α → β
p : β → Prop
⊢ (∀ (b : β) (a : α), f a = b → p b) ↔ ∀ (a : α), p (f a)
Theorem: FiniteDimensional.finrank_zero_iff
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← finrank_eq_rank]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ finrank K V = 0 ↔ Module.rank K V = 0

tactic: norm_cast
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
⊢ finrank K V = 0 ↔ ↑(finrank K V) = 0
Theorem: Isometry.prod_map
File: Mathlib/Topology/MetricSpace/Isometry.lean

tactic: simp only [Prod.edist_eq, hf.edist_eq, hg.edist_eq, Prod_map]
state_before: ι : Type ?u.2341
α : Type u
β : Type v
γ : Type w
inst✝³ : PseudoEMetricSpace α
inst✝² : PseudoEMetricSpace β
inst✝¹ : PseudoEMetricSpace γ
f✝ : α → β
x✝ y✝ z : α
s : Set α
δ : Type u_1
inst✝ : PseudoEMetricSpace δ
f : α → β
g : γ → δ
hf : Isometry f
hg : Isometry g
x y : α × γ
⊢ edist (Prod.map f g x) (Prod.map f g y) = edist x y
Theorem: Odd.sub_odd
File: Mathlib/Algebra/Parity.lean

tactic: rw [sub_eq_add_neg]
state_before: F : Type ?u.105241
α : Type u_1
β : Type ?u.105247
R : Type ?u.105250
inst✝ : Ring α
a b : α
n : ℕ
ha : Odd a
hb : Odd b
⊢ Even (a - b)

tactic: exact ha.add_odd hb.neg
state_before: F : Type ?u.105241
α : Type u_1
β : Type ?u.105247
R : Type ?u.105250
inst✝ : Ring α
a b : α
n : ℕ
ha : Odd a
hb : Odd b
⊢ Even (a + -b)
Theorem: integral_re_add_im
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [← integral_ofReal, ← integral_ofReal, integral_coe_re_add_coe_im hf]
state_before: α : Type u_2
β : Type ?u.3500341
E : Type ?u.3500344
F : Type ?u.3500347
inst✝⁹ : MeasurableSpace α
ι : Type ?u.3500353
inst✝⁸ : NormedAddCommGroup E
μ : MeasureTheory.Measure α
𝕜 : Type u_1
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝³ : CompleteSpace E
inst✝² : NormedSpace ℝ E
inst✝¹ : CompleteSpace F
inst✝ : NormedSpace ℝ F
f : α → 𝕜
hf : Integrable f
⊢ ↑(∫ (x : α), ↑IsROrC.re (f x) ∂μ) + ↑(∫ (x : α), ↑IsROrC.im (f x) ∂μ) * IsROrC.I = ∫ (x : α), f x ∂μ
Theorem: Filter.principal_bind
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [sSup_image, join_principal_eq_sSup, map_principal, eq_self_iff_true]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.299672
ι : Sort x
s : Set α
f : α → Filter β
⊢ join (map f (𝓟 s)) = ⨆ (x : α) (_ : x ∈ s), f x
Theorem: SimpleGraph.incMatrix_apply_eq_one_iff
File: Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean

tactic: unfold incMatrix Set.indicator
state_before: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝¹ : MulZeroOneClass R
a b : α
e : Sym2 α
inst✝ : Nontrivial R
⊢ incMatrix R G a e = 1 ↔ e ∈ incidenceSet G a

tactic: simp only [Pi.one_apply]
state_before: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝¹ : MulZeroOneClass R
a b : α
e : Sym2 α
inst✝ : Nontrivial R
⊢ (let x := e;
      if x ∈ incidenceSet G a then OfNat.ofNat 1 x else 0) =
      1 ↔
    e ∈ incidenceSet G a

tactic: apply Iff.intro <;> intro h
state_before: R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝¹ : MulZeroOneClass R
a b : α
e : Sym2 α
inst✝ : Nontrivial R
⊢ (if e ∈ incidenceSet G a then 1 else 0) = 1 ↔ e ∈ incidenceSet G a

tactic: split at h <;> simp_all only [zero_ne_one]
state_before: case mp
R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝¹ : MulZeroOneClass R
a b : α
e : Sym2 α
inst✝ : Nontrivial R
h : (if e ∈ incidenceSet G a then 1 else 0) = 1
⊢ e ∈ incidenceSet G a

tactic: simp_all only [ite_true]
state_before: case mpr
R : Type u_1
α : Type u_2
G : SimpleGraph α
inst✝¹ : MulZeroOneClass R
a b : α
e : Sym2 α
inst✝ : Nontrivial R
h : e ∈ incidenceSet G a
⊢ (if e ∈ incidenceSet G a then 1 else 0) = 1
Theorem: Filter.range_mem_map
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [← image_univ]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.221604
ι : Sort x
f : Filter α
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ range m ∈ map m f

tactic: exact image_mem_map univ_mem
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.221604
ι : Sort x
f : Filter α
m : α → β
m' : β → γ
s : Set α
t : Set β
⊢ m '' univ ∈ map m f
Theorem: Set.Ico_add_bij
File: Mathlib/Data/Set/Intervals/Monoid.lean

tactic: rw [← Ici_inter_Iio, ← Ici_inter_Iio]
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ico a b) (Ico (a + d) (b + d))

tactic: exact
  (Ici_add_bij a d).inter_mapsTo (fun x hx => add_lt_add_right hx _) fun x hx =>
    lt_of_add_lt_add_right hx.2
state_before: M : Type u_1
inst✝¹ : OrderedCancelAddCommMonoid M
inst✝ : ExistsAddOfLE M
a b c d : M
⊢ BijOn (fun x => x + d) (Ici a ∩ Iio b) (Ici (a + d) ∩ Iio (b + d))
Theorem: Real.exp_nat_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [exp_nat_mul]
state_before: x✝ y x : ℝ
n : ℕ
⊢ ↑(exp (↑n * x)) = ↑(exp x ^ n)
Theorem: NFA.toDFA_correct
File: Mathlib/Computability/NFA.lean

tactic: ext x
state_before: α : Type u
σ σ' : Type v
M : NFA α σ
⊢ DFA.accepts (toDFA M) = accepts M

tactic: rw [mem_accepts, DFA.mem_accepts]
state_before: case h
α : Type u
σ σ' : Type v
M : NFA α σ
x : List α
⊢ x ∈ DFA.accepts (toDFA M) ↔ x ∈ accepts M

tactic: exact fun ⟨w, h2, h3⟩ => ⟨w, h3, h2⟩
state_before: case h.mpr
α : Type u
σ σ' : Type v
M : NFA α σ
x : List α
⊢ (∃ S, S ∈ M.accept ∧ S ∈ evalFrom M M.start x) → DFA.evalFrom (toDFA M) (toDFA M).start x ∈ (toDFA M).accept
Theorem: Polynomial.count_roots_le_one
File: Mathlib/FieldTheory/Separable.lean

tactic: rw [count_roots p]
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hsep : Separable p
x : R
⊢ Multiset.count x (roots p) ≤ 1

tactic: exact rootMultiplicity_le_one_of_separable hsep x
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : IsDomain R
p : R[X]
hsep : Separable p
x : R
⊢ rootMultiplicity x p ≤ 1
Theorem: symmDiff_left_comm
File: Mathlib/Order/SymmDiff.lean

tactic: simp_rw [← symmDiff_assoc, symmDiff_comm]
state_before: ι : Type ?u.72219
α : Type u_1
β : Type ?u.72225
π : ι → Type ?u.72230
inst✝ : GeneralizedBooleanAlgebra α
a b c d : α
⊢ a ∆ (b ∆ c) = b ∆ (a ∆ c)
Theorem: Cardinal.ord_univ
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: refine' le_antisymm (ord_card_le _) <| le_of_forall_lt fun o h => lt_ord.2 ?_
state_before: α : Type ?u.234443
β : Type ?u.234446
γ : Type ?u.234449
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
⊢ ord univ = Ordinal.univ

tactic: have := lift.principalSeg.{u, v}.down.1 (by simpa only [lift.principalSeg_coe] using h)
state_before: α : Type ?u.234443
β : Type ?u.234446
γ : Type ?u.234449
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : o < Ordinal.univ
⊢ card o < univ

tactic: rcases this with ⟨o, h'⟩
state_before: α : Type ?u.234443
β : Type ?u.234446
γ : Type ?u.234449
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : o < Ordinal.univ
this : ∃ a, ↑lift.principalSeg.toRelEmbedding a = o
⊢ card o < univ

tactic: rw [←h', lift.principalSeg_coe, ← lift_card]
state_before: case intro
α : Type ?u.234443
β : Type ?u.234446
γ : Type ?u.234449
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o✝ : Ordinal
h : o✝ < Ordinal.univ
o : Ordinal
h' : ↑lift.principalSeg.toRelEmbedding o = o✝
⊢ card o✝ < univ

tactic: apply lift_lt_univ'
state_before: case intro
α : Type ?u.234443
β : Type ?u.234446
γ : Type ?u.234449
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o✝ : Ordinal
h : o✝ < Ordinal.univ
o : Ordinal
h' : ↑lift.principalSeg.toRelEmbedding o = o✝
⊢ lift (card o) < univ

tactic: simpa only [lift.principalSeg_coe] using h
state_before: α : Type ?u.234443
β : Type ?u.234446
γ : Type ?u.234449
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal
h : o < Ordinal.univ
⊢ ?m.234736 < lift.principalSeg.top
Theorem: Finset.sup_eq_biUnion
File: Mathlib/Data/Finset/Lattice.lean

tactic: ext
state_before: F : Type ?u.416235
α✝ : Type ?u.416238
β✝ : Type ?u.416241
γ : Type ?u.416244
ι : Type ?u.416247
κ : Type ?u.416250
α : Type u_1
β : Type u_2
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
⊢ sup s t = Finset.biUnion s t

tactic: rw [mem_sup, mem_biUnion]
state_before: case a
F : Type ?u.416235
α✝ : Type ?u.416238
β✝ : Type ?u.416241
γ : Type ?u.416244
ι : Type ?u.416247
κ : Type ?u.416250
α : Type u_1
β : Type u_2
inst✝ : DecidableEq β
s : Finset α
t : α → Finset β
a✝ : β
⊢ a✝ ∈ sup s t ↔ a✝ ∈ Finset.biUnion s t
Theorem: Nat.choose_eq_zero_of_lt
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: have hnk : n < k := lt_of_succ_lt_succ hk
state_before: n k : ℕ
hk : n + 1 < k + 1
⊢ choose (n + 1) (k + 1) = 0

tactic: have hnk1 : n < k + 1 := lt_of_succ_lt hk
state_before: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
⊢ choose (n + 1) (k + 1) = 0

tactic: rw [choose_succ_succ, choose_eq_zero_of_lt hnk, choose_eq_zero_of_lt hnk1]
state_before: n k : ℕ
hk : n + 1 < k + 1
hnk : n < k
hnk1 : n < k + 1
⊢ choose (n + 1) (k + 1) = 0
Theorem: Pmf.bind_bind
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simpa only [ENNReal.coe_eq_coe.symm, bind_apply, ENNReal.tsum_mul_left.symm,
  ENNReal.tsum_mul_right.symm, mul_assoc, mul_left_comm, mul_comm] using ENNReal.tsum_comm
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
p : Pmf α
f : α → Pmf β
g : β → Pmf γ
b : γ
⊢ ↑(bind (bind p f) g) b = ↑(bind p fun a => bind (f a) g) b
Theorem: Real.rpow_add_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rcases hy.eq_or_lt with (rfl | hy)
state_before: x y z : ℝ
hx : 0 ≤ x
hy : 0 ≤ y
hz : 0 ≤ z
⊢ x ^ (y + z) = x ^ y * x ^ z

tactic: exact rpow_add' hx (ne_of_gt <| add_pos_of_pos_of_nonneg hy hz)
state_before: case inr
x y z : ℝ
hx : 0 ≤ x
hy✝ : 0 ≤ y
hz : 0 ≤ z
hy : 0 < y
⊢ x ^ (y + z) = x ^ y * x ^ z

tactic: rw [zero_add, rpow_zero, one_mul]
state_before: case inl
x z : ℝ
hx : 0 ≤ x
hz : 0 ≤ z
hy : 0 ≤ 0
⊢ x ^ (0 + z) = x ^ 0 * x ^ z
Theorem: Complex.cosh_sq_sub_sinh_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [sq_sub_sq, cosh_add_sinh, cosh_sub_sinh, ← exp_add, add_neg_self, exp_zero]
state_before: x y : ℂ
⊢ cosh x ^ 2 - sinh x ^ 2 = 1
Theorem: Nat.Primrec'.if_lt
File: Mathlib/Computability/Primrec.lean

tactic: cases e : b v - a v
state_before: n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
⊢ Nat.rec (g v) (fun y IH => f (Vector.tail (Vector.tail (y ::ᵥ IH ::ᵥ v)))) (b v - a v) =
    if a v < b v then f v else g v

tactic: simp [not_lt.2 (tsub_eq_zero_iff_le.mp e)]
state_before: case zero
n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
e : b v - a v = Nat.zero
⊢ Nat.rec (g v) (fun y IH => f (Vector.tail (Vector.tail (y ::ᵥ IH ::ᵥ v)))) Nat.zero = if a v < b v then f v else g v

tactic: simp [Nat.lt_of_sub_eq_succ e]
state_before: case succ
n : ℕ
a b f g : Vector ℕ n → ℕ
ha : Primrec' a
hb : Primrec' b
hf : Primrec' f
hg : Primrec' g
v : Vector ℕ n
n✝ : ℕ
e : b v - a v = Nat.succ n✝
⊢ Nat.rec (g v) (fun y IH => f (Vector.tail (Vector.tail (y ::ᵥ IH ::ᵥ v)))) (Nat.succ n✝) =
    if a v < b v then f v else g v
Theorem: MeasureTheory.ae_eq_trim_of_stronglyMeasurable
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: rwa [EventuallyEq, @ae_iff _ m, trim_measurableSet_eq hm _]
state_before: α : Type ?u.1725284
E : Type ?u.1725287
F : Type ?u.1725290
𝕜 : Type ?u.1725293
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
inst✝⁹ : CompleteSpace E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : SMulCommClass ℝ 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : CompleteSpace F
H : Type ?u.1727964
β : Type u_2
γ : Type u_1
inst✝² : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
inst✝¹ : TopologicalSpace γ
inst✝ : MetrizableSpace γ
hm : m ≤ m0
f g : β → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f =ᵐ[μ] g
⊢ f =ᵐ[Measure.trim μ hm] g

tactic: exact (hf.measurableSet_eq_fun hg).compl
state_before: α : Type ?u.1725284
E : Type ?u.1725287
F : Type ?u.1725290
𝕜 : Type ?u.1725293
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace ℝ E
inst✝⁹ : CompleteSpace E
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedSpace 𝕜 E
inst✝⁶ : SMulCommClass ℝ 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : CompleteSpace F
H : Type ?u.1727964
β : Type u_2
γ : Type u_1
inst✝² : NormedAddCommGroup H
m m0 : MeasurableSpace β
μ : Measure β
inst✝¹ : TopologicalSpace γ
inst✝ : MetrizableSpace γ
hm : m ≤ m0
f g : β → γ
hf : StronglyMeasurable f
hg : StronglyMeasurable g
hfg : f =ᵐ[μ] g
⊢ MeasurableSet {a | ¬f a = g a}
Theorem: spectrum.inv_mem_resolventSet
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: rw [mem_resolventSet_iff, Algebra.algebraMap_eq_smul_one, ← Units.smul_def] at h ⊢
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : ↑r ∈ resolventSet R ↑a
⊢ ↑r⁻¹ ∈ resolventSet R ↑a⁻¹

tactic: rw [IsUnit.smul_sub_iff_sub_inv_smul, inv_inv, IsUnit.sub_iff]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
⊢ IsUnit (r⁻¹ • 1 - ↑a⁻¹)

tactic: have h₁ : (a : A) * (r • (↑a⁻¹ : A) - 1) = r • (1 : A) - a := by
  rw [mul_sub, mul_smul_comm, a.mul_inv, mul_one]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
⊢ IsUnit (r • ↑a⁻¹ - 1)

tactic: have h₂ : (r • (↑a⁻¹ : A) - 1) * a = r • (1 : A) - a := by
  rw [sub_mul, smul_mul_assoc, a.inv_mul, one_mul]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
h₁ : ↑a * (r • ↑a⁻¹ - 1) = r • 1 - ↑a
⊢ IsUnit (r • ↑a⁻¹ - 1)

tactic: have hcomm : Commute (a : A) (r • (↑a⁻¹ : A) - 1) := by rwa [← h₂] at h₁
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
h₁ : ↑a * (r • ↑a⁻¹ - 1) = r • 1 - ↑a
h₂ : (r • ↑a⁻¹ - 1) * ↑a = r • 1 - ↑a
⊢ IsUnit (r • ↑a⁻¹ - 1)

tactic: exact (hcomm.isUnit_mul_iff.mp (h₁.symm ▸ h)).2
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
h₁ : ↑a * (r • ↑a⁻¹ - 1) = r • 1 - ↑a
h₂ : (r • ↑a⁻¹ - 1) * ↑a = r • 1 - ↑a
hcomm : Commute (↑a) (r • ↑a⁻¹ - 1)
⊢ IsUnit (r • ↑a⁻¹ - 1)

tactic: rw [mul_sub, mul_smul_comm, a.mul_inv, mul_one]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
⊢ ↑a * (r • ↑a⁻¹ - 1) = r • 1 - ↑a

tactic: rw [sub_mul, smul_mul_assoc, a.inv_mul, one_mul]
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
h₁ : ↑a * (r • ↑a⁻¹ - 1) = r • 1 - ↑a
⊢ (r • ↑a⁻¹ - 1) * ↑a = r • 1 - ↑a

tactic: rwa [← h₂] at h₁
state_before: R : Type u
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Ring A
inst✝ : Algebra R A
r : Rˣ
a : Aˣ
h : IsUnit (r • 1 - ↑a)
h₁ : ↑a * (r • ↑a⁻¹ - 1) = r • 1 - ↑a
h₂ : (r • ↑a⁻¹ - 1) * ↑a = r • 1 - ↑a
⊢ Commute (↑a) (r • ↑a⁻¹ - 1)
Theorem: IsCountablySpanning.pi
File: Mathlib/MeasureTheory/Constructions/Pi.lean

tactic: choose s h1s h2s using hC
state_before: ι : Type u_2
ι' : Type ?u.427415
α : ι → Type u_1
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
hC : ∀ (i : ι), IsCountablySpanning (C i)
⊢ IsCountablySpanning (Set.pi univ '' Set.pi univ C)

tactic: cases nonempty_encodable (ι → ℕ)
state_before: ι : Type u_2
ι' : Type ?u.427415
α : ι → Type u_1
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
s : (i : ι) → ℕ → Set (α i)
h1s : ∀ (i : ι) (n : ℕ), s i n ∈ C i
h2s : ∀ (i : ι), (⋃ (n : ℕ), s i n) = univ
⊢ IsCountablySpanning (Set.pi univ '' Set.pi univ C)

tactic: let e : ℕ → ι → ℕ := fun n => (@decode (ι → ℕ) _ n).iget
state_before: case intro
ι : Type u_2
ι' : Type ?u.427415
α : ι → Type u_1
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
s : (i : ι) → ℕ → Set (α i)
h1s : ∀ (i : ι) (n : ℕ), s i n ∈ C i
h2s : ∀ (i : ι), (⋃ (n : ℕ), s i n) = univ
val✝ : Encodable (ι → ℕ)
⊢ IsCountablySpanning (Set.pi univ '' Set.pi univ C)

tactic: refine' ⟨fun n => Set.pi univ fun i => s i (e n i), fun n =>
  mem_image_of_mem _ fun i _ => h1s i _, _⟩
state_before: case intro
ι : Type u_2
ι' : Type ?u.427415
α : ι → Type u_1
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
s : (i : ι) → ℕ → Set (α i)
h1s : ∀ (i : ι) (n : ℕ), s i n ∈ C i
h2s : ∀ (i : ι), (⋃ (n : ℕ), s i n) = univ
val✝ : Encodable (ι → ℕ)
e : ℕ → ι → ℕ := fun n => Option.iget (decode n)
⊢ IsCountablySpanning (Set.pi univ '' Set.pi univ C)

tactic: simp_rw [(surjective_decode_iget (ι → ℕ)).iUnion_comp fun x => Set.pi univ fun i => s i (x i),
  iUnion_univ_pi s, h2s, pi_univ]
state_before: case intro
ι : Type u_2
ι' : Type ?u.427415
α : ι → Type u_1
inst✝¹ : Finite ι
inst✝ : Finite ι'
C : (i : ι) → Set (Set (α i))
s : (i : ι) → ℕ → Set (α i)
h1s : ∀ (i : ι) (n : ℕ), s i n ∈ C i
h2s : ∀ (i : ι), (⋃ (n : ℕ), s i n) = univ
val✝ : Encodable (ι → ℕ)
e : ℕ → ι → ℕ := fun n => Option.iget (decode n)
⊢ (⋃ (n : ℕ), (fun n => Set.pi univ fun i => s i (e n i)) n) = univ
Theorem: Order.lt_succ_bot_iff
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [lt_succ_iff, le_bot_iff]
state_before: α : Type u_1
inst✝³ : PartialOrder α
inst✝² : SuccOrder α
a b : α
inst✝¹ : OrderBot α
inst✝ : NoMaxOrder α
⊢ a < succ ⊥ ↔ a = ⊥
Theorem: Set.image2_iUnion₂_right
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [image2_iUnion_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort ?u.249989
ι₂ : Sort ?u.249992
κ : ι → Sort u_5
κ₁ : ι → Sort ?u.250002
κ₂ : ι → Sort ?u.250007
κ' : ι' → Sort ?u.250012
f : α → β → γ
s✝ : Set α
t✝ : Set β
s : Set α
t : (i : ι) → κ i → Set β
⊢ image2 f s (⋃ (i : ι) (j : κ i), t i j) = ⋃ (i : ι) (j : κ i), image2 f s (t i j)
Theorem: MeasureTheory.Measure.rnDeriv_lt_top
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: suffices ∀ n, ∀ᵐ x ∂ν, x ∈ spanningSets μ n → μ.rnDeriv ν x < ∞ by
  filter_upwards [ae_all_iff.2 this] with _ hx using hx _ (mem_spanningSetsIndex _ _)
state_before: α : Type u_1
β : Type ?u.38973
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
⊢ ∀ᵐ (x : α) ∂ν, rnDeriv μ ν x < ⊤

tactic: intro n
state_before: α : Type u_1
β : Type ?u.38973
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
⊢ ∀ (n : ℕ), ∀ᵐ (x : α) ∂ν, x ∈ spanningSets μ n → rnDeriv μ ν x < ⊤

tactic: rw [← ae_restrict_iff' (measurable_spanningSets _ _)]
state_before: α : Type u_1
β : Type ?u.38973
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
n : ℕ
⊢ ∀ᵐ (x : α) ∂ν, x ∈ spanningSets μ n → rnDeriv μ ν x < ⊤

tactic: apply ae_lt_top (measurable_rnDeriv _ _)
state_before: α : Type u_1
β : Type ?u.38973
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
n : ℕ
⊢ ∀ᵐ (x : α) ∂restrict ν (spanningSets μ n), rnDeriv μ ν x < ⊤

tactic: refine' (lintegral_rnDeriv_lt_top_of_measure_ne_top _ _).ne
state_before: α : Type u_1
β : Type ?u.38973
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
n : ℕ
⊢ (∫⁻ (x : α) in spanningSets μ n, rnDeriv μ ν x ∂ν) ≠ ⊤

tactic: exact (measure_spanningSets_lt_top _ _).ne
state_before: α : Type u_1
β : Type ?u.38973
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
n : ℕ
⊢ ↑↑μ (spanningSets μ n) ≠ ⊤

tactic: filter_upwards [ae_all_iff.2 this] with _ hx using hx _ (mem_spanningSetsIndex _ _)
state_before: α : Type u_1
β : Type ?u.38973
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
inst✝ : SigmaFinite μ
this : ∀ (n : ℕ), ∀ᵐ (x : α) ∂ν, x ∈ spanningSets μ n → rnDeriv μ ν x < ⊤
⊢ ∀ᵐ (x : α) ∂ν, rnDeriv μ ν x < ⊤
Theorem: Multiset.filter_cons_of_pos
File: Mathlib/Data/Multiset/Basic.lean

tactic: simpa using h
state_before: α : Type u_1
β : Type ?u.209487
γ : Type ?u.209490
p : α → Prop
inst✝ : DecidablePred p
a : α
s : Multiset α
l : List α
h : p a
⊢ decide (p a) = true
Theorem: Finset.image₂_comm
File: Mathlib/Data/Finset/NAry.lean

tactic: simp_rw [h_comm]
state_before: α : Type u_2
α' : Type ?u.72072
β : Type u_3
β' : Type ?u.72078
γ : Type u_1
γ' : Type ?u.72084
δ : Type ?u.72087
δ' : Type ?u.72090
ε : Type ?u.72093
ε' : Type ?u.72096
ζ : Type ?u.72099
ζ' : Type ?u.72102
ν : Type ?u.72105
inst✝⁷ : DecidableEq α'
inst✝⁶ : DecidableEq β'
inst✝⁵ : DecidableEq γ
inst✝⁴ : DecidableEq γ'
inst✝³ : DecidableEq δ
inst✝² : DecidableEq δ'
inst✝¹ : DecidableEq ε
inst✝ : DecidableEq ε'
f f' : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Finset α
t t' : Finset β
u u' : Finset γ
a a' : α
b b' : β
c : γ
g : β → α → γ
h_comm : ∀ (a : α) (b : β), f a b = g b a
⊢ image₂ (fun a b => f b a) t s = image₂ g t s