tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.limsup_ae_eq_of_forall_ae_eq
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp_rw [ae_eq_set] at h⊢
state_before: α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), s n =ᵐ[μ] t
⊢ limsup s atTop =ᵐ[μ] t

tactic: constructor
state_before: α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (limsup s atTop \ t) = 0 ∧ ↑↑μ (t \ limsup s atTop) = 0

tactic: rw [atTop.limsup_sdiff s t]
state_before: case left
α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (limsup s atTop \ t) = 0

tactic: apply measure_limsup_eq_zero
state_before: case left
α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (limsup (fun b => s b \ t) atTop) = 0

tactic: simp [h]
state_before: case left.hs
α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ (∑' (i : ℕ), ↑↑μ (s i \ t)) ≠ ⊤

tactic: rw [atTop.sdiff_limsup s t]
state_before: case right
α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (t \ limsup s atTop) = 0

tactic: apply measure_liminf_eq_zero
state_before: case right
α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ ↑↑μ (liminf (fun b => t \ s b) atTop) = 0

tactic: simp [h]
state_before: case right.h
α : Type u_1
β : Type ?u.75562
γ : Type ?u.75565
δ : Type ?u.75568
ι : Type ?u.75571
R : Type ?u.75574
R' : Type ?u.75577
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t✝ : Set α
s : ℕ → Set α
t : Set α
h : ∀ (n : ℕ), ↑↑μ (s n \ t) = 0 ∧ ↑↑μ (t \ s n) = 0
⊢ (∑' (i : ℕ), ↑↑μ (t \ s i)) ≠ ⊤
Theorem: TopCat.of_homeoOfIso
File: Mathlib/Topology/Category/TopCat/Basic.lean

tactic: dsimp [homeoOfIso, isoOfHomeo]
state_before: X Y : TopCat
f : X ≅ Y
⊢ isoOfHomeo (homeoOfIso f) = f

tactic: ext
state_before: X Y : TopCat
f : X ≅ Y
⊢ Iso.mk
      (Homeomorph.toContinuousMap
        (Homeomorph.mk
          { toFun := (forget TopCat).map f.hom, invFun := (forget TopCat).map f.inv,
            left_inv := (_ : ∀ (x : ↑X), (forget TopCat).map f.inv ((forget TopCat).map f.hom x) = x),
            right_inv := (_ : ∀ (x : ↑Y), (forget TopCat).map f.hom ((forget TopCat).map f.inv x) = x) }))
      (Homeomorph.toContinuousMap
        (Homeomorph.symm
          (Homeomorph.mk
            { toFun := (forget TopCat).map f.hom, invFun := (forget TopCat).map f.inv,
              left_inv := (_ : ∀ (x : ↑X), (forget TopCat).map f.inv ((forget TopCat).map f.hom x) = x),
              right_inv := (_ : ∀ (x : ↑Y), (forget TopCat).map f.hom ((forget TopCat).map f.inv x) = x) }))) =
    f

tactic: rfl
state_before: case w.w
X Y : TopCat
f : X ≅ Y
x✝ : (forget TopCat).obj X
⊢ (forget TopCat).map
      (Iso.mk
          (Homeomorph.toContinuousMap
            (Homeomorph.mk
              { toFun := (forget TopCat).map f.hom, invFun := (forget TopCat).map f.inv,
                left_inv := (_ : ∀ (x : ↑X), (forget TopCat).map f.inv ((forget TopCat).map f.hom x) = x),
                right_inv := (_ : ∀ (x : ↑Y), (forget TopCat).map f.hom ((forget TopCat).map f.inv x) = x) }))
          (Homeomorph.toContinuousMap
            (Homeomorph.symm
              (Homeomorph.mk
                { toFun := (forget TopCat).map f.hom, invFun := (forget TopCat).map f.inv,
                  left_inv := (_ : ∀ (x : ↑X), (forget TopCat).map f.inv ((forget TopCat).map f.hom x) = x),
                  right_inv := (_ : ∀ (x : ↑Y), (forget TopCat).map f.hom ((forget TopCat).map f.inv x) = x) })))).hom
      x✝ =
    (forget TopCat).map f.hom x✝
Theorem: CompositionSeries.append_castAdd
File: Mathlib/Order/JordanHolder.lean

tactic: rw [coe_append, append_castAdd_aux _ _ i]
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : top s₁ = bot s₂
i : Fin s₁.length
⊢ series (append s₁ s₂ h) (↑Fin.castSucc (↑(Fin.castAdd s₂.length) i)) = series s₁ (↑Fin.castSucc i)
Theorem: List.nil_bagInter
File: Mathlib/Data/List/Lattice.lean

tactic: cases l <;> rfl
state_before: α : Type u_1
l✝ l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
l : List α
⊢ List.bagInter [] l = []
Theorem: Matrix.nonsing_inv_apply
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

tactic: rw [inv_def, ← Ring.inverse_unit h.unit, IsUnit.unit_spec]
state_before: l : Type ?u.101841
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A B : Matrix n n α
h : IsUnit (det A)
⊢ A⁻¹ = ↑(IsUnit.unit h)⁻¹ • adjugate A
Theorem: Matrix.det_updateColumn_add
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [← det_transpose, ← updateRow_transpose, det_updateRow_add]
state_before: m : Type ?u.1639172
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
u v : n → R
⊢ det (updateColumn M j (u + v)) = det (updateColumn M j u) + det (updateColumn M j v)

tactic: simp [updateRow_transpose, det_transpose]
state_before: m : Type ?u.1639172
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
M : Matrix n n R
j : n
u v : n → R
⊢ det (updateRow Mᵀ j u) + det (updateRow Mᵀ j v) = det (updateColumn M j u) + det (updateColumn M j v)
Theorem: Polynomial.Monic.expand
File: Mathlib/Data/Polynomial/Expand.lean

tactic: rw [Monic.def, Polynomial.leadingCoeff, natDegree_expand, coeff_expand hp]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
f : R[X]
hp : 0 < p
h : Monic f
⊢ Monic (↑(Polynomial.expand R p) f)

tactic: simp [hp, h]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p✝ q p : ℕ
f : R[X]
hp : 0 < p
h : Monic f
⊢ (if p ∣ natDegree f * p then coeff f (natDegree f * p / p) else 0) = 1
Theorem: CategoryTheory.isPreconnected_induction
File: Mathlib/CategoryTheory/IsConnected.lean

tactic: rintro ⟨y⟩
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
⊢ j₁✝ ∈ {j | Nonempty (Z j)} → j₂✝ ∈ {j | Nonempty (Z j)}

tactic: exact ⟨h₁ f y⟩
state_before: case intro
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
y : Z j₁✝
⊢ j₂✝ ∈ {j | Nonempty (Z j)}

tactic: rintro ⟨y⟩
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
⊢ j₂✝ ∈ {j | Nonempty (Z j)} → j₁✝ ∈ {j | Nonempty (Z j)}

tactic: exact ⟨h₂ f y⟩
state_before: case intro
J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
inst✝ : IsPreconnected J
Z : J → Sort u_1
h₁ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₁ → Z j₂
h₂ : {j₁ j₂ : J} → (j₁ ⟶ j₂) → Z j₂ → Z j₁
j₀ : J
x : Z j₀
j j₁✝ j₂✝ : J
f : j₁✝ ⟶ j₂✝
y : Z j₂✝
⊢ j₁✝ ∈ {j | Nonempty (Z j)}
Theorem: List.pairwise_of_forall
File: Mathlib/Data/List/Pairwise.lean

tactic: induction l <;> [exact Pairwise.nil; simp only [*, pairwise_cons, forall₂_true_iff, and_true_iff]]
state_before: α : Type u_1
β : Type ?u.3869
R S T : α → α → Prop
a : α
l✝ l : List α
H : ∀ (x y : α), R x y
⊢ Pairwise R l
Theorem: MvPolynomial.hom_congr_vars
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: ext <;> simp
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.682541
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f₁ f₂ : MvPolynomial σ R →+* S
p₁ p₂ : MvPolynomial σ R
hC : RingHom.comp f₁ C = RingHom.comp f₂ C
hv : ∀ (i : σ), i ∈ vars p₁ → i ∈ vars p₂ → ↑f₁ (X i) = ↑f₂ (X i)
hp : p₁ = p₂
⊢ f₁ = eval₂Hom (RingHom.comp f₁ C) (↑f₁ ∘ X)

tactic: ext <;> simp
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.682541
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f₁ f₂ : MvPolynomial σ R →+* S
p₁ p₂ : MvPolynomial σ R
hC : RingHom.comp f₁ C = RingHom.comp f₂ C
hv : ∀ (i : σ), i ∈ vars p₁ → i ∈ vars p₂ → ↑f₁ (X i) = ↑f₂ (X i)
hp : p₁ = p₂
⊢ eval₂Hom (RingHom.comp f₂ C) (↑f₂ ∘ X) = f₂
Theorem: Set.injective_piecewise_iff
File: Mathlib/Data/Set/Function.lean

tactic: rw [injective_iff_injOn_univ, ← union_compl_self s, injOn_union (@disjoint_compl_right _ _ s),
  (piecewise_eqOn s f g).injOn_iff, (piecewise_eqOn_compl s f g).injOn_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.96342
ι : Sort ?u.96345
π : α → Type ?u.96350
δ : α → Sort ?u.96355
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
⊢ Injective (piecewise s f g) ↔ InjOn f s ∧ InjOn g (sᶜ) ∧ ∀ (x : α), x ∈ s → ∀ (y : α), ¬y ∈ s → f x ≠ g y

tactic: refine' and_congr Iff.rfl (and_congr Iff.rfl <| forall₄_congr fun x hx y hy => _)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.96342
ι : Sort ?u.96345
π : α → Type ?u.96350
δ : α → Sort ?u.96355
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
⊢ (InjOn f s ∧ InjOn g (sᶜ) ∧ ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ sᶜ → piecewise s f g x ≠ piecewise s f g y) ↔
    InjOn f s ∧ InjOn g (sᶜ) ∧ ∀ (x : α), x ∈ s → ∀ (y : α), ¬y ∈ s → f x ≠ g y

tactic: rw [piecewise_eq_of_mem s f g hx, piecewise_eq_of_not_mem s f g hy]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.96342
ι : Sort ?u.96345
π : α → Type ?u.96350
δ : α → Sort ?u.96355
s : Set α
f✝ g✝ : (i : α) → δ i
inst✝ : (j : α) → Decidable (j ∈ s)
f g : α → β
x : α
hx : x ∈ s
y : α
hy : y ∈ sᶜ
⊢ piecewise s f g x ≠ piecewise s f g y ↔ f x ≠ g y
Theorem: Equiv.swap_comp_apply
File: Mathlib/Logic/Equiv/Basic.lean

tactic: cases π
state_before: α : Sort u_1
inst✝ : DecidableEq α
a b x : α
π : Perm α
⊢ ↑(π.trans (swap a b)) x = if ↑π x = a then b else if ↑π x = b then a else ↑π x

tactic: rfl
state_before: case mk
α : Sort u_1
inst✝ : DecidableEq α
a b x : α
toFun✝ invFun✝ : α → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ ↑({ toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }.trans (swap a b)) x =
    if ↑{ toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x = a then b
    else
      if ↑{ toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x = b then a
      else ↑{ toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } x
Theorem: isAddCyclic_of_card_pow_eq_one_le
File: Mathlib/GroupTheory/SpecificGroups/Cyclic.lean

tactic: obtain ⟨g, hg⟩ := (@isCyclic_of_card_pow_eq_one_le (Multiplicative α) _ _ (_) hn)
state_before: α✝ : Type u
a : α✝
inst✝⁵ : Group α✝
inst✝⁴ : DecidableEq α✝
inst✝³ : Fintype α✝
hn✝ : ∀ (n : ℕ), 0 < n → card (filter (fun a => a ^ n = 1) univ) ≤ n
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → card (filter (fun a => n • a = 0) univ) ≤ n
⊢ IsAddCyclic α

tactic: exact ⟨⟨g, hg⟩⟩
state_before: case mk.intro
α✝ : Type u
a : α✝
inst✝⁵ : Group α✝
inst✝⁴ : DecidableEq α✝
inst✝³ : Fintype α✝
hn✝ : ∀ (n : ℕ), 0 < n → card (filter (fun a => a ^ n = 1) univ) ≤ n
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : DecidableEq α
inst✝ : Fintype α
hn : ∀ (n : ℕ), 0 < n → card (filter (fun a => n • a = 0) univ) ≤ n
g : Multiplicative α
hg : ∀ (x : Multiplicative α), x ∈ zpowers g
⊢ IsAddCyclic α
Theorem: Rat.mul_nonneg
File: Mathlib/Data/Rat/Order.lean

tactic: rw [← nonneg_iff_zero_le] at ha hb⊢
state_before: a✝ b✝ c a b : ℚ
ha : 0 ≤ a
hb : 0 ≤ b
⊢ 0 ≤ a * b

tactic: exact Rat.nonneg_mul ha hb
state_before: a✝ b✝ c a b : ℚ
ha : Rat.Nonneg a
hb : Rat.Nonneg b
⊢ Rat.Nonneg (a * b)
Theorem: padicNormE.norm_int_le_one
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: simpa
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
this : ‖↑↑z‖ ≤ 1
⊢ ‖↑z‖ ≤ 1

tactic: simp [hp.1.ne_one]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
z : ℤ
⊢ ¬p ∣ (↑z).den
Theorem: List.pairwise_map
File: Std/Data/List/Lemmas.lean

tactic: induction l
state_before: α : Type u_1
α✝ : Type u_2
f : α → α✝
R : α✝ → α✝ → Prop
l : List α
⊢ Pairwise R (map f l) ↔ Pairwise (fun a b => R (f a) (f b)) l

tactic: . simp
state_before: case nil
α : Type u_1
α✝ : Type u_2
f : α → α✝
R : α✝ → α✝ → Prop
⊢ Pairwise R (map f []) ↔ Pairwise (fun a b => R (f a) (f b)) []

case cons
α : Type u_1
α✝ : Type u_2
f : α → α✝
R : α✝ → α✝ → Prop
head✝ : α
tail✝ : List α
tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝
⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝)

tactic: . simp only [map, pairwise_cons, forall_mem_map_iff, *]
state_before: case cons
α : Type u_1
α✝ : Type u_2
f : α → α✝
R : α✝ → α✝ → Prop
head✝ : α
tail✝ : List α
tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝
⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝)

tactic: simp
state_before: case nil
α : Type u_1
α✝ : Type u_2
f : α → α✝
R : α✝ → α✝ → Prop
⊢ Pairwise R (map f []) ↔ Pairwise (fun a b => R (f a) (f b)) []

tactic: simp only [map, pairwise_cons, forall_mem_map_iff, *]
state_before: case cons
α : Type u_1
α✝ : Type u_2
f : α → α✝
R : α✝ → α✝ → Prop
head✝ : α
tail✝ : List α
tail_ih✝ : Pairwise R (map f tail✝) ↔ Pairwise (fun a b => R (f a) (f b)) tail✝
⊢ Pairwise R (map f (head✝ :: tail✝)) ↔ Pairwise (fun a b => R (f a) (f b)) (head✝ :: tail✝)
Theorem: finSuccEquiv'_below
File: Mathlib/Logic/Equiv/Fin.lean

tactic: rw [← Fin.succAbove_below _ _ h, finSuccEquiv'_succAbove]
state_before: m✝ n : ℕ
i : Fin (n + 1)
m : Fin n
h : ↑Fin.castSucc m < i
⊢ ↑(finSuccEquiv' i) (↑Fin.castSucc m) = some m
Theorem: Equiv.Perm.cycleFactorsFinset_eq_singleton_self_iff
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: simp [cycleFactorsFinset_eq_finset]
state_before: ι : Type ?u.2751377
α : Type u_1
β : Type ?u.2751383
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f : Perm α
⊢ cycleFactorsFinset f = {f} ↔ IsCycle f
Theorem: sdiff_sdiff_sup_sdiff'
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_sdiff_right, sdiff_sdiff_right]
state_before: α : Type u
β : Type ?u.33026
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ z \ (x \ y) ⊓ z \ (y \ x) = (z \ x ⊔ z ⊓ x ⊓ y) ⊓ (z \ y ⊔ z ⊓ y ⊓ x)

tactic: ac_rfl
state_before: α : Type u
β : Type ?u.33026
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ (z \ x ⊔ z ⊓ x ⊓ y) ⊓ (z \ y ⊔ z ⊓ y ⊓ x) = (z \ x ⊔ z ⊓ y ⊓ x) ⊓ (z \ y ⊔ z ⊓ y ⊓ x)

tactic: ac_rfl
state_before: α : Type u
β : Type ?u.33026
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ z \ x ⊓ z \ y ⊔ z ⊓ y ⊓ x = z ⊓ x ⊓ y ⊔ z \ x ⊓ z \ y
Theorem: Complex.tan_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: convert tan_add_mul_I h
state_before: z : ℂ
h :
  ((∀ (k : ℤ), ↑z.re ≠ (2 * ↑k + 1) * ↑π / 2) ∧ ∀ (l : ℤ), ↑z.im * I ≠ (2 * ↑l + 1) * ↑π / 2) ∨
    (∃ k, ↑z.re = (2 * ↑k + 1) * ↑π / 2) ∧ ∃ l, ↑z.im * I = (2 * ↑l + 1) * ↑π / 2
⊢ tan z = (tan ↑z.re + tanh ↑z.im * I) / (1 - tan ↑z.re * tanh ↑z.im * I)

tactic: exact (re_add_im z).symm
state_before: case h.e'_2.h.e'_1
z : ℂ
h :
  ((∀ (k : ℤ), ↑z.re ≠ (2 * ↑k + 1) * ↑π / 2) ∧ ∀ (l : ℤ), ↑z.im * I ≠ (2 * ↑l + 1) * ↑π / 2) ∨
    (∃ k, ↑z.re = (2 * ↑k + 1) * ↑π / 2) ∧ ∃ l, ↑z.im * I = (2 * ↑l + 1) * ↑π / 2
⊢ z = ↑z.re + ↑z.im * I
Theorem: Finset.card_Ioc_finset
File: Mathlib/Data/Finset/Interval.lean

tactic: rw [card_Ioc_eq_card_Icc_sub_one, card_Icc_finset h]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
h : s ⊆ t
⊢ card (Ioc s t) = 2 ^ (card t - card s) - 1
Theorem: Mathlib.Meta.NormNum.isRat_sub
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rw [hf, sub_eq_add_neg]
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : Int.sub (Int.mul na ↑db) (Int.mul nb ↑da) = Int.mul (↑k) nc
h₂ : Nat.mul da db = Nat.mul k dc
⊢ IsRat (f a b) nc dc

tactic: refine isRat_add rfl ra (isRat_neg (n' := -nb) rfl rb rfl) (k := k) (nc := nc) ?_ h₂
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : Int.sub (Int.mul na ↑db) (Int.mul nb ↑da) = Int.mul (↑k) nc
h₂ : Nat.mul da db = Nat.mul k dc
⊢ IsRat (a + -b) nc dc

tactic: rw [show Int.mul (-nb) _ = _ from neg_mul ..]
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : Int.sub (Int.mul na ↑db) (Int.mul nb ↑da) = Int.mul (↑k) nc
h₂ : Nat.mul da db = Nat.mul k dc
⊢ Int.add (Int.mul na ↑db) (Int.mul (-nb) ↑da) = Int.mul (↑k) nc

tactic: exact h₁
state_before: α : Type u_1
inst✝ : Ring α
f : α → α → α
a b : α
na nb nc : ℤ
da db dc k : ℕ
hf : f = HSub.hSub
ra : IsRat a na da
rb : IsRat b nb db
h₁ : Int.sub (Int.mul na ↑db) (Int.mul nb ↑da) = Int.mul (↑k) nc
h₂ : Nat.mul da db = Nat.mul k dc
⊢ Int.add (Int.mul na ↑db) (-(nb * ↑da)) = Int.mul (↑k) nc
Theorem: interval_average_eq_div
File: Mathlib/MeasureTheory/Integral/IntervalAverage.lean

tactic: rw [interval_average_eq, smul_eq_mul, div_eq_inv_mul]
state_before: E : Type ?u.12725
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f : ℝ → ℝ
a b : ℝ
⊢ (⨍ (x : ℝ) in Ι a b, f x) = (∫ (x : ℝ) in a..b, f x) / (b - a)
Theorem: MeasureTheory.set_lintegral_withDensity_eq_set_lintegral_mul
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [restrict_withDensity hs, lintegral_withDensity_eq_lintegral_mul _ hf hg]
state_before: α : Type u_1
β : Type ?u.1801194
γ : Type ?u.1801197
δ : Type ?u.1801200
m m0 : MeasurableSpace α
μ : Measure α
f g : α → ℝ≥0∞
hf : Measurable f
hg : Measurable g
s : Set α
hs : MeasurableSet s
⊢ (∫⁻ (x : α) in s, g x ∂Measure.withDensity μ f) = ∫⁻ (x : α) in s, (f * g) x ∂μ
Theorem: Representation.asAlgebraHom_single
File: Mathlib/RepresentationTheory/Basic.lean

tactic: simp only [asAlgebraHom_def, MonoidAlgebra.lift_single]
state_before: k : Type u_2
G : Type u_3
V : Type u_1
inst✝³ : CommSemiring k
inst✝² : Monoid G
inst✝¹ : AddCommMonoid V
inst✝ : Module k V
ρ : Representation k G V
g : G
r : k
⊢ ↑(asAlgebraHom ρ) (Finsupp.single g r) = r • ↑ρ g
Theorem: le_geom
File: Mathlib/Analysis/SpecificLimits/Basic.lean

tactic: apply (monotone_mul_left_of_nonneg hc).seq_le_seq n _ h _ <;>
  simp [_root_.pow_succ, mul_assoc, le_refl]
state_before: α : Type ?u.38546
β : Type ?u.38549
ι : Type ?u.38552
u : ℕ → ℝ
c : ℝ
hc : 0 ≤ c
n : ℕ
h : ∀ (k : ℕ), k < n → u (k + 1) ≤ c * u k
⊢ u n ≤ c ^ n * u 0
Theorem: MulChar.IsQuadratic.pow_even
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: obtain ⟨n, rfl⟩ := even_iff_two_dvd.mp hn
state_before: R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
n : ℕ
hn : Even n
⊢ χ ^ n = 1

tactic: rw [pow_mul, hχ.sq_eq_one, one_pow]
state_before: case intro
R : Type u
inst✝² : CommRing R
R' : Type v
inst✝¹ : CommRing R'
R'' : Type w
inst✝ : CommRing R''
χ : MulChar R R'
hχ : IsQuadratic χ
n : ℕ
hn : Even (2 * n)
⊢ χ ^ (2 * n) = 1
Theorem: Sylow.card_normalizer_modEq_card
File: Mathlib/GroupTheory/Sylow.lean

tactic: have : H.subgroupOf (normalizer H) ≃ H := (subgroupOfEquivOfLe le_normalizer).toEquiv
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
⊢ Fintype.card { x // x ∈ normalizer H } ≡ Fintype.card G [MOD p ^ (n + 1)]

tactic: rw [card_eq_card_quotient_mul_card_subgroup H,
  card_eq_card_quotient_mul_card_subgroup (H.subgroupOf (normalizer H)), Fintype.card_congr this,
  hH, pow_succ]
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
this : { x // x ∈ subgroupOf H (normalizer H) } ≃ { x // x ∈ H }
⊢ Fintype.card { x // x ∈ normalizer H } ≡ Fintype.card G [MOD p ^ (n + 1)]

tactic: exact (card_quotient_normalizer_modEq_card_quotient hH).mul_right' _
state_before: G : Type u
α : Type v
β : Type w
inst✝¹ : Group G
inst✝ : Fintype G
p n : ℕ
hp : Fact (Nat.Prime p)
H : Subgroup G
hH : Fintype.card { x // x ∈ H } = p ^ n
this : { x // x ∈ subgroupOf H (normalizer H) } ≃ { x // x ∈ H }
⊢ Fintype.card ({ x // x ∈ normalizer H } ⧸ subgroupOf H (normalizer H)) * p ^ n ≡ Fintype.card (G ⧸ H) * p ^ n [MOD
    p * p ^ n]
Theorem: OrderIso.preimage_Ioc
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a b : β
⊢ ↑e ⁻¹' Ioc a b = Ioc (↑(symm e) a) (↑(symm e) b)
Theorem: Submodule.pow_eq_span_pow_set
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rw [← span_pow, span_eq]
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n✝ : A
n : ℕ
⊢ M ^ n = span R (↑M ^ n)
Theorem: lowerSemicontinuousAt_iSup
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
β : Type ?u.119406
inst✝² : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
ι : Sort u_3
δ : Type u_2
δ' : Type ?u.119438
inst✝¹ : CompleteLinearOrder δ
inst✝ : ConditionallyCompleteLinearOrder δ'
f : ι → α → δ
h : ∀ (i : ι), LowerSemicontinuousAt (f i) x
⊢ ∀ᶠ (y : α) in 𝓝 x, BddAbove (range fun i => f i y)
Theorem: CategoryTheory.Iso.refl_conj
File: Mathlib/CategoryTheory/Conj.lean

tactic: rw [conj_apply, Iso.refl_inv, Iso.refl_hom, Category.id_comp, Category.comp_id]
state_before: C : Type u
inst✝ : Category C
X Y : C
α : X ≅ Y
f : End X
⊢ ↑(conj (refl X)) f = f
Theorem: Matrix.conjTranspose_smul_non_comm
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [h]
state_before: l : Type ?u.972645
m : Type u_2
n : Type u_3
o : Type ?u.972654
m' : o → Type ?u.972659
n' : o → Type ?u.972664
R : Type u_1
S : Type ?u.972670
α : Type v
β : Type w
γ : Type ?u.972677
inst✝³ : Star R
inst✝² : Star α
inst✝¹ : SMul R α
inst✝ : SMul Rᵐᵒᵖ α
c : R
M : Matrix m n α
h : ∀ (r : R) (a : α), star (r • a) = MulOpposite.op (star r) • star a
⊢ ∀ (i : n) (j : m), (c • M)ᴴ i j = (MulOpposite.op (star c) • Mᴴ) i j