tasksource/leandojo huggingface dataset:
Theorem: TensorProduct.map_smul_left
File: Mathlib/LinearAlgebra/TensorProduct.lean

tactic: ext
state_before: R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type ?u.995671
inst✝¹⁷ : Monoid R'
R'' : Type ?u.995677
inst✝¹⁶ : Semiring R''
M : Type u_2
N : Type u_4
P : Type u_3
Q : Type u_5
S : Type ?u.995695
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type ?u.996822
Q' : Type ?u.996825
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
⊢ map (r • f) g = r • map f g

tactic: simp only [smul_tmul, compr₂_apply, mk_apply, map_tmul, smul_apply, tmul_smul]
state_before: case H.h.h
R : Type u_1
inst✝¹⁸ : CommSemiring R
R' : Type ?u.995671
inst✝¹⁷ : Monoid R'
R'' : Type ?u.995677
inst✝¹⁶ : Semiring R''
M : Type u_2
N : Type u_4
P : Type u_3
Q : Type u_5
S : Type ?u.995695
inst✝¹⁵ : AddCommMonoid M
inst✝¹⁴ : AddCommMonoid N
inst✝¹³ : AddCommMonoid P
inst✝¹² : AddCommMonoid Q
inst✝¹¹ : AddCommMonoid S
inst✝¹⁰ : Module R M
inst✝⁹ : Module R N
inst✝⁸ : Module R P
inst✝⁷ : Module R Q
inst✝⁶ : Module R S
inst✝⁵ : DistribMulAction R' M
inst✝⁴ : Module R'' M
P' : Type ?u.996822
Q' : Type ?u.996825
inst✝³ : AddCommMonoid P'
inst✝² : Module R P'
inst✝¹ : AddCommMonoid Q'
inst✝ : Module R Q'
r : R
f : M →ₗ[R] P
g : N →ₗ[R] Q
x✝¹ : M
x✝ : N
⊢ ↑(↑(compr₂ (mk R M N) (map (r • f) g)) x✝¹) x✝ = ↑(↑(compr₂ (mk R M N) (r • map f g)) x✝¹) x✝
Theorem: Path.trans_pi_eq_pi_trans
File: Mathlib/Topology/PathConnected.lean

tactic: ext (t i)
state_before: X : Type ?u.424517
Y : Type ?u.424520
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_2
γ : Path x y
χ : ι → Type u_1
inst✝ : (i : ι) → TopologicalSpace (χ i)
as bs cs : (i : ι) → χ i
γ₀ : (i : ι) → Path (as i) (bs i)
γ₁ : (i : ι) → Path (bs i) (cs i)
⊢ trans (Path.pi γ₀) (Path.pi γ₁) = Path.pi fun i => trans (γ₀ i) (γ₁ i)

tactic: unfold Path.trans
state_before: case a.h.h
X : Type ?u.424517
Y : Type ?u.424520
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_2
γ : Path x y
χ : ι → Type u_1
inst✝ : (i : ι) → TopologicalSpace (χ i)
as bs cs : (i : ι) → χ i
γ₀ : (i : ι) → Path (as i) (bs i)
γ₁ : (i : ι) → Path (bs i) (cs i)
t : ↑I
i : ι
⊢ ↑(trans (Path.pi γ₀) (Path.pi γ₁)) t i = ↑(Path.pi fun i => trans (γ₀ i) (γ₁ i)) t i

