tasksource/leandojo huggingface dataset:
Theorem: Pell.xz_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [sub_eq_add_neg, ← mul_neg]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ xz a1 (m - n) = xz a1 m * xz a1 n - ↑(Pell.d a1) * yz a1 m * yz a1 n

tactic: exact congr_arg Zsqrtd.re (pellZd_sub a1 h)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ xz a1 (m - n) = xz a1 m * xz a1 n + ↑(Pell.d a1) * yz a1 m * -yz a1 n
Theorem: ComputablePred.computable_of_manyOneReducible
File: Mathlib/Computability/Reduce.lean

tactic: rcases h₁ with ⟨f, c, hf⟩
state_before: α : Type u_1
β : Type u_2
σ : Type ?u.29812
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
p : α → Prop
q : β → Prop
h₁ : p ≤₀ q
h₂ : ComputablePred q
⊢ ComputablePred p

tactic: rw [show p = fun a => q (f a) from Set.ext hf]
state_before: case intro.intro
α : Type u_1
β : Type u_2
σ : Type ?u.29812
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
p : α → Prop
q : β → Prop
h₂ : ComputablePred q
f : α → β
c : Computable f
hf : ∀ (a : α), p a ↔ q (f a)
⊢ ComputablePred p

tactic: rcases computable_iff.1 h₂ with ⟨g, hg, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
σ : Type ?u.29812
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
p : α → Prop
q : β → Prop
h₂ : ComputablePred q
f : α → β
c : Computable f
hf : ∀ (a : α), p a ↔ q (f a)
⊢ ComputablePred fun a => q (f a)

tactic: exact ⟨by infer_instance, by simpa using hg.comp c⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
σ : Type ?u.29812
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
p : α → Prop
f : α → β
c : Computable f
g : β → Bool
hg : Computable g
h₂ : ComputablePred fun a => g a = true
hf : ∀ (a : α), p a ↔ (fun a => g a = true) (f a)
⊢ ComputablePred fun a => (fun a => g a = true) (f a)

tactic: infer_instance
state_before: α : Type u_1
β : Type u_2
σ : Type ?u.29812
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
p : α → Prop
f : α → β
c : Computable f
g : β → Bool
hg : Computable g
h₂ : ComputablePred fun a => g a = true
hf : ∀ (a : α), p a ↔ (fun a => g a = true) (f a)
⊢ DecidablePred fun a => (fun a => g a = true) (f a)

tactic: simpa using hg.comp c
state_before: α : Type u_1
β : Type u_2
σ : Type ?u.29812
inst✝² : Primcodable α
inst✝¹ : Primcodable β
inst✝ : Primcodable σ
p : α → Prop
f : α → β
c : Computable f
g : β → Bool
hg : Computable g
h₂ : ComputablePred fun a => g a = true
hf : ∀ (a : α), p a ↔ (fun a => g a = true) (f a)
⊢ Computable fun a => decide ((fun a => (fun a => g a = true) (f a)) a)
Theorem: LinearMap.IsProj.eq_conj_prodMap
File: Mathlib/LinearAlgebra/Projection.lean

tactic: rw [LinearEquiv.conj_apply]
state_before: R : Type u_1
inst✝² : CommRing R
E : Type u_2
inst✝¹ : AddCommGroup E
inst✝ : Module R E
p : Submodule R E
f : E →ₗ[R] E
h : IsProj p f
⊢ f = ↑(LinearEquiv.conj (Submodule.prodEquivOfIsCompl p (ker f) (_ : IsCompl p (ker f)))) (prodMap id 0)

tactic: exact h.eq_conj_prod_map'
state_before: R : Type u_1
inst✝² : CommRing R
E : Type u_2
inst✝¹ : AddCommGroup E
inst✝ : Module R E
p : Submodule R E
f : E →ₗ[R] E
h : IsProj p f
⊢ f =
    comp (comp (↑(Submodule.prodEquivOfIsCompl p (ker f) (_ : IsCompl p (ker f)))) (prodMap id 0))
      ↑(LinearEquiv.symm (Submodule.prodEquivOfIsCompl p (ker f) (_ : IsCompl p (ker f))))
