1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Cardinal.ord_aleph'_eq_enum_card
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [← eq_enumOrd _ ord_card_unbounded, range_eq_iff]
state_before: ⊢ ord ∘ aleph' = enumOrd {b | b.card.ord = b}
state_after: ⊢ StrictMono (ord ∘ aleph') ∧
    (∀ (a : Ordinal.{u_1}), (ord ∘ aleph') a ∈ {b | b.card.ord = b}) ∧
      ∀ b ∈ {b | b.card.ord = b}, ∃ a, (ord ∘ aleph') a = b

tactic: exact
  ⟨aleph'_isNormal.strictMono,
    ⟨fun a => by
      dsimp
      rw [card_ord], fun b hb => eq_aleph'_of_eq_card_ord hb⟩⟩
state_before: ⊢ StrictMono (ord ∘ aleph') ∧
    (∀ (a : Ordinal.{u_1}), (ord ∘ aleph') a ∈ {b | b.card.ord = b}) ∧
      ∀ b ∈ {b | b.card.ord = b}, ∃ a, (ord ∘ aleph') a = b
state_after: no goals

tactic: dsimp
state_before: a : Ordinal.{u_1}
⊢ (ord ∘ aleph') a ∈ {b | b.card.ord = b}
state_after: a : Ordinal.{u_1}
⊢ (aleph' a).ord.card.ord = (aleph' a).ord

tactic: rw [card_ord]
state_before: a : Ordinal.{u_1}
⊢ (aleph' a).ord.card.ord = (aleph' a).ord
state_after: no goals
Theorem: MvPolynomial.aevalTower_ofId
File: Mathlib/Algebra/MvPolynomial/Basic.lean

tactic: ext
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S₁
p q : MvPolynomial σ R
S : Type u_2
A : Type u_3
B : Type u_4
inst✝⁵ : CommSemiring S
inst✝⁴ : CommSemiring A
inst✝³ : CommSemiring B
inst✝² : Algebra S R
inst✝¹ : Algebra S A
inst✝ : Algebra S B
g : R →ₐ[S] A
y : σ → A
⊢ aevalTower (Algebra.ofId S A) = aeval
state_after: case h.hf
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S₁
p q : MvPolynomial σ R
S : Type u_2
A : Type u_3
B : Type u_4
inst✝⁵ : CommSemiring S
inst✝⁴ : CommSemiring A
inst✝³ : CommSemiring B
inst✝² : Algebra S R
inst✝¹ : Algebra S A
inst✝ : Algebra S B
g : R →ₐ[S] A
y x✝ : σ → A
i✝ : σ
⊢ (aevalTower (Algebra.ofId S A) x✝) (X i✝) = (aeval x✝) (X i✝)

tactic: simp only [aeval_X, aevalTower_X]
state_before: case h.hf
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝⁷ : CommSemiring R
inst✝⁶ : CommSemiring S₁
p q : MvPolynomial σ R
S : Type u_2
A : Type u_3
B : Type u_4
inst✝⁵ : CommSemiring S
inst✝⁴ : CommSemiring A
inst✝³ : CommSemiring B
inst✝² : Algebra S R
inst✝¹ : Algebra S A
inst✝ : Algebra S B
g : R →ₐ[S] A
y x✝ : σ → A
i✝ : σ
⊢ (aevalTower (Algebra.ofId S A) x✝) (X i✝) = (aeval x✝) (X i✝)
state_after: no goals
Theorem: ContinuousMap.not_mem_setOfIdeal
File: Mathlib/Topology/ContinuousFunction/Ideals.lean

tactic: rw [← Set.mem_compl_iff, setOfIdeal, compl_compl, Set.mem_setOf]
state_before: X : Type u_1
R : Type u_2
inst✝³ : TopologicalSpace X
inst✝² : Semiring R
inst✝¹ : TopologicalSpace R
inst✝ : TopologicalSemiring R
I : Ideal C(X, R)
x : X
⊢ x ∉ setOfIdeal I ↔ ∀ ⦃f : C(X, R)⦄, f ∈ I → f x = 0
state_after: no goals
Theorem: Subgroup.pi_mem_of_mulSingle_mem
File: Mathlib/Algebra/Group/Subgroup/Finite.lean

tactic: cases nonempty_fintype η
state_before: G : Type u_1
inst✝⁴ : Group G
A : Type u_2
inst✝³ : AddGroup A
η : Type u_3
f : η → Type u_4
inst✝² : (i : η) → Group (f i)
inst✝¹ : Finite η
inst✝ : DecidableEq η
H : Subgroup ((i : η) → f i)
x : (i : η) → f i
h : ∀ (i : η), Pi.mulSingle i (x i) ∈ H
⊢ x ∈ H
state_after: case intro
G : Type u_1
inst✝⁴ : Group G
A : Type u_2
inst✝³ : AddGroup A
η : Type u_3
f : η → Type u_4
inst✝² : (i : η) → Group (f i)
inst✝¹ : Finite η
inst✝ : DecidableEq η
H : Subgroup ((i : η) → f i)
x : (i : η) → f i
h : ∀ (i : η), Pi.mulSingle i (x i) ∈ H
val✝ : Fintype η
⊢ x ∈ H

tactic: exact pi_mem_of_mulSingle_mem_aux Finset.univ x (by simp) fun i _ => h i
state_before: case intro
G : Type u_1
inst✝⁴ : Group G
A : Type u_2
inst✝³ : AddGroup A
η : Type u_3
f : η → Type u_4
inst✝² : (i : η) → Group (f i)
inst✝¹ : Finite η
inst✝ : DecidableEq η
H : Subgroup ((i : η) → f i)
x : (i : η) → f i
h : ∀ (i : η), Pi.mulSingle i (x i) ∈ H
val✝ : Fintype η
⊢ x ∈ H
state_after: no goals

tactic: simp
state_before: G : Type u_1
inst✝⁴ : Group G
A : Type u_2
inst✝³ : AddGroup A
η : Type u_3
f : η → Type u_4
inst✝² : (i : η) → Group (f i)
inst✝¹ : Finite η
inst✝ : DecidableEq η
H : Subgroup ((i : η) → f i)
x : (i : η) → f i
h : ∀ (i : η), Pi.mulSingle i (x i) ∈ H
val✝ : Fintype η
⊢ ∀ i ∉ Finset.univ, x i = 1
state_after: no goals
Theorem: QuotientMap.lift_comp
File: Mathlib/Topology/ContinuousFunction/Basic.lean

tactic: ext
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : C(X, Y)
hf : QuotientMap ⇑f
g : C(X, Z)
h : FactorsThrough ⇑g ⇑f
⊢ (hf.lift g h).comp f = g
state_after: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : C(X, Y)
hf : QuotientMap ⇑f
g : C(X, Z)
h : FactorsThrough ⇑g ⇑f
a✝ : X
⊢ ((hf.lift g h).comp f) a✝ = g a✝

tactic: simpa using h (Function.rightInverse_surjInv _ _)
state_before: case h
X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
f : C(X, Y)
hf : QuotientMap ⇑f
g : C(X, Z)
h : FactorsThrough ⇑g ⇑f
a✝ : X
⊢ ((hf.lift g h).comp f) a✝ = g a✝
state_after: no goals
Theorem: Module.DirectLimit.map_comp
File: Mathlib/Algebra/DirectLimit.lean

tactic: rw [LinearMap.comp_assoc, hg₁ i, ← LinearMap.comp_assoc, hg₂ i, LinearMap.comp_assoc]
state_before: R : Type u
inst✝¹¹ : Ring R
ι : Type v
inst✝¹⁰ : Preorder ι
G : ι → Type w
inst✝⁹ : (i : ι) → AddCommGroup (G i)
inst✝⁸ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝⁷ : DecidableEq ι
P : Type u₁
inst✝⁶ : AddCommGroup P
inst✝⁵ : Module R P
g : (i : ι) → G i →ₗ[R] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
G' : ι → Type v'
inst✝⁴ : (i : ι) → AddCommGroup (G' i)
inst✝³ : (i : ι) → Module R (G' i)
f' : (i j : ι) → i ≤ j → G' i →ₗ[R] G' j
G'' : ι → Type v''
inst✝² : (i : ι) → AddCommGroup (G'' i)
inst✝¹ : (i : ι) → Module R (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →ₗ[R] G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
g₁ : (i : ι) → G i →ₗ[R] G' i
g₂ : (i : ι) → G' i →ₗ[R] G'' i
hg₁ : ∀ (i j : ι) (h : i ≤ j), g₁ j ∘ₗ f i j h = f' i j h ∘ₗ g₁ i
hg₂ : ∀ (i j : ι) (h : i ≤ j), g₂ j ∘ₗ f' i j h = f'' i j h ∘ₗ g₂ i
i j : ι
h : i ≤ j
⊢ (fun i => g₂ i ∘ₗ g₁ i) j ∘ₗ f i j h = f'' i j h ∘ₗ (fun i => g₂ i ∘ₗ g₁ i) i
state_after: no goals

tactic: simp
state_before: R : Type u
inst✝¹¹ : Ring R
ι : Type v
inst✝¹⁰ : Preorder ι
G : ι → Type w
inst✝⁹ : (i : ι) → AddCommGroup (G i)
inst✝⁸ : (i : ι) → Module R (G i)
f : (i j : ι) → i ≤ j → G i →ₗ[R] G j
inst✝⁷ : DecidableEq ι
P : Type u₁
inst✝⁶ : AddCommGroup P
inst✝⁵ : Module R P
g✝ : (i : ι) → G i →ₗ[R] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g✝ j) ((f i j hij) x) = (g✝ i) x
G' : ι → Type v'
inst✝⁴ : (i : ι) → AddCommGroup (G' i)
inst✝³ : (i : ι) → Module R (G' i)
f' : (i j : ι) → i ≤ j → G' i →ₗ[R] G' j
G'' : ι → Type v''
inst✝² : (i : ι) → AddCommGroup (G'' i)
inst✝¹ : (i : ι) → Module R (G'' i)
f'' : (i j : ι) → i ≤ j → G'' i →ₗ[R] G'' j
inst✝ : IsDirected ι fun x x_1 => x ≤ x_1
g₁ : (i : ι) → G i →ₗ[R] G' i
g₂ : (i : ι) → G' i →ₗ[R] G'' i
hg₁ : ∀ (i j : ι) (h : i ≤ j), g₁ j ∘ₗ f i j h = f' i j h ∘ₗ g₁ i
hg₂ : ∀ (i j : ι) (h : i ≤ j), g₂ j ∘ₗ f' i j h = f'' i j h ∘ₗ g₂ i
x : DirectLimit G f
x✝ : Nonempty ι
i : ι
g : G i
⊢ (map g₂ hg₂ ∘ₗ map g₁ hg₁) ((of R ι G f i) g) = (map (fun i => g₂ i ∘ₗ g₁ i) ⋯) ((of R ι G f i) g)
state_after: no goals
Theorem: Set.mulIndicator_compl'
File: Mathlib/Algebra/Group/Indicator.lean

tactic: rw [div_eq_mul_inv, mulIndicator_compl]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
inst✝ : Group G
s✝ t : Set α
f✝ g : α → G
a : α
s : Set α
f : α → G
⊢ sᶜ.mulIndicator f = f / s.mulIndicator f
state_after: no goals
Theorem: Convex.sum_mem
File: Mathlib/Analysis/Convex/Combination.lean

tactic: simpa only [h₁, centerMass, inv_one, one_smul] using
  hs.centerMass_mem h₀ (h₁.symm ▸ zero_lt_one) hz
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
hs : Convex R s
h₀ : ∀ i ∈ t, 0 ≤ w i
h₁ : ∑ i ∈ t, w i = 1
hz : ∀ i ∈ t, z i ∈ s
⊢ ∑ i ∈ t, w i • z i ∈ s
state_after: no goals
Theorem: MonoidAlgebra.induction_on
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: refine Finsupp.induction_linear f ?_ (fun f g hf hg => hadd f g hf hg) fun g r => ?_
state_before: k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
⊢ p f
state_after: case refine_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
⊢ p 0

case refine_2
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
g : G
r : k
⊢ p (Finsupp.single g r)

tactic: simpa using hsmul 0 (of k G 1) (hM 1)
state_before: case refine_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
⊢ p 0
state_after: no goals

tactic: convert hsmul r (of k G g) (hM g)
state_before: case refine_2
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
g : G
r : k
⊢ p (Finsupp.single g r)
state_after: case h.e'_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
g : G
r : k
⊢ Finsupp.single g r = r • (of k G) g

tactic: rw [of_apply, smul_single', mul_one]
state_before: case h.e'_1
k : Type u₁
G : Type u₂
H : Type u_1
R : Type u_2
inst✝¹ : Semiring k
inst✝ : Monoid G
p : MonoidAlgebra k G → Prop
f : MonoidAlgebra k G
hM : ∀ (g : G), p ((of k G) g)
hadd : ∀ (f g : MonoidAlgebra k G), p f → p g → p (f + g)
hsmul : ∀ (r : k) (f : MonoidAlgebra k G), p f → p (r • f)
g : G
r : k
⊢ Finsupp.single g r = r • (of k G) g
state_after: no goals
Theorem: Filter.blimsup_false
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [blimsup_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
inst✝ : CompleteLattice α
f : Filter β
u : β → α
⊢ (blimsup u f fun x => False) = ⊥
state_after: no goals
Theorem: HasSum.hasSum_at_zero
File: Mathlib/Analysis/Analytic/IsolatedZeros.lean

tactic: convert hasSum_single (α := E) 0 fun b h ↦ _ <;> simp [*]
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
s : E
p q : FormalMultilinearSeries 𝕜 𝕜 E
f g : 𝕜 → E
n : ℕ
z z₀ : 𝕜
a✝ a : ℕ → E
⊢ HasSum (fun n => 0 ^ n • a n) (a 0)
state_after: no goals
Theorem: infinite_prod
File: Mathlib/Data/Fintype/Prod.lean

tactic: refine
  ⟨fun H => ?_, fun H =>
    H.elim (and_imp.2 <| @Prod.infinite_of_left α β) (and_imp.2 <| @Prod.infinite_of_right α β)⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
⊢ Infinite (α × β) ↔ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β

tactic: rw [and_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Infinite α ∧ Nonempty β ∨ Nonempty α ∧ Infinite β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Nonempty β ∧ Infinite α ∨ Nonempty α ∧ Infinite β

tactic: contrapose! H
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : Infinite (α × β)
⊢ Nonempty β ∧ Infinite α ∨ Nonempty α ∧ Infinite β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
⊢ ¬Infinite (α × β)

tactic: intro H'
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
⊢ ¬Infinite (α × β)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
⊢ False

tactic: rcases Infinite.nonempty (α × β) with ⟨a, b⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
⊢ False
state_after: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
⊢ False

tactic: haveI := fintypeOfNotInfinite (H.1 ⟨b⟩)
state_before: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
⊢ False
state_after: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this : Fintype α
⊢ False

tactic: haveI := fintypeOfNotInfinite (H.2 ⟨a⟩)
state_before: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this : Fintype α
⊢ False
state_after: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this✝ : Fintype α
this : Fintype β
⊢ False

tactic: exact H'.false
state_before: case intro.mk
α : Type u_1
β : Type u_2
γ : Type u_3
H : (Nonempty β → ¬Infinite α) ∧ (Nonempty α → ¬Infinite β)
H' : Infinite (α × β)
a : α
b : β
this✝ : Fintype α
this : Fintype β
⊢ False
state_after: no goals
Theorem: residual_of_dense_Gδ
File: Mathlib/Topology/GDelta.lean

tactic: rcases ho with ⟨T, To, Tct, rfl⟩
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
s : Set X
ho : IsGδ s
hd : Dense s
⊢ s ∈ residual X
state_after: case intro.intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
T : Set (Set X)
To : ∀ t ∈ T, IsOpen t
Tct : T.Countable
hd : Dense (⋂₀ T)
⊢ ⋂₀ T ∈ residual X

tactic: exact
  (countable_sInter_mem Tct).mpr fun t tT =>
    residual_of_dense_open (To t tT) (hd.mono (sInter_subset_of_mem tT))
state_before: case intro.intro.intro
X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
T : Set (Set X)
To : ∀ t ∈ T, IsOpen t
Tct : T.Countable
hd : Dense (⋂₀ T)
⊢ ⋂₀ T ∈ residual X
state_after: no goals
Theorem: Set.piecewise_mem_pi
File: Mathlib/Data/Set/Function.lean

tactic: intro i ht
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ✝ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_7
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ t.pi t'
hg : g ∈ t.pi t'
⊢ s.piecewise f g ∈ t.pi t'
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ✝ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_7
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ t.pi t'
hg : g ∈ t.pi t'
i : α
ht : i ∈ t
⊢ s.piecewise f g i ∈ t' i

tactic: by_cases hs : i ∈ s <;> simp [hf i ht, hg i ht, hs]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ✝ : α → Sort u_6
s : Set α
f✝ g✝ : (i : α) → δ✝ i
inst✝ : (j : α) → Decidable (j ∈ s)
δ : α → Type u_7
t : Set α
t' : (i : α) → Set (δ i)
f g : (i : α) → δ i
hf : f ∈ t.pi t'
hg : g ∈ t.pi t'
i : α
ht : i ∈ t
⊢ s.piecewise f g i ∈ t' i
state_after: no goals
Theorem: Int.coe_leastOfBdd_eq
File: Mathlib/Data/Int/LeastGreatest.lean

tactic: rcases leastOfBdd b Hb Hinh with ⟨n, hn, h2n⟩
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
⊢ ↑(b.leastOfBdd Hb Hinh) = ↑(b'.leastOfBdd Hb' Hinh)
state_after: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑(b'.leastOfBdd Hb' Hinh)

tactic: rcases leastOfBdd b' Hb' Hinh with ⟨n', hn', h2n'⟩
state_before: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑(b'.leastOfBdd Hb' Hinh)
state_after: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → n' ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑⟨n', ⋯⟩

tactic: exact le_antisymm (h2n _ hn') (h2n' _ hn)
state_before: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → n' ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑⟨n', ⋯⟩
state_after: no goals
Theorem: IsAdjoinRoot.ext
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rw [← h.aeval_eq, ← h'.aeval_eq, eq]
state_before: R : Type u
S : Type v
inst✝² : CommRing R
inst✝¹ : Ring S
f : R[X]
inst✝ : Algebra R S
h h' : IsAdjoinRoot S f
eq : h.root = h'.root
x : R[X]
⊢ h.map x = h'.map x
state_after: no goals
Theorem: Complex.tendsto_abs_tan_of_cos_eq_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/ComplexDeriv.lean

tactic: simp only [tan_eq_sin_div_cos, ← norm_eq_abs, norm_div]
state_before: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => abs (tan x)) (𝓝[≠] x) atTop
state_after: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop

tactic: have A : sin x ≠ 0 := fun h => by simpa [*, sq] using sin_sq_add_cos_sq x
state_before: x : ℂ
hx : cos x = 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
state_after: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop

tactic: have B : Tendsto cos (𝓝[≠] x) (𝓝[≠] 0) :=
  hx ▸ (hasDerivAt_cos x).tendsto_punctured_nhds (neg_ne_zero.2 A)
state_before: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
state_after: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
B : Tendsto cos (𝓝[≠] x) (𝓝[≠] 0)
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop

tactic: exact continuous_sin.continuousWithinAt.norm.mul_atTop (norm_pos_iff.2 A)
  (tendsto_norm_nhdsWithin_zero.comp B).inv_tendsto_zero
state_before: x : ℂ
hx : cos x = 0
A : sin x ≠ 0
B : Tendsto cos (𝓝[≠] x) (𝓝[≠] 0)
⊢ Tendsto (fun x => ‖sin x‖ / ‖cos x‖) (𝓝[≠] x) atTop
state_after: no goals

tactic: simpa [*, sq] using sin_sq_add_cos_sq x
state_before: x : ℂ
hx : cos x = 0
h : sin x = 0
⊢ False
state_after: no goals
Theorem: List.sublist_join
File: Mathlib/Data/List/Join.lean

tactic: induction L with
| nil =>
  exfalso
  exact not_mem_nil s hs
| cons t m ht =>
  cases mem_cons.mp hs with
  | inl h =>
    rw [h]
    simp only [join_cons, sublist_append_left]
  | inr h =>
    simp only [join_cons]
    exact sublist_append_of_sublist_right (ht h)
state_before: α : Type u_1
β : Type u_2
L : List (List α)
s : List α
hs : s ∈ L
⊢ s <+ L.join
state_after: no goals

tactic: exfalso
state_before: case nil
α : Type u_1
β : Type u_2
s : List α
hs : s ∈ []
⊢ s <+ [].join
state_after: case nil
α : Type u_1
β : Type u_2
s : List α
hs : s ∈ []
⊢ False

tactic: exact not_mem_nil s hs
state_before: case nil
α : Type u_1
β : Type u_2
s : List α
hs : s ∈ []
⊢ False
state_after: no goals

tactic: cases mem_cons.mp hs with
| inl h =>
  rw [h]
  simp only [join_cons, sublist_append_left]
| inr h =>
  simp only [join_cons]
  exact sublist_append_of_sublist_right (ht h)
state_before: case cons
α : Type u_1
β : Type u_2
s t : List α
m : List (List α)
ht : s ∈ m → s <+ m.join
hs : s ∈ t :: m
⊢ s <+ (t :: m).join
state_after: no goals

tactic: rw [h]
state_before: case cons.inl
α : Type u_1
β : Type u_2
s t : List α
m : List (List α)
ht : s ∈ m → s <+ m.join
hs : s ∈ t :: m
h : s = t
⊢ s <+ (t :: m).join
state_after: case cons.inl
α : Type u_1
β : Type u_2
s t : List α
m : List (List α)
ht : s ∈ m → s <+ m.join
hs : s ∈ t :: m
h : s = t
⊢ t <+ (t :: m).join

tactic: simp only [join_cons, sublist_append_left]
state_before: case cons.inl
α : Type u_1
β : Type u_2
s t : List α
m : List (List α)
ht : s ∈ m → s <+ m.join
hs : s ∈ t :: m
h : s = t
⊢ t <+ (t :: m).join
state_after: no goals

tactic: simp only [join_cons]
state_before: case cons.inr
α : Type u_1
β : Type u_2
s t : List α
m : List (List α)
ht : s ∈ m → s <+ m.join
hs : s ∈ t :: m
h : s ∈ m
⊢ s <+ (t :: m).join
state_after: case cons.inr
α : Type u_1
β : Type u_2
s t : List α
m : List (List α)
ht : s ∈ m → s <+ m.join
hs : s ∈ t :: m
h : s ∈ m
⊢ s <+ t ++ m.join

tactic: exact sublist_append_of_sublist_right (ht h)
state_before: case cons.inr
α : Type u_1
β : Type u_2
s t : List α
m : List (List α)
ht : s ∈ m → s <+ m.join
hs : s ∈ t :: m
h : s ∈ m
⊢ s <+ t ++ m.join
state_after: no goals
Theorem: Ctop.Realizer.is_basis
File: Mathlib/Data/Analysis/Topology.lean

tactic: have := toTopsp_isTopologicalBasis F.F
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
T : TopologicalSpace α
F : Realizer α
⊢ TopologicalSpace.IsTopologicalBasis (range F.F.f)
state_after: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
T : TopologicalSpace α
F : Realizer α
this : TopologicalSpace.IsTopologicalBasis (range F.F.f)
⊢ TopologicalSpace.IsTopologicalBasis (range F.F.f)

tactic: rwa [F.eq] at this
state_before: α : Type u_1
β : Type u_2
σ : Type u_3
τ : Type u_4
T : TopologicalSpace α
F : Realizer α
this : TopologicalSpace.IsTopologicalBasis (range F.F.f)
⊢ TopologicalSpace.IsTopologicalBasis (range F.F.f)
state_after: no goals
Theorem: Polynomial.eval_eq_sum_range'
File: Mathlib/Algebra/Polynomial/Eval.lean

tactic: rw [eval_eq_sum, p.sum_over_range' _ _ hn]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x✝ : R
p : R[X]
n : ℕ
hn : p.natDegree < n
x : R
⊢ eval x p = ∑ i ∈ range n, p.coeff i * x ^ i
state_after: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x✝ : R
p : R[X]
n : ℕ
hn : p.natDegree < n
x : R
⊢ ∀ (n : ℕ), 0 * x ^ n = 0

tactic: simp
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
x✝ : R
p : R[X]
n : ℕ
hn : p.natDegree < n
x : R
⊢ ∀ (n : ℕ), 0 * x ^ n = 0
state_after: no goals
Theorem: gcd_eq_of_dvd_sub_left
File: Mathlib/Algebra/GCDMonoid/Basic.lean

tactic: rw [gcd_comm _ a, gcd_comm _ a, gcd_eq_of_dvd_sub_right h]
state_before: α : Type u_1
inst✝² : CommRing α
inst✝¹ : IsDomain α
inst✝ : NormalizedGCDMonoid α
a b c : α
h : a ∣ b - c
⊢ gcd b a = gcd c a
state_after: no goals