tactic: simp only [Path.coe_mk_mk, Function.comp_apply, pi_coe]
state_before: case a.h.h
X : Type ?u.424517
Y : Type ?u.424520
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_2
γ : Path x y
χ : ι → Type u_1
inst✝ : (i : ι) → TopologicalSpace (χ i)
as bs cs : (i : ι) → χ i
γ₀ : (i : ι) → Path (as i) (bs i)
γ₁ : (i : ι) → Path (bs i) (cs i)
t : ↑I
i : ι
⊢ ↑{
          toContinuousMap :=
            ContinuousMap.mk
              ((fun t => if t ≤ 1 / 2 then extend (Path.pi γ₀) (2 * t) else extend (Path.pi γ₁) (2 * t - 1)) ∘
                Subtype.val),
          source' :=
            (_ :
              ((fun x => if x ≤ 1 / 2 then extend (Path.pi γ₀) (2 * x) else extend (Path.pi γ₁) (2 * x - 1)) ∘
                    Subtype.val)
                  0 =
                fun i => as i),
          target' :=
            (_ :
              ((fun x => if x ≤ 1 / 2 then extend (Path.pi γ₀) (2 * x) else extend (Path.pi γ₁) (2 * x - 1)) ∘
                    Subtype.val)
                  1 =
                fun i => cs i) }
      t i =
    ↑(Path.pi fun i =>
          {
            toContinuousMap :=
              ContinuousMap.mk
                ((fun t => if t ≤ 1 / 2 then extend (γ₀ i) (2 * t) else extend (γ₁ i) (2 * t - 1)) ∘ Subtype.val),
            source' :=
              (_ :
                ((fun x => if x ≤ 1 / 2 then extend (γ₀ i) (2 * x) else extend (γ₁ i) (2 * x - 1)) ∘ Subtype.val) 0 =
                  as i),
            target' :=
              (_ :
                ((fun x => if x ≤ 1 / 2 then extend (γ₀ i) (2 * x) else extend (γ₁ i) (2 * x - 1)) ∘ Subtype.val) 1 =
                  cs i) })
      t i

tactic: split_ifs <;> rfl
state_before: case a.h.h
X : Type ?u.424517
Y : Type ?u.424520
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
x y z : X
ι : Type u_2
γ : Path x y
χ : ι → Type u_1
inst✝ : (i : ι) → TopologicalSpace (χ i)
as bs cs : (i : ι) → χ i
γ₀ : (i : ι) → Path (as i) (bs i)
γ₁ : (i : ι) → Path (bs i) (cs i)
t : ↑I
i : ι
⊢ ite (↑t ≤ 1 / 2) (extend (Path.pi γ₀) (2 * ↑t)) (extend (Path.pi γ₁) (2 * ↑t - 1)) i =
    if ↑t ≤ 1 / 2 then extend (γ₀ i) (2 * ↑t) else extend (γ₁ i) (2 * ↑t - 1)
Theorem: eq_iff_eq_cancel_left
File: Mathlib/Logic/Basic.lean

tactic: rw [← h]
state_before: α : Sort u_1
b c : α
h : ∀ {a : α}, a = b ↔ a = c
⊢ b = c

tactic: rw [h]
state_before: α : Sort u_1
b c : α
h : b = c
a : α
⊢ a = b ↔ a = c
Theorem: ENNReal.ofReal_coe_nat
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp [ENNReal.ofReal]
state_before: α : Type ?u.101567
β : Type ?u.101570
a b c d : ℝ≥0∞
r p q : ℝ≥0
n : ℕ
⊢ ENNReal.ofReal ↑n = ↑n
Theorem: Monovary.sum_comp_perm_smul_lt_sum_smul_iff
File: Mathlib/Algebra/Order/Rearrangement.lean

tactic: simp [(hfg.monovaryOn _).sum_comp_perm_smul_lt_sum_smul_iff fun _ _ ↦ mem_univ _]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module α β
inst✝¹ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
inst✝ : Fintype ι
hfg : Monovary f g
⊢ ∑ i : ι, f (↑σ i) • g i < ∑ i : ι, f i • g i ↔ ¬Monovary (f ∘ ↑σ) g
Theorem: Finset.product_image_snd
File: Mathlib/Data/Finset/Prod.lean

tactic: ext i
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.13936
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝ : DecidableEq β
ht : Finset.Nonempty s
⊢ image Prod.snd (s ×ˢ t) = t

tactic: simp [mem_image, ht.bex]
state_before: case a
α : Type u_2
β : Type u_1
γ : Type ?u.13936
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝ : DecidableEq β
ht : Finset.Nonempty s
i : β
⊢ i ∈ image Prod.snd (s ×ˢ t) ↔ i ∈ t
Theorem: Codisjoint.map_orderIso
File: Mathlib/Order/Hom/Basic.lean

tactic: rw [codisjoint_iff_le_sup, ← f.map_sup, ← f.map_top]
state_before: F : Type ?u.114656
α : Type u_1
β : Type u_2
γ : Type ?u.114665
δ : Type ?u.114668
inst✝³ : SemilatticeSup α
inst✝² : OrderTop α
inst✝¹ : SemilatticeSup β
inst✝ : OrderTop β
a b : α
f : α ≃o β
ha : Codisjoint a b
⊢ Codisjoint (↑f a) (↑f b)