Theorem: Set.preimage_add_const_Ioc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x + a) ⁻¹' Ioc b c = Ioc (b - a) (c - a)
Theorem: Int.log_of_left_le_one
File: Mathlib/Data/Int/Log.lean

tactic: cases' le_total 1 r with h h
state_before: R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : b ≤ 1
r : R
⊢ log b r = 0

tactic: rw [log_of_one_le_right _ h, Nat.log_of_left_le_one hb, Int.ofNat_zero]
state_before: case inl
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : b ≤ 1
r : R
h : 1 ≤ r
⊢ log b r = 0

tactic: rw [log_of_right_le_one _ h, Nat.clog_of_left_le_one hb, Int.ofNat_zero, neg_zero]
state_before: case inr
R : Type u_1
inst✝¹ : LinearOrderedSemifield R
inst✝ : FloorSemiring R
b : ℕ
hb : b ≤ 1
r : R
h : r ≤ 1
⊢ log b r = 0
Theorem: Int.measurable_ceil
File: Mathlib/MeasureTheory/Function/Floor.lean

tactic: simpa only [Int.preimage_ceil_singleton] using measurableSet_Ioc
state_before: α : Type ?u.1579
R : Type u_1
inst✝⁶ : MeasurableSpace α
inst✝⁵ : LinearOrderedRing R
inst✝⁴ : FloorRing R
inst✝³ : TopologicalSpace R
inst✝² : OrderTopology R
inst✝¹ : MeasurableSpace R
inst✝ : OpensMeasurableSpace R
x : R
⊢ MeasurableSet (ceil ⁻¹' {⌈x⌉})
Theorem: ENNReal.add_iSup
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: rw [add_comm, iSup_add]
state_before: α : Type ?u.136001
β : Type ?u.136004
γ : Type ?u.136007
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
ι : Sort u_1
s : ι → ℝ≥0∞
inst✝ : Nonempty ι
⊢ a + iSup s = ⨆ (b : ι), a + s b

tactic: simp [add_comm]
state_before: α : Type ?u.136001
β : Type ?u.136004
γ : Type ?u.136007
a b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s✝ : Set ℝ≥0∞
ι : Sort u_1
s : ι → ℝ≥0∞
inst✝ : Nonempty ι
⊢ (⨆ (b : ι), s b + a) = ⨆ (b : ι), a + s b
Theorem: CircleDeg1Lift.tendsto_translationNumber_of_dist_bounded_aux
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: refine' f.tendsto_translationNumber_aux.congr_dist (squeeze_zero (fun _ => dist_nonneg) _ _)
state_before: f g : CircleDeg1Lift
x : ℕ → ℝ
C : ℝ
H : ∀ (n : ℕ), dist (↑(f ^ n) 0) (x n) ≤ C
⊢ Tendsto (fun n => x (2 ^ n) / 2 ^ n) atTop (𝓝 (τ f))

tactic: exact fun n => C / 2 ^ n
state_before: case refine'_1
f g : CircleDeg1Lift
x : ℕ → ℝ
C : ℝ
H : ∀ (n : ℕ), dist (↑(f ^ n) 0) (x n) ≤ C
⊢ ℕ → ℝ

tactic: intro n
state_before: case refine'_2
f g : CircleDeg1Lift
x : ℕ → ℝ
C : ℝ
H : ∀ (n : ℕ), dist (↑(f ^ n) 0) (x n) ≤ C
⊢ ∀ (t : ℕ), dist (transnumAuxSeq f t) (x (2 ^ t) / 2 ^ t) ≤ C / 2 ^ t

tactic: have : 0 < (2 ^ n : ℝ) := pow_pos zero_lt_two _
state_before: case refine'_2
f g : CircleDeg1Lift
x : ℕ → ℝ
C : ℝ
H : ∀ (n : ℕ), dist (↑(f ^ n) 0) (x n) ≤ C
n : ℕ
⊢ dist (transnumAuxSeq f n) (x (2 ^ n) / 2 ^ n) ≤ C / 2 ^ n

tactic: convert (div_le_div_right this).2 (H (2 ^ n)) using 1
state_before: case refine'_2
f g : CircleDeg1Lift
x : ℕ → ℝ
C : ℝ
H : ∀ (n : ℕ), dist (↑(f ^ n) 0) (x n) ≤ C
n : ℕ
this : 0 < 2 ^ n
⊢ dist (transnumAuxSeq f n) (x (2 ^ n) / 2 ^ n) ≤ C / 2 ^ n

tactic: rw [transnumAuxSeq, Real.dist_eq, ← sub_div, abs_div, abs_of_pos this, Real.dist_eq]
state_before: case h.e'_3
f g : CircleDeg1Lift
x : ℕ → ℝ
C : ℝ
H : ∀ (n : ℕ), dist (↑(f ^ n) 0) (x n) ≤ C
n : ℕ
this : 0 < 2 ^ n
⊢ dist (transnumAuxSeq f n) (x (2 ^ n) / 2 ^ n) = dist (↑(f ^ 2 ^ n) 0) (x (2 ^ n)) / 2 ^ n

tactic: exact mul_zero C ▸ tendsto_const_nhds.mul <| tendsto_inv_atTop_zero.comp <|
  tendsto_pow_atTop_atTop_of_one_lt one_lt_two
state_before: case refine'_3
f g : CircleDeg1Lift
x : ℕ → ℝ
C : ℝ
H : ∀ (n : ℕ), dist (↑(f ^ n) 0) (x n) ≤ C
⊢ Tendsto (fun n => C / 2 ^ n) atTop (𝓝 0)
Theorem: exists_rat_gt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: rwa [Rat.cast_coe_nat]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x✝ y ε x : α
n : ℕ
h : x < ↑n
⊢ x < ↑↑n
Theorem: Fintype.choose_subtype_eq
File: Mathlib/Data/Fintype/Basic.lean

tactic: simpa [Subtype.ext_iff] using hy
state_before: α✝ : Type ?u.144755
β : Type ?u.144758
γ : Type ?u.144761
inst✝³ : Fintype α✝
p✝ : α✝ → Prop
inst✝² : DecidablePred p✝
α : Type ?u.144781
p : α → Prop
inst✝¹ : Fintype { a // p a }
inst✝ : DecidableEq α
x y : { a // p a }
hy : (fun a => ↑a = ↑x) y
⊢ y = x

tactic: rw [Subtype.ext_iff, Fintype.choose_spec (fun y : { a : α // p a } => (y : α) = x) _]
state_before: α✝ : Type ?u.144755
β : Type ?u.144758
γ : Type ?u.144761
inst✝³ : Fintype α✝
p✝ : α✝ → Prop
inst✝² : DecidablePred p✝
α : Type u_1
p : α → Prop
inst✝¹ : Fintype { a // p a }
inst✝ : DecidableEq α
x : { a // p a }
h : optParam (∃! a, ↑a = ↑x) (_ : ∃ x_1, (fun a => ↑a = ↑x) x_1 ∧ ∀ (y : { a // p a }), (fun a => ↑a = ↑x) y → y = x_1)
⊢ choose (fun y => ↑y = ↑x) h = x
Theorem: Submodule.mem_sup_right
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: have : T ≤ S ⊔ T := le_sup_right
state_before: R : Type u_1
S✝ : Type ?u.151745
M : Type u_2
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q S T : Submodule R M
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T

tactic: rw [LE.le] at this
state_before: R : Type u_1
S✝ : Type ?u.151745
M : Type u_2
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q S T : Submodule R M
this : T ≤ S ⊔ T
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T

tactic: exact this
state_before: R : Type u_1
S✝ : Type ?u.151745
M : Type u_2
inst✝⁶ : Semiring R
inst✝⁵ : Semiring S✝
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
inst✝² : Module S✝ M
inst✝¹ : SMul S✝ R
inst✝ : IsScalarTower S✝ R M
p q S T : Submodule R M
this : Preorder.toLE.1 T (S ⊔ T)
⊢ ∀ {x : M}, x ∈ T → x ∈ S ⊔ T
Theorem: IsNoetherian.range_finsetBasis
File: Mathlib/FieldTheory/Finiteness.lean

tactic: rw [finsetBasis, Basis.range_reindex, Basis.range_ofVectorSpace]
state_before: K : Type u
V : Type v
inst✝³ : DivisionRing K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
inst✝ : IsNoetherian K V
⊢ Set.range ↑(finsetBasis K V) = Basis.ofVectorSpaceIndex K V
Theorem: Nat.factorization_inj
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simp [h]
state_before: a : ℕ
ha : a ∈ {x | x ≠ 0}
b : ℕ
hb : b ∈ {x | x ≠ 0}
h : factorization a = factorization b
p : ℕ
⊢ ↑(factorization a) p = ↑(factorization b) p
Theorem: PEquiv.mul_toPEquiv_toMatrix
File: Mathlib/Data/Matrix/PEquiv.lean

tactic: rw [PEquiv.matrix_mul_apply, ← Equiv.toPEquiv_symm, Equiv.toPEquiv_apply,
  Matrix.submatrix_apply, id.def]
state_before: k : Type ?u.16360
l : Type ?u.16363
m✝ : Type ?u.16366
n✝ : Type ?u.16369
α✝ : Type v
m : Type u_1
n : Type u_2
α : Type u_3
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : Semiring α
f : n ≃ n
M : Matrix m n α
i : m
j : n
⊢ (M ⬝ toMatrix (Equiv.toPEquiv f)) i j = submatrix M id (↑f.symm) i j
Theorem: Real.mk_mul
File: Mathlib/Data/Real/Basic.lean

tactic: simp [mk, ← ofCauchy_mul]
state_before: x y : ℝ
f g : CauSeq ℚ abs
⊢ mk (f * g) = mk f * mk g
Theorem: CategoryTheory.Preadditive.isSeparating_iff
File: Mathlib/CategoryTheory/Preadditive/Generator.lean

tactic: simpa only [Limits.comp_zero] using hf
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
𝒢 : Set C
h𝒢 : IsSeparating 𝒢
X Y : C
f : X ⟶ Y
hf : ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = 0
⊢ ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ 0

tactic: simpa only [Preadditive.comp_sub, sub_eq_zero] using hfg
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Preadditive C
𝒢 : Set C
h𝒢 : ∀ ⦃X Y : C⦄ (f : X ⟶ Y), (∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = 0) → f = 0
X Y : C
f g : X ⟶ Y
hfg : ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ f = h ≫ g
⊢ ∀ (G : C), G ∈ 𝒢 → ∀ (h : G ⟶ X), h ≫ (f - g) = 0
Theorem: SimpleGraph.Walk.length_darts
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
⊢ List.length (darts p) = length p
Theorem: Set.sInter_eq_iInter
File: Mathlib/Data/Set/Lattice.lean

tactic: simp only [← sInter_range, Subtype.range_coe]
state_before: α : Type u_1
β : Type ?u.167787
γ : Type ?u.167790
ι : Sort ?u.167793
ι' : Sort ?u.167796
ι₂ : Sort ?u.167799
κ : ι → Sort ?u.167804
κ₁ : ι → Sort ?u.167809
κ₂ : ι → Sort ?u.167814
κ' : ι' → Sort ?u.167819
s : Set (Set α)
⊢ ⋂₀ s = ⋂ (i : ↑s), ↑i
Theorem: MeasureTheory.L1.SimpleFunc.setToL1S_smul_real
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

tactic: simp_rw [setToL1S]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.680254
G : Type ?u.680257
𝕜 : Type ?u.680260
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
c : ℝ
f : { x // x ∈ simpleFunc E 1 μ }
⊢ setToL1S T (c • f) = c • setToL1S T f

tactic: rw [← SimpleFunc.setToSimpleFunc_smul_real T h_add c (SimpleFunc.integrable f)]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.680254
G : Type ?u.680257
𝕜 : Type ?u.680260
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
c : ℝ
f : { x // x ∈ simpleFunc E 1 μ }
⊢ SimpleFunc.setToSimpleFunc T (toSimpleFunc (c • f)) = c • SimpleFunc.setToSimpleFunc T (toSimpleFunc f)

tactic: refine' SimpleFunc.setToSimpleFunc_congr T h_zero h_add (SimpleFunc.integrable _) _
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.680254
G : Type ?u.680257
𝕜 : Type ?u.680260
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
c : ℝ
f : { x // x ∈ simpleFunc E 1 μ }
⊢ SimpleFunc.setToSimpleFunc T (toSimpleFunc (c • f)) = SimpleFunc.setToSimpleFunc T (c • toSimpleFunc f)

tactic: exact smul_toSimpleFunc c f
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type ?u.680254
G : Type ?u.680257
𝕜 : Type ?u.680260
p : ℝ≥0∞
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : NormedAddCommGroup F'
inst✝³ : NormedSpace ℝ F'
inst✝² : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝¹ : NormedField 𝕜
inst✝ : NormedSpace 𝕜 E
T : Set α → E →L[ℝ] F
h_zero : ∀ (s : Set α), MeasurableSet s → ↑↑μ s = 0 → T s = 0
h_add : FinMeasAdditive μ T
c : ℝ
f : { x // x ∈ simpleFunc E 1 μ }
⊢ ↑(toSimpleFunc (c • f)) =ᵐ[μ] ↑(c • toSimpleFunc f)
Theorem: sbtw_vadd_const_iff
File: Mathlib/Analysis/Convex/Between.lean

tactic: rw [Sbtw, Sbtw, wbtw_vadd_const_iff, (vadd_right_injective p).ne_iff,
  (vadd_right_injective p).ne_iff]
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.121133
P : Type u_3
P' : Type ?u.121139
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : V
p : P
⊢ Sbtw R (x +ᵥ p) (y +ᵥ p) (z +ᵥ p) ↔ Sbtw R x y z
Theorem: PadicInt.lift_self
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: show _ = RingHom.id _ z
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type ?u.654027
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
z : ℤ_[p]
⊢ ↑(lift
          (_ :
            ∀ (m n : ℕ) (h : m ≤ n),
              RingHom.comp (ZMod.castHom (_ : p ^ m ∣ p ^ n) (ZMod (p ^ m))) (toZModPow n) = toZModPow m))
      z =
    z

tactic: rw [@lift_unique p _ ℤ_[p] _ _ zmod_cast_comp_toZModPow (RingHom.id ℤ_[p])]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type ?u.654027
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
z : ℤ_[p]
⊢ ↑(lift
          (_ :
            ∀ (m n : ℕ) (h : m ≤ n),
              RingHom.comp (ZMod.castHom (_ : p ^ m ∣ p ^ n) (ZMod (p ^ m))) (toZModPow n) = toZModPow m))
      z =
    ↑(RingHom.id ℤ_[p]) z

tactic: intro
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type ?u.654027
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
z : ℤ_[p]
⊢ ∀ (n : ℕ), RingHom.comp (toZModPow n) (RingHom.id ℤ_[p]) = toZModPow n

tactic: rw [RingHom.comp_id]
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
R : Type ?u.654027
inst✝ : NonAssocSemiring R
f : (k : ℕ) → R →+* ZMod (p ^ k)
f_compat : ∀ (k1 k2 : ℕ) (hk : k1 ≤ k2), RingHom.comp (ZMod.castHom (_ : p ^ k1 ∣ p ^ k2) (ZMod (p ^ k1))) (f k2) = f k1
z : ℤ_[p]
n✝ : ℕ
⊢ RingHom.comp (toZModPow n✝) (RingHom.id ℤ_[p]) = toZModPow n✝
Theorem: Finset.map_filter
File: Mathlib/Data/Finset/Image.lean

tactic: simp only [filter_map, Function.comp, Equiv.toEmbedding_apply, Equiv.symm_apply_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.30514
f✝ : α ↪ β
s : Finset α
f : α ≃ β
p : α → Prop
inst✝ : DecidablePred p
⊢ map (Equiv.toEmbedding f) (filter p s) = filter (p ∘ ↑f.symm) (map (Equiv.toEmbedding f) s)
Theorem: Ctop.Realizer.isClosed_iff
File: Mathlib/Data/Analysis/Topology.lean

tactic: haveI := Classical.propDecidable
state_before: α : Type u_1
β : Type ?u.8619
σ : Type ?u.8622
τ : Type ?u.8625
inst✝ : TopologicalSpace α
F : Realizer α
s : Set α
a : α
⊢ (¬a ∈ s → ∃ b, a ∈ f F.F b ∧ ∀ (z : α), z ∈ f F.F b → ¬z ∈ s) ↔
    (∀ (b : F.σ), a ∈ f F.F b → ∃ z, z ∈ f F.F b ∩ s) → a ∈ s

tactic: rw [not_imp_comm]
state_before: α : Type u_1
β : Type ?u.8619
σ : Type ?u.8622
τ : Type ?u.8625
inst✝ : TopologicalSpace α
F : Realizer α
s : Set α
a : α
this : (a : Prop) → Decidable a
⊢ (¬a ∈ s → ∃ b, a ∈ f F.F b ∧ ∀ (z : α), z ∈ f F.F b → ¬z ∈ s) ↔
    (∀ (b : F.σ), a ∈ f F.F b → ∃ z, z ∈ f F.F b ∩ s) → a ∈ s

tactic: simp [not_exists, not_and, not_forall, and_comm]
state_before: α : Type u_1
β : Type ?u.8619
σ : Type ?u.8622
τ : Type ?u.8625
inst✝ : TopologicalSpace α
F : Realizer α
s : Set α
a : α
this : (a : Prop) → Decidable a
⊢ (¬∃ b, a ∈ f F.F b ∧ ∀ (z : α), z ∈ f F.F b → ¬z ∈ s) → a ∈ s ↔
    (∀ (b : F.σ), a ∈ f F.F b → ∃ z, z ∈ f F.F b ∩ s) → a ∈ s
Theorem: NNReal.tsum_mul_left
File: Mathlib/Topology/Instances/NNReal.lean

tactic: simp only [coe_tsum, NNReal.coe_mul, tsum_mul_left]
state_before: α : Type u_1
a : ℝ≥0
f : α → ℝ≥0
⊢ ↑(∑' (x : α), a * f x) = ↑(a * ∑' (x : α), f x)
Theorem: Ordnode.dual_eraseMin
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [eraseMin, dual_balanceR, dual_eraseMin (node sz l' y r'), dual, dual, dual, eraseMax]
state_before: α : Type u_1
size✝ sz : ℕ
l' : Ordnode α
y : α
r' : Ordnode α
x : α
r : Ordnode α
⊢ dual (eraseMin (node size✝ (node sz l' y r') x r)) = eraseMax (dual (node size✝ (node sz l' y r') x r))
Theorem: ack_succ_zero
File: Mathlib/Computability/Ackermann.lean

tactic: rw [ack]
state_before: m : ℕ
⊢ ack (m + 1) 0 = ack m 1
Theorem: PEquiv.trans_eq_none
File: Mathlib/Data/PEquiv.lean

tactic: simp only [eq_none_iff_forall_not_mem, mem_trans, imp_iff_not_or.symm]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
g : β ≃. γ
a : α
⊢ ↑(PEquiv.trans f g) a = none ↔ ∀ (b : β) (c : γ), ¬b ∈ ↑f a ∨ ¬c ∈ ↑g b

tactic: push_neg
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
g : β ≃. γ
a : α
⊢ (∀ (a_1 : γ), ¬∃ b, b ∈ ↑f a ∧ a_1 ∈ ↑g b) ↔ ∀ (b : β) (c : γ), b ∈ ↑f a → ¬c ∈ ↑g b

tactic: exact forall_swap
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
g : β ≃. γ
a : α
⊢ (∀ (a_1 : γ) (b : β), b ∈ ↑f a → ¬a_1 ∈ ↑g b) ↔ ∀ (b : β) (c : γ), b ∈ ↑f a → ¬c ∈ ↑g b
Theorem: gauge_of_subset_zero
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: obtain rfl | rfl := subset_singleton_iff_eq.1 h
state_before: 𝕜 : Type ?u.34254
E : Type u_1
F : Type ?u.34260
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
h : s ⊆ 0
⊢ gauge s = 0

tactic: exacts [gauge_empty, gauge_zero']
state_before: case inl
𝕜 : Type ?u.34254
E : Type u_1
F : Type ?u.34260
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
t : Set E
a : ℝ
h : ∅ ⊆ 0
⊢ gauge ∅ = 0

case inr
𝕜 : Type ?u.34254
E : Type u_1
F : Type ?u.34260
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
t : Set E
a : ℝ
h : {0} ⊆ 0
⊢ gauge {0} = 0
Theorem: FreeAbelianGroup.lift.map_hom
File: Mathlib/GroupTheory/FreeAbelianGroup.lean

tactic: show (g.comp (lift f)) a = lift (g ∘ f) a
state_before: α✝ : Type u
β✝ : Type v
inst✝² : AddCommGroup β✝
f✝ : α✝ → β✝
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : AddCommGroup β
inst✝ : AddCommGroup γ
a : FreeAbelianGroup α
f : α → β
g : β →+ γ
⊢ ↑g (↑(↑lift f) a) = ↑(↑lift (↑g ∘ f)) a

tactic: apply lift.unique
state_before: α✝ : Type u
β✝ : Type v
inst✝² : AddCommGroup β✝
f✝ : α✝ → β✝
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : AddCommGroup β
inst✝ : AddCommGroup γ
a : FreeAbelianGroup α
f : α → β
g : β →+ γ
⊢ ↑(AddMonoidHom.comp g (↑lift f)) a = ↑(↑lift (↑g ∘ f)) a

tactic: intro a
state_before: case hg
α✝ : Type u
β✝ : Type v
inst✝² : AddCommGroup β✝
f✝ : α✝ → β✝
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : AddCommGroup β
inst✝ : AddCommGroup γ
a : FreeAbelianGroup α
f : α → β
g : β →+ γ
⊢ ∀ (x : α), ↑(AddMonoidHom.comp g (↑lift f)) (of x) = (↑g ∘ f) x

tactic: show g ((lift f) (of a)) = g (f a)
state_before: case hg
α✝ : Type u
β✝ : Type v
inst✝² : AddCommGroup β✝
f✝ : α✝ → β✝
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : AddCommGroup β
inst✝ : AddCommGroup γ
a✝ : FreeAbelianGroup α
f : α → β
g : β →+ γ
a : α
⊢ ↑(AddMonoidHom.comp g (↑lift f)) (of a) = (↑g ∘ f) a
Theorem: WithBot.succ_unbot
File: Mathlib/Order/SuccPred/Basic.lean

tactic: induction a using WithBot.recBotCoe <;> simp
state_before: α : Type ?u.61733
inst✝² : Preorder α
inst✝¹ : OrderBot α
inst✝ : SuccOrder α
a : WithBot α
ha : a ≠ ⊥
⊢ succ a ≠ ⊥
Theorem: HolderWith.nndist_le_of_le
File: Mathlib/Topology/MetricSpace/Holder.lean

tactic: norm_cast
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.903365
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ ↑(nndist (f x) (f y)) ≤ ↑C * ↑d ^ ↑r

tactic: rw [← ENNReal.coe_le_coe, ← edist_nndist, ENNReal.coe_mul, ←
  ENNReal.coe_rpow_of_nonneg _ r.coe_nonneg]
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.903365
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ nndist (f x) (f y) ≤ C * d ^ ↑r

tactic: apply hf.edist_le_of_le
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.903365
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ edist (f x) (f y) ≤ ↑C * ↑d ^ ↑r

tactic: rwa [edist_nndist, ENNReal.coe_le_coe]
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.903365
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ edist x y ≤ ↑d
Theorem: Array.foldl_data_eq_bind
File: Std/Data/Array/Init/Lemmas.lean

tactic: induction l generalizing acc <;> simp [*, List.bind]
state_before: α : Type u_1
β : Type u_2
l : List α
acc : Array β
F : Array β → α → Array β
G : α → List β
H : ∀ (acc : Array β) (a : α), (F acc a).data = acc.data ++ G a
⊢ (List.foldl F acc l).data = acc.data ++ List.bind l G