1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Polynomial.natDegree_mul_X_pow
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

tactic: rw [natDegree_mul' (by simpa), natDegree_X_pow]
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
n : ℕ
hp : p ≠ 0
⊢ (p * X ^ n).natDegree = p.natDegree + n
state_after: no goals

tactic: simpa
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
inst✝ : Nontrivial R
p q : R[X]
n : ℕ
hp : p ≠ 0
⊢ p.leadingCoeff * (X ^ n).leadingCoeff ≠ 0
state_after: no goals
Theorem: min_div_div_right'
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simpa only [div_eq_mul_inv] using min_mul_mul_right a b c⁻¹
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ min (a / c) (b / c) = min a b / c
state_after: no goals
Theorem: GeneralizedContinuedFraction.part_denom_none_iff_s_none
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: cases s_nth_eq : g.s.get? n <;> simp [partialDenominators, s_nth_eq]
state_before: α : Type u_1
g : GeneralizedContinuedFraction α
n : ℕ
⊢ g.partialDenominators.get? n = none ↔ g.s.get? n = none
state_after: no goals
Theorem: Finset.map_prodComm_antidiagonal
File: Mathlib/Algebra/Order/Antidiag/Prod.lean

tactic: simp [add_comm]
state_before: A : Type u_1
inst✝¹ : AddCommMonoid A
inst✝ : HasAntidiagonal A
n : A
x✝ : A × A
a b : A
⊢ (a, b) ∈ map (Equiv.prodComm A A).toEmbedding (antidiagonal n) ↔ (a, b) ∈ antidiagonal n
state_after: no goals
Theorem: AlgebraicTopology.DoldKan.QInfty_comp_PInfty
File: Mathlib/AlgebraicTopology/DoldKan/PInfty.lean

tactic: ext n
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
⊢ QInfty ≫ PInfty = 0
state_after: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ (QInfty ≫ PInfty).f n = HomologicalComplex.Hom.f 0 n

tactic: apply QInfty_f_comp_PInfty_f
state_before: case h
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X : SimplicialObject C
n : ℕ
⊢ (QInfty ≫ PInfty).f n = HomologicalComplex.Hom.f 0 n
state_after: no goals
Theorem: Nat.add_le_pair
File: Mathlib/Data/Nat/Pairing.lean

tactic: simp only [pair, Nat.add_assoc]
state_before: m n : ℕ
⊢ m + n ≤ pair m n
state_after: m n : ℕ
⊢ m + n ≤ if m < n then n * n + m else m * m + (m + n)

tactic: split_ifs
state_before: m n : ℕ
⊢ m + n ≤ if m < n then n * n + m else m * m + (m + n)
state_after: case pos
m n : ℕ
h✝ : m < n
⊢ m + n ≤ n * n + m

case neg
m n : ℕ
h✝ : ¬m < n
⊢ m + n ≤ m * m + (m + n)

tactic: have := le_mul_self n
state_before: case pos
m n : ℕ
h✝ : m < n
⊢ m + n ≤ n * n + m
state_after: case pos
m n : ℕ
h✝ : m < n
this : n ≤ n * n
⊢ m + n ≤ n * n + m

tactic: omega
state_before: case pos
m n : ℕ
h✝ : m < n
this : n ≤ n * n
⊢ m + n ≤ n * n + m
state_after: no goals

tactic: exact Nat.le_add_left _ _
state_before: case neg
m n : ℕ
h✝ : ¬m < n
⊢ m + n ≤ m * m + (m + n)
state_after: no goals
Theorem: PresheafOfModules.sheafificationAdjunction_unit_app_hom
File: Mathlib/Algebra/Category/ModuleCat/Presheaf/Sheafification.lean

tactic: rfl
state_before: C : Type u'
inst✝⁴ : Category.{v', u'} C
J : GrothendieckTopology C
R₀ : Cᵒᵖ ⥤ RingCat
R : Sheaf J RingCat
α : R₀ ⟶ R.val
inst✝³ : Presheaf.IsLocallyInjective J α
inst✝² : Presheaf.IsLocallySurjective J α
inst✝¹ : J.WEqualsLocallyBijective AddCommGrp
inst✝ : HasWeakSheafify J AddCommGrp
M₀ : PresheafOfModules R₀
⊢ ((sheafificationAdjunction α).unit.app M₀).hom = CategoryTheory.toSheafify J M₀.presheaf
state_after: no goals
Theorem: Set.Countable.sUnion_iff
File: Mathlib/Data/Set/Countable.lean

tactic: rw [sUnion_eq_biUnion, hs.biUnion_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
s : Set (Set α)
hs : s.Countable
⊢ (⋃₀ s).Countable ↔ ∀ a ∈ s, a.Countable
state_after: no goals
Theorem: Homeomorph.isOpen_image
File: Mathlib/Topology/Homeomorph.lean

tactic: rw [← preimage_symm, isOpen_preimage]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
s : Set X
⊢ IsOpen (⇑h '' s) ↔ IsOpen s
state_after: no goals
Theorem: Set.biInter_iUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: simp [@iInter_comm _ ι]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
ι₂ : Sort u_6
κ : ι → Sort u_7
κ₁ : ι → Sort u_8
κ₂ : ι → Sort u_9
κ' : ι' → Sort u_10
s : ι → Set α
t : α → Set β
⊢ ⋂ x ∈ ⋃ i, s i, t x = ⋂ i, ⋂ x ∈ s i, t x
state_after: no goals
Theorem: measurableSet_of_differentiableWithinAt_Ici_of_isComplete
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

tactic: simp only [differentiable_set_eq_D K hK, D]
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
⊢ MeasurableSet {x | DifferentiableWithinAt ℝ f (Ici x) x ∧ derivWithin f (Ici x) x ∈ K}
state_after: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
⊢ MeasurableSet (⋂ e, ⋃ n, ⋂ p, ⋂ (_ : p ≥ n), ⋂ q, ⋂ (_ : q ≥ n), B f K ((1 / 2) ^ p) ((1 / 2) ^ q) ((1 / 2) ^ e))

tactic: repeat apply_rules [MeasurableSet.iUnion, MeasurableSet.iInter] <;> intro
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
⊢ MeasurableSet (⋂ e, ⋃ n, ⋂ p, ⋂ (_ : p ≥ n), ⋂ q, ⋂ (_ : q ≥ n), B f K ((1 / 2) ^ p) ((1 / 2) ^ q) ((1 / 2) ^ e))
state_after: case h
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
b✝⁵ b✝⁴ b✝³ : ℕ
b✝² : b✝³ ≥ b✝⁴
b✝¹ : ℕ
b✝ : b✝¹ ≥ b✝⁴
⊢ MeasurableSet (B f K ((1 / 2) ^ b✝³) ((1 / 2) ^ b✝¹) ((1 / 2) ^ b✝⁵))

tactic: exact measurableSet_B
state_before: case h
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
b✝⁵ b✝⁴ b✝³ : ℕ
b✝² : b✝³ ≥ b✝⁴
b✝¹ : ℕ
b✝ : b✝¹ ≥ b✝⁴
⊢ MeasurableSet (B f K ((1 / 2) ^ b✝³) ((1 / 2) ^ b✝¹) ((1 / 2) ^ b✝⁵))
state_after: no goals

tactic: apply_rules [MeasurableSet.iUnion, MeasurableSet.iInter] <;> intro
state_before: case h
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
b✝⁵ b✝⁴ b✝³ : ℕ
b✝² : b✝³ ≥ b✝⁴
b✝¹ : ℕ
b✝ : b✝¹ ≥ b✝⁴
⊢ MeasurableSet (B f K ((1 / 2) ^ b✝³) ((1 / 2) ^ b✝¹) ((1 / 2) ^ b✝⁵))
state_after: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K✝ K : Set F
hK : IsComplete K
b✝⁵ b✝⁴ b✝³ : ℕ
b✝² : b✝³ ≥ b✝⁴
b✝¹ : ℕ
b✝ : b✝¹ ≥ b✝⁴
⊢ Countable F
Theorem: EReal.inv_inv
File: Mathlib/Data/Real/EReal.lean

tactic: rw [← coe_toReal h' h, ← coe_inv a.toReal, ← coe_inv a.toReal⁻¹, _root_.inv_inv a.toReal]
state_before: a : EReal
h : a ≠ ⊥
h' : a ≠ ⊤
⊢ a⁻¹⁻¹ = a
state_after: no goals
Theorem: EMetric.uniformEmbedding_iff'
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: rw [uniformEmbedding_iff_uniformInducing, uniformInducing_iff, uniformContinuous_iff]
state_before: α : Type u
β : Type v
X : Type u_1
inst✝² : PseudoEMetricSpace α
γ : Type w
inst✝¹ : EMetricSpace γ
inst✝ : EMetricSpace β
f : γ → β
⊢ UniformEmbedding f ↔
    (∀ ε > 0, ∃ δ > 0, ∀ {a b : γ}, edist a b < δ → edist (f a) (f b) < ε) ∧
      ∀ δ > 0, ∃ ε > 0, ∀ {a b : γ}, edist (f a) (f b) < ε → edist a b < δ
state_after: no goals
Theorem: Monotone.of_map_inf
File: Mathlib/Order/Lattice.lean

tactic: rw [← h, inf_eq_left.2 hxy]
state_before: α : Type u
β : Type v
inst✝¹ : SemilatticeInf α
inst✝ : SemilatticeInf β
f : α → β
h : ∀ (x y : α), f (x ⊓ y) = f x ⊓ f y
x y : α
hxy : x ≤ y
⊢ f x ⊓ f y = f x
state_after: no goals
Theorem: Submodule.mul_induction_on'
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: refine Exists.elim ?_ fun (hr : r ∈ M * N) (hc : C r hr) => hc
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
C : (r : A) → r ∈ M * N → Prop
mem_mul_mem : ∀ (m : A) (hm : m ∈ M) (n : A) (hn : n ∈ N), C (m * n) ⋯
add : ∀ (x : A) (hx : x ∈ M * N) (y : A) (hy : y ∈ M * N), C x hx → C y hy → C (x + y) ⋯
r : A
hr : r ∈ M * N
⊢ C r hr
state_after: ι : 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
C : (r : A) → r ∈ M * N → Prop
mem_mul_mem : ∀ (m : A) (hm : m ∈ M) (n : A) (hn : n ∈ N), C (m * n) ⋯
add : ∀ (x : A) (hx : x ∈ M * N) (y : A) (hy : y ∈ M * N), C x hx → C y hy → C (x + y) ⋯
r : A
hr : r ∈ M * N
⊢ ∃ (x : r ∈ M * N), C r x

tactic: exact
  Submodule.mul_induction_on hr
    (fun x hx y hy => ⟨_, mem_mul_mem _ hx _ hy⟩)
    fun x y ⟨_, hx⟩ ⟨_, hy⟩ => ⟨_, add _ _ _ _ hx hy⟩
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
C : (r : A) → r ∈ M * N → Prop
mem_mul_mem : ∀ (m : A) (hm : m ∈ M) (n : A) (hn : n ∈ N), C (m * n) ⋯
add : ∀ (x : A) (hx : x ∈ M * N) (y : A) (hy : y ∈ M * N), C x hx → C y hy → C (x + y) ⋯
r : A
hr : r ∈ M * N
⊢ ∃ (x : r ∈ M * N), C r x
state_after: no goals
Theorem: Int.land_bit
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← bitwise_and, bitwise_bit]
state_before: a : Bool
m : ℤ
b : Bool
n : ℤ
⊢ (bit a m).land (bit b n) = bit (a && b) (m.land n)
state_after: no goals
Theorem: CliffordAlgebra.ι_mul_ι_mul_invOf_ι
File: Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean

tactic: rw [invOf_ι, map_smul, mul_smul_comm, ι_mul_ι_mul_ι, ← map_smul, smul_sub, smul_smul, smul_smul,
  invOf_mul_self, one_smul]
state_before: R : Type u_1
M : Type u_2
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
Q : QuadraticForm R M
a b : M
inst✝¹ : Invertible ((ι Q) a)
inst✝ : Invertible (Q a)
⊢ (ι Q) a * (ι Q) b * ⅟((ι Q) a) = (ι Q) ((⅟(Q a) * QuadraticForm.polar (⇑Q) a b) • a - b)
state_after: no goals
Theorem: List.getElem?_enum
File: Mathlib/Data/List/Enum.lean

tactic: rw [enum, getElem?_enumFrom, Nat.zero_add]
state_before: α : Type u_1
β : Type u_2
l : List α
n : ℕ
⊢ l.enum[n]? = Option.map (fun a => (n, a)) l[n]?
state_after: no goals
Theorem: Set.uIoc_eq_union
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: cases le_total a b <;> simp [uIoc, *]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
⊢ Ι a b = Ioc a b ∪ Ioc b a
state_after: no goals
Theorem: SimpleGraph.Iso.connectedComponentEquiv_trans
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: ext ⟨_⟩
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
⊢ connectedComponentEquiv (RelIso.trans φ φ') = φ.connectedComponentEquiv.trans φ'.connectedComponentEquiv
state_after: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
x✝ : G.ConnectedComponent
a✝ : V
⊢ (connectedComponentEquiv (RelIso.trans φ φ')) (Quot.mk G.Reachable a✝) =
    (φ.connectedComponentEquiv.trans φ'.connectedComponentEquiv) (Quot.mk G.Reachable a✝)

tactic: rfl
state_before: case H.mk
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
φ : G ≃g G'
φ' : G' ≃g G''
x✝ : G.ConnectedComponent
a✝ : V
⊢ (connectedComponentEquiv (RelIso.trans φ φ')) (Quot.mk G.Reachable a✝) =
    (φ.connectedComponentEquiv.trans φ'.connectedComponentEquiv) (Quot.mk G.Reachable a✝)
state_after: no goals
Theorem: HomologicalComplex₂.d₁_eq_zero'
File: Mathlib/Algebra/Homology/TotalComplex.lean

tactic: rw [totalAux.d₁_eq' K c₁₂ h i₂ i₁₂, K.toGradedObject.ιMapObjOrZero_eq_zero, comp_zero, smul_zero]
state_before: C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ i₁' : I₁
h : c₁.Rel i₁ i₁'
i₂ : I₂
i₁₂ : I₁₂
h' : c₁.π c₂ c₁₂ (i₁', i₂) ≠ i₁₂
⊢ K.d₁ c₁₂ i₁ i₂ i₁₂ = 0
state_after: case h
C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ i₁' : I₁
h : c₁.Rel i₁ i₁'
i₂ : I₂
i₁₂ : I₁₂
h' : c₁.π c₂ c₁₂ (i₁', i₂) ≠ i₁₂
⊢ c₁.π c₂ c₁₂ (i₁', i₂) ≠ i₁₂

tactic: exact h'
state_before: case h
C : Type u_1
inst✝⁴ : Category.{u_5, u_1} C
inst✝³ : Preadditive C
I₁ : Type u_2
I₂ : Type u_3
I₁₂ : Type u_4
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
K L M : HomologicalComplex₂ C c₁ c₂
φ : K ⟶ L
e : K ≅ L
ψ : L ⟶ M
c₁₂ : ComplexShape I₁₂
inst✝² : DecidableEq I₁₂
inst✝¹ : TotalComplexShape c₁ c₂ c₁₂
inst✝ : K.HasTotal c₁₂
i₁ i₁' : I₁
h : c₁.Rel i₁ i₁'
i₂ : I₂
i₁₂ : I₁₂
h' : c₁.π c₂ c₁₂ (i₁', i₂) ≠ i₁₂
⊢ c₁.π c₂ c₁₂ (i₁', i₂) ≠ i₁₂
state_after: no goals
Theorem: unique_uniformity_of_compact
File: Mathlib/Topology/UniformSpace/Compact.lean

tactic: refine UniformSpace.ext ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
⊢ u = u'
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
⊢ 𝓤 γ = 𝓤 γ

tactic: have : @CompactSpace γ u.toTopologicalSpace := by rwa [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
⊢ 𝓤 γ = 𝓤 γ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ

tactic: have : @CompactSpace γ u'.toTopologicalSpace := by rwa [h']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this✝ : CompactSpace γ
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ

tactic: rw [@compactSpace_uniformity _ u, compactSpace_uniformity, h, h']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this✝ : CompactSpace γ
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ
state_after: no goals

tactic: rwa [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
⊢ CompactSpace γ
state_after: no goals

tactic: rwa [h']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this : CompactSpace γ
⊢ CompactSpace γ
state_after: no goals
Theorem: ENNReal.div_le_of_le_mul
File: Mathlib/Data/ENNReal/Inv.lean

tactic: by_cases h0 : c = 0
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
⊢ a / c ≤ b
state_after: case pos
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : c = 0
⊢ a / c ≤ b

case neg
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : ¬c = 0
⊢ a / c ≤ b

tactic: by_cases hinf : c = ∞
state_before: case neg
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : ¬c = 0
⊢ a / c ≤ b
state_after: case pos
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : ¬c = 0
hinf : c = ⊤
⊢ a / c ≤ b

case neg
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : ¬c = 0
hinf : ¬c = ⊤
⊢ a / c ≤ b

tactic: exact (ENNReal.div_le_iff_le_mul (Or.inl h0) (Or.inl hinf)).2 h
state_before: case neg
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : ¬c = 0
hinf : ¬c = ⊤
⊢ a / c ≤ b
state_after: no goals

tactic: have : a = 0 := by simpa [h0] using h
state_before: case pos
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : c = 0
⊢ a / c ≤ b
state_after: case pos
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : c = 0
this : a = 0
⊢ a / c ≤ b

tactic: simp [*]
state_before: case pos
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : c = 0
this : a = 0
⊢ a / c ≤ b
state_after: no goals

tactic: simpa [h0] using h
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : c = 0
⊢ a = 0
state_after: no goals

tactic: simp [hinf]
state_before: case pos
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : a ≤ b * c
h0 : ¬c = 0
hinf : c = ⊤
⊢ a / c ≤ b
state_after: no goals
Theorem: Nat.findGreatest_mono_right
File: Mathlib/Data/Nat/Defs.lean

tactic: induction' hmn with k hmk ih
state_before: a b c d m✝ n✝¹ k : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n : ℕ
hmn : m ≤ n
⊢ findGreatest P m ≤ findGreatest P n
state_after: case refl
a b c d m✝ n✝¹ k : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n : ℕ
⊢ findGreatest P m ≤ findGreatest P m

case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ findGreatest P k.succ

tactic: rw [findGreatest_succ]
state_before: case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ findGreatest P k.succ
state_after: case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ if P (k + 1) then k + 1 else findGreatest P k

tactic: split_ifs
state_before: case step
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
⊢ findGreatest P m ≤ if P (k + 1) then k + 1 else findGreatest P k
state_after: case pos
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
h✝ : P (k + 1)
⊢ findGreatest P m ≤ k + 1

case neg
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
h✝ : ¬P (k + 1)
⊢ findGreatest P m ≤ findGreatest P k

tactic: simp
state_before: case refl
a b c d m✝ n✝¹ k : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n : ℕ
⊢ findGreatest P m ≤ findGreatest P m
state_after: no goals

tactic: exact le_trans ih $ le_trans (findGreatest_le _) (le_succ _)
state_before: case pos
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
h✝ : P (k + 1)
⊢ findGreatest P m ≤ k + 1
state_after: no goals

tactic: exact ih
state_before: case neg
a b c d m✝ n✝¹ k✝ : ℕ
p q P✝ Q : ℕ → Prop
inst✝¹ : DecidablePred P✝
n✝ : ℕ
P : ℕ → Prop
inst✝ : DecidablePred P
m n k : ℕ
hmk : m.le k
ih : findGreatest P m ≤ findGreatest P k
h✝ : ¬P (k + 1)
⊢ findGreatest P m ≤ findGreatest P k
state_after: no goals
Theorem: DirichletCharacter.modZero_eq_delta
File: Mathlib/NumberTheory/LSeries/Dirichlet.lean

tactic: ext n
state_before: χ : DirichletCharacter ℂ 0
⊢ (fun n => χ ↑n) = δ
state_after: case h
χ : DirichletCharacter ℂ 0
n : ℕ
⊢ χ ↑n = δ n

tactic: rcases eq_or_ne n 0 with rfl | hn
state_before: case h
χ : DirichletCharacter ℂ 0
n : ℕ
⊢ χ ↑n = δ n
state_after: case h.inl
χ : DirichletCharacter ℂ 0
⊢ χ ↑0 = δ 0

case h.inr
χ : DirichletCharacter ℂ 0
n : ℕ
hn : n ≠ 0
⊢ χ ↑n = δ n

tactic: rcases eq_or_ne n 1 with rfl | hn'
state_before: case h.inr
χ : DirichletCharacter ℂ 0
n : ℕ
hn : n ≠ 0
⊢ χ ↑n = δ n
state_after: case h.inr.inl
χ : DirichletCharacter ℂ 0
hn : 1 ≠ 0
⊢ χ ↑1 = δ 1

case h.inr.inr
χ : DirichletCharacter ℂ 0
n : ℕ
hn : n ≠ 0
hn' : n ≠ 1
⊢ χ ↑n = δ n

tactic: have : ¬ IsUnit (n : ZMod 0) := fun h ↦ hn' <| ZMod.eq_one_of_isUnit_natCast h
state_before: case h.inr.inr
χ : DirichletCharacter ℂ 0
n : ℕ
hn : n ≠ 0
hn' : n ≠ 1
⊢ χ ↑n = δ n
state_after: case h.inr.inr
χ : DirichletCharacter ℂ 0
n : ℕ
hn : n ≠ 0
hn' : n ≠ 1
this : ¬IsUnit ↑n
⊢ χ ↑n = δ n

tactic: simp only [χ.map_nonunit this, delta, hn', ↓reduceIte]
state_before: case h.inr.inr
χ : DirichletCharacter ℂ 0
n : ℕ
hn : n ≠ 0
hn' : n ≠ 1
this : ¬IsUnit ↑n
⊢ χ ↑n = δ n
state_after: no goals

tactic: simp_rw [cast_zero, χ.map_nonunit not_isUnit_zero, delta, if_false]
state_before: case h.inl
χ : DirichletCharacter ℂ 0
⊢ χ ↑0 = δ 0
state_after: no goals

tactic: simp only [cast_one, map_one, delta, ↓reduceIte]
state_before: case h.inr.inl
χ : DirichletCharacter ℂ 0
hn : 1 ≠ 0
⊢ χ ↑1 = δ 1
state_after: no goals
Theorem: Finset.erase_inter_comm
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [erase_inter, inter_erase]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s✝ t✝ u v : Finset α
a✝ b : α
s t : Finset α
a : α
⊢ s.erase a ∩ t = s ∩ t.erase a
state_after: no goals
Theorem: Language.reverse_mem_reverse
File: Mathlib/Computability/Language.lean

tactic: rw [mem_reverse, List.reverse_reverse]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
l m : Language α
a b x : List α
⊢ a.reverse ∈ l.reverse ↔ a ∈ l
state_after: no goals
Theorem: TopologicalSpace.Opens.inclusion_map_eq_top
File: Mathlib/Topology/Category/TopCat/Opens.lean

tactic: ext1
state_before: X : TopCat
U : Opens ↑X
⊢ (map U.inclusion).obj U = ⊤
state_after: case h
X : TopCat
U : Opens ↑X
⊢ ↑((map U.inclusion).obj U) = ↑⊤

tactic: exact Subtype.coe_preimage_self _
state_before: case h
X : TopCat
U : Opens ↑X
⊢ ↑((map U.inclusion).obj U) = ↑⊤
state_after: no goals