tactic: exact f.monotone ha.top_le
state_before: F : Type ?u.114656
α : Type u_1
β : Type u_2
γ : Type ?u.114665
δ : Type ?u.114668
inst✝³ : SemilatticeSup α
inst✝² : OrderTop α
inst✝¹ : SemilatticeSup β
inst✝ : OrderTop β
a b : α
f : α ≃o β
ha : Codisjoint a b
⊢ ↑f ⊤ ≤ ↑f (a ⊔ b)
Theorem: Real.sin_eq_zero_iff_cos_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: rw [← mul_self_eq_one_iff, ← sin_sq_add_cos_sq x, sq, sq, ← sub_eq_iff_eq_add, sub_self]
state_before: x : ℝ
⊢ sin x = 0 ↔ cos x = 1 ∨ cos x = -1

tactic: exact ⟨fun h => by rw [h, MulZeroClass.mul_zero], eq_zero_of_mul_self_eq_zero ∘ Eq.symm⟩
state_before: x : ℝ
⊢ sin x = 0 ↔ 0 = sin x * sin x

tactic: rw [h, MulZeroClass.mul_zero]
state_before: x : ℝ
h : sin x = 0
⊢ 0 = sin x * sin x
Theorem: Cardinal.mk_union_le_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp only [le_aleph0_iff_subtype_countable, mem_union, setOf_mem_eq, Set.union_def,
  ← countable_union]
state_before: α✝ β : Type u
α : Type u_1
P Q : Set α
⊢ (#↑(P ∪ Q)) ≤ ℵ₀ ↔ (#↑P) ≤ ℵ₀ ∧ (#↑Q) ≤ ℵ₀
Theorem: Nat.Partrec'.comp'
File: Mathlib/Computability/Halting.lean

tactic: simp
state_before: n m : ℕ
f : Vector ℕ m →. ℕ
g : Vector ℕ n → Vector ℕ m
hf : Partrec' f
hg : Vec g
v : Vector ℕ n
⊢ (mOfFn fun i => ↑(some (Vector.get (g v) i))) >>= f = f (g v)
Theorem: ComputablePred.rice₂
File: Mathlib/Computability/Halting.lean

tactic: classical exact
    have hC : ∀ f, f ∈ C ↔ eval f ∈ eval '' C := fun f =>
      ⟨Set.mem_image_of_mem _, fun ⟨g, hg, e⟩ => (H _ _ e).1 hg⟩
    ⟨fun h =>
      or_iff_not_imp_left.2 fun C0 =>
        Set.eq_univ_of_forall fun cg =>
          let ⟨cf, fC⟩ := Set.nonempty_iff_ne_empty.2 C0
          (hC _).2 <|
            rice (eval '' C) (h.of_eq hC)
              (Partrec.nat_iff.1 <| eval_part.comp (const cf) Computable.id)
              (Partrec.nat_iff.1 <| eval_part.comp (const cg) Computable.id) ((hC _).1 fC),
      fun h => by {
        obtain rfl | rfl := h <;> simp [ComputablePred, Set.mem_empty_iff_false] <;>
          exact ⟨by infer_instance, Computable.const _⟩ }⟩
state_before: α : Type ?u.289197
σ : Type ?u.289200
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
C : Set Code
H : ∀ (cf cg : Code), eval cf = eval cg → (cf ∈ C ↔ cg ∈ C)
⊢ (ComputablePred fun c => c ∈ C) ↔ C = ∅ ∨ C = Set.univ

tactic: exact
have hC : ∀ f, f ∈ C ↔ eval f ∈ eval '' C := fun f =>
⟨Set.mem_image_of_mem _, fun ⟨g, hg, e⟩ => (H _ _ e).1 hg⟩
⟨fun h =>
or_iff_not_imp_left.2 fun C0 =>
Set.eq_univ_of_forall fun cg =>
let ⟨cf, fC⟩ := Set.nonempty_iff_ne_empty.2 C0
(hC _).2 <|
  rice (eval '' C) (h.of_eq hC)
    (Partrec.nat_iff.1 <| eval_part.comp (const cf) Computable.id)
    (Partrec.nat_iff.1 <| eval_part.comp (const cg) Computable.id) ((hC _).1 fC),
fun h => by {
obtain rfl | rfl := h <;> simp [ComputablePred, Set.mem_empty_iff_false] <;>
exact ⟨by infer_instance, Computable.const _⟩ }⟩
state_before: α : Type ?u.289197
σ : Type ?u.289200
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
C : Set Code
H : ∀ (cf cg : Code), eval cf = eval cg → (cf ∈ C ↔ cg ∈ C)
⊢ (ComputablePred fun c => c ∈ C) ↔ C = ∅ ∨ C = Set.univ

tactic: infer_instance
state_before: α : Type ?u.289197
σ : Type ?u.289200
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
H : ∀ (cf cg : Code), eval cf = eval cg → (cf ∈ Set.univ ↔ cg ∈ Set.univ)
hC : ∀ (f : Code), f ∈ Set.univ ↔ eval f ∈ eval '' Set.univ
⊢ DecidablePred fun c => c ∈ Set.univ
Theorem: ENNReal.Tendsto.div
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: apply Tendsto.mul hma _ (ENNReal.tendsto_inv_iff.2 hmb) _ <;> simp [ha, hb]
state_before: α : Type u_1
β : Type ?u.124755
γ : Type ?u.124758
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
ma mb : α → ℝ≥0∞
a b : ℝ≥0∞
hma : Tendsto ma f (𝓝 a)
ha : a ≠ 0 ∨ b ≠ 0
hmb : Tendsto mb f (𝓝 b)
hb : b ≠ ⊤ ∨ a ≠ ⊤
⊢ Tendsto (fun a => ma a / mb a) f (𝓝 (a / b))
Theorem: Ordering.ite_eq_lt_distrib
File: Mathlib/Init/Data/Ordering/Lemmas.lean

tactic: by_cases c <;> simp [*]
state_before: c : Prop
inst✝ : Decidable c
a b : Ordering
⊢ ((if c then a else b) = lt) = if c then a = lt else b = lt
Theorem: ContinuousLinearEquiv.map_tsum
File: Mathlib/Topology/Algebra/InfiniteSum/Module.lean

tactic: refine' symm (e.tsum_eq_iff.mpr _)
state_before: ι : Type u_5
R : Type u_3
R₂ : Type u_4
M : Type u_1
M₂ : Type u_2
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
inst✝⁵ : TopologicalSpace M
inst✝⁴ : TopologicalSpace M₂
σ : R →+* R₂
σ' : R₂ →+* R
inst✝³ : RingHomInvPair σ σ'
inst✝² : RingHomInvPair σ' σ
inst✝¹ : T2Space M
inst✝ : T2Space M₂
f : ι → M
e : M ≃SL[σ] M₂
⊢ ↑e (∑' (z : ι), f z) = ∑' (z : ι), ↑e (f z)

tactic: rw [e.symm_apply_apply _]
state_before: ι : Type u_5
R : Type u_3
R₂ : Type u_4
M : Type u_1
M₂ : Type u_2
inst✝¹¹ : Semiring R
inst✝¹⁰ : Semiring R₂
inst✝⁹ : AddCommMonoid M
inst✝⁸ : Module R M
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
inst✝⁵ : TopologicalSpace M
inst✝⁴ : TopologicalSpace M₂
σ : R →+* R₂
σ' : R₂ →+* R
inst✝³ : RingHomInvPair σ σ'
inst✝² : RingHomInvPair σ' σ
inst✝¹ : T2Space M
inst✝ : T2Space M₂
f : ι → M
e : M ≃SL[σ] M₂
⊢ (∑' (z : ι), f z) = ↑(ContinuousLinearEquiv.symm e) (↑e (∑' (z : ι), f z))
Theorem: AlgebraicTopology.DoldKan.HigherFacesVanish.of_succ
File: Mathlib/AlgebraicTopology/DoldKan/Faces.lean

tactic: simpa only [← add_assoc] using le_add_right hj
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
Y : C
n q : ℕ
φ : Y ⟶ X.obj [n + 1].op
v : HigherFacesVanish (q + 1) φ
j : Fin (n + 1)
hj : n + 1 ≤ ↑j + q
⊢ n + 1 ≤ ↑j + (q + 1)
Theorem: smul_mul_smul
File: Mathlib/GroupTheory/GroupAction/Defs.lean

tactic: rw [smul_mul_assoc, mul_smul_comm, ← smul_assoc, smul_eq_mul]
state_before: M : Type u_2
N : Type ?u.22188
G : Type ?u.22191
A : Type ?u.22194
B : Type ?u.22197
α : Type u_1
β : Type ?u.22203
γ : Type ?u.22206
δ : Type ?u.22209
inst✝⁴ : Monoid M
inst✝³ : MulAction M α
inst✝² : Mul α
r s : M
x y : α
inst✝¹ : IsScalarTower M α α
inst✝ : SMulCommClass M α α
⊢ r • x * s • y = (r * s) • (x * y)
Theorem: MvPolynomial.mem_vars_rename
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
simpa only [exists_prop, Finset.mem_image] using vars_rename f φ h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
j : τ
h : j ∈ vars (↑(rename f) φ)
⊢ ∃ i, i ∈ vars φ ∧ f i = j

tactic: simpa only [exists_prop, Finset.mem_image] using vars_rename f φ h
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : σ → τ
φ : MvPolynomial σ R
j : τ
h : j ∈ vars (↑(rename f) φ)
⊢ ∃ i, i ∈ vars φ ∧ f i = j
Theorem: Nat.pow_sub_lt_descFactorial
File: Mathlib/Data/Nat/Factorial/Basic.lean

tactic: rintro ⟨⟩
state_before: n : ℕ
⊢ 2 ≤ 0 → 0 ≤ n → (n + 1 - 0) ^ 0 < descFactorial n 0

tactic: intro
state_before: n : ℕ
⊢ 2 ≤ 1 → 1 ≤ n → (n + 1 - 1) ^ 1 < descFactorial n 1

tactic: contradiction
state_before: n : ℕ
a✝ : 2 ≤ 1
⊢ 1 ≤ n → (n + 1 - 1) ^ 1 < descFactorial n 1

tactic: rw [succ_sub_succ]
state_before: n k : ℕ
x✝ : 2 ≤ k + 2
h : k + 2 ≤ n
⊢ (n + 1 - (k + 2)) ^ (k + 2) < descFactorial n (k + 2)

tactic: exact pow_sub_lt_descFactorial' h
state_before: n k : ℕ
x✝ : 2 ≤ k + 2
h : k + 2 ≤ n
⊢ (n - (k + 1)) ^ (k + 2) < descFactorial n (k + 2)
Theorem: MeasureTheory.OuterMeasure.restrict_iInf_restrict
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: rw [Subtype.range_coe]
state_before: α : Type u_2
ι : Sort u_1
s : Set α
m : ι → OuterMeasure α
⊢ ↑(restrict s) (⨅ (i : ι), ↑(restrict s) (m i)) = ↑(restrict (range Subtype.val)) (⨅ (i : ι), ↑(restrict s) (m i))
Theorem: Set.self_mem_ordConnectedComponent
File: Mathlib/Data/Set/Intervals/OrdConnectedComponent.lean

tactic: rw [mem_ordConnectedComponent, uIcc_self, singleton_subset_iff]
state_before: α : Type u_1
inst✝ : LinearOrder α
s t : Set α
x y z : α
⊢ x ∈ ordConnectedComponent s x ↔ x ∈ s
Theorem: strictAnti_pow
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simpa only [pow_succ, one_mul] using mul_lt_mul h₁ le_rfl (pow_pos h₀ n) zero_le_one
state_before: β : Type ?u.230037
A : Type ?u.230040
G : Type ?u.230043
M : Type ?u.230046
R : Type u_1
inst✝ : StrictOrderedSemiring R
a x y : R
n✝ m : ℕ
h₀ : 0 < a
h₁ : a < 1
n : ℕ
⊢ a ^ (n + 1) < a ^ n
Theorem: QuotientRing.isOpenMap_coe
File: Mathlib/Topology/Algebra/Ring/Ideal.lean

tactic: intro s s_op
state_before: R : Type u_1
inst✝² : TopologicalSpace R
inst✝¹ : CommRing R
N : Ideal R
inst✝ : TopologicalRing R
⊢ IsOpenMap ↑(mk N)

tactic: change IsOpen (mk N ⁻¹' (mk N '' s))
state_before: R : Type u_1
inst✝² : TopologicalSpace R
inst✝¹ : CommRing R
N : Ideal R
inst✝ : TopologicalRing R
s : Set R
s_op : IsOpen s
⊢ IsOpen (↑(mk N) '' s)

tactic: rw [quotient_ring_saturate]
state_before: R : Type u_1
inst✝² : TopologicalSpace R
inst✝¹ : CommRing R
N : Ideal R
inst✝ : TopologicalRing R
s : Set R
s_op : IsOpen s
⊢ IsOpen (↑(mk N) ⁻¹' (↑(mk N) '' s))

tactic: exact isOpen_iUnion fun ⟨n, _⟩ => isOpenMap_add_left n s s_op
state_before: R : Type u_1
inst✝² : TopologicalSpace R
inst✝¹ : CommRing R
N : Ideal R
inst✝ : TopologicalRing R
s : Set R
s_op : IsOpen s
⊢ IsOpen (⋃ (x : { x // x ∈ N }), (fun y => ↑x + y) '' s)
Theorem: pow_gcd_card_eq_one_iff
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: let ⟨m, hm⟩ := gcd_dvd_left n (Fintype.card G)
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Fintype G
h : x ^ gcd n (Fintype.card G) = 1
⊢ x ^ n = 1

tactic: rw [hm, pow_mul, h, one_pow]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m✝ : ℕ
inst✝² : Group G
inst✝¹ : AddGroup A
inst✝ : Fintype G
h : x ^ gcd n (Fintype.card G) = 1
m : ℕ
hm : n = gcd n (Fintype.card G) * m
⊢ x ^ n = 1
Theorem: List.Pairwise.imp_of_mem
File: Mathlib/Data/List/Pairwise.lean

tactic: constructor
state_before: case nil
α : Type u_1
β : Type ?u.2069
R S✝ T : α → α → Prop
a : α
l✝ : List α
S : α → α → Prop
l : List α
H : ∀ {a b : α}, a ∈ [] → b ∈ [] → R a b → S a b
⊢ Pairwise S []

tactic: constructor
state_before: case cons
α : Type u_1
β : Type ?u.2069
R S✝ T : α → α → Prop
a✝¹ : α
l✝¹ : List α
S : α → α → Prop
l✝ : List α
a : α
l : List α
r : ∀ (a' : α), a' ∈ l → R a a'
a✝ : Pairwise R l
ih : (∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → Pairwise S l
H : ∀ {a_1 b : α}, a_1 ∈ a :: l → b ∈ a :: l → R a_1 b → S a_1 b
⊢ Pairwise S (a :: l)

tactic: exact BAll.imp_right (fun x h ↦ H (mem_cons_self _ _) (mem_cons_of_mem _ h)) r
state_before: case cons.a
α : Type u_1
β : Type ?u.2069
R S✝ T : α → α → Prop
a✝¹ : α
l✝¹ : List α
S : α → α → Prop
l✝ : List α
a : α
l : List α
r : ∀ (a' : α), a' ∈ l → R a a'
a✝ : Pairwise R l
ih : (∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → Pairwise S l
H : ∀ {a_1 b : α}, a_1 ∈ a :: l → b ∈ a :: l → R a_1 b → S a_1 b
⊢ ∀ (a' : α), a' ∈ l → S a a'

tactic: exact ih fun {a b} m m' ↦ H (mem_cons_of_mem _ m) (mem_cons_of_mem _ m')
state_before: case cons.a
α : Type u_1
β : Type ?u.2069
R S✝ T : α → α → Prop
a✝¹ : α
l✝¹ : List α
S : α → α → Prop
l✝ : List α
a : α
l : List α
r : ∀ (a' : α), a' ∈ l → R a a'
a✝ : Pairwise R l
ih : (∀ {a b : α}, a ∈ l → b ∈ l → R a b → S a b) → Pairwise S l
H : ∀ {a_1 b : α}, a_1 ∈ a :: l → b ∈ a :: l → R a_1 b → S a_1 b
⊢ Pairwise S l
Theorem: Finset.inter_empty
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.183003
γ : Type ?u.183006
inst✝ : DecidableEq α
s✝ s₁ s₂ t t₁ t₂ u v : Finset α
a b : α
s : Finset α
x✝ : α
⊢ x✝ ∈ s ∧ x✝ ∈ ∅ ↔ x✝ ∈ ∅
Theorem: UniformFun.uniformContinuous_toFun
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: rw [uniformContinuous_pi]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44602
ι : Type ?u.44605
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
⊢ UniformContinuous ↑toFun

tactic: intro x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44602
ι : Type ?u.44605
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
⊢ ∀ (i : α), UniformContinuous fun x => ↑toFun x i

tactic: exact uniformContinuous_eval β x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.44602
ι : Type ?u.44605
s s' : Set α
x✝ : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
x : α
⊢ UniformContinuous fun x_1 => ↑toFun x_1 x
Theorem: CategoryTheory.isSheaf_yoneda'
File: Mathlib/CategoryTheory/Sites/Types.lean

tactic: convert congr_fun (hx (𝟙 _) (fun _ => z) (hs <| f z) h rfl) PUnit.unit using 1
state_before: α β : Type u
S : Sieve β
hs : S ∈ GrothendieckTopology.sieves typesGrothendieckTopology β
x : FamilyOfElements (yoneda.obj α) S.arrows
hx : FamilyOfElements.Compatible x
γ : Type u
f : γ ⟶ β
h : S.arrows f
z : γ.op.unop
⊢ (yoneda.obj α).map f.op (fun y => x (fun x => y) (_ : S.arrows fun x => y) PUnit.unit) z = x f h z

tactic: convert congr_fun (hf _ (hs y)) PUnit.unit
state_before: α β : Type u
S : Sieve β
hs : S ∈ GrothendieckTopology.sieves typesGrothendieckTopology β
x : FamilyOfElements (yoneda.obj α) S.arrows
hx : FamilyOfElements.Compatible x
f : (yoneda.obj α).obj β.op
hf : (fun t => FamilyOfElements.IsAmalgamation x t) f
y : β.op.unop
⊢ f y = x (fun x => y) (_ : S.arrows fun x => y) PUnit.unit
Theorem: Equiv.Perm.cycleOf_apply_apply_self
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: convert cycleOf_apply_apply_pow_self f x 1 using 1
state_before: ι : Type ?u.2369326
α : Type u_1
β : Type ?u.2369332
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g : Perm α
x✝ y : α
f : Perm α
x : α
⊢ ↑(cycleOf f x) (↑f x) = ↑f (↑f x)
Theorem: Finsupp.toAList_keys_toFinset
File: Mathlib/Data/Finsupp/AList.lean

tactic: ext
state_before: α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
f : α →₀ M
⊢ List.toFinset (AList.keys (toAList f)) = f.support

tactic: simp [toAList, AList.mem_keys, AList.keys, List.keys]
state_before: case a
α : Type u_1
M : Type u_2
inst✝¹ : Zero M
inst✝ : DecidableEq α
f : α →₀ M
a✝ : α
⊢ a✝ ∈ List.toFinset (AList.keys (toAList f)) ↔ a✝ ∈ f.support
Theorem: Ideal.jacobson_eq_iff_jacobson_quotient_eq_bot
File: Mathlib/RingTheory/JacobsonIdeal.lean

tactic: have hf : Function.Surjective (Ideal.Quotient.mk I) := Submodule.Quotient.mk_surjective I
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
⊢ jacobson I = I ↔ jacobson ⊥ = ⊥

tactic: constructor
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
⊢ jacobson I = I ↔ jacobson ⊥ = ⊥

tactic: intro h
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
⊢ jacobson I = I → jacobson ⊥ = ⊥

tactic: replace h := congr_arg (Ideal.map (Ideal.Quotient.mk I)) h
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : jacobson I = I
⊢ jacobson ⊥ = ⊥

tactic: rw [map_jacobson_of_surjective hf (le_of_eq mk_ker)] at h
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : map (Quotient.mk I) (jacobson I) = map (Quotient.mk I) I
⊢ jacobson ⊥ = ⊥

tactic: simpa using h
state_before: case mp
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : jacobson (map (Quotient.mk I) I) = map (Quotient.mk I) I
⊢ jacobson ⊥ = ⊥

tactic: intro h
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
⊢ jacobson ⊥ = ⊥ → jacobson I = I

tactic: replace h := congr_arg (comap (Ideal.Quotient.mk I)) h
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : jacobson ⊥ = ⊥
⊢ jacobson I = I

tactic: rw [comap_jacobson_of_surjective hf, ← RingHom.ker_eq_comap_bot (Ideal.Quotient.mk I)] at h
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : comap (Quotient.mk I) (jacobson ⊥) = comap (Quotient.mk I) ⊥
⊢ jacobson I = I

tactic: simpa using h
state_before: case mpr
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
I : Ideal R
hf : Function.Surjective ↑(Quotient.mk I)
h : jacobson (RingHom.ker (Quotient.mk I)) = RingHom.ker (Quotient.mk I)
⊢ jacobson I = I