tasksource/leandojo huggingface dataset:
Theorem: BoxIntegral.Box.withBotCoe_inj
File: Mathlib/Analysis/BoxIntegral/Box/Basic.lean

tactic: simp only [Subset.antisymm_iff, ← le_antisymm_iff, withBotCoe_subset_iff]
state_before: ι : Type u_1
I✝ J✝ : Box ι
x y : ι → ℝ
I J : WithBot (Box ι)
⊢ ↑I = ↑J ↔ I = J
Theorem: VectorBundleCore.localTriv_symm_apply
File: Mathlib/Topology/VectorBundle/Basic.lean

tactic: apply (Z.localTriv i).symm_apply hb v
state_before: R : Type u_2
B : Type u_1
F : Type u_3
E : B → Type ?u.410614
inst✝⁸ : NontriviallyNormedField R
inst✝⁷ : (x : B) → AddCommMonoid (E x)
inst✝⁶ : (x : B) → Module R (E x)
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace R F
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace (TotalSpace E)
inst✝¹ : (x : B) → TopologicalSpace (E x)
inst✝ : FiberBundle F E
ι : Type u_4
Z : VectorBundleCore R B F ι
b✝ : B
a : F
i j : ι
b : B
hb : b ∈ baseSet Z i
v : F
⊢ Trivialization.symm (localTriv Z i) b v = ↑(coordChange Z i (indexAt Z b) b) v
Theorem: lowerCentralSeries_succ_eq_bot
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: rw [lowerCentralSeries_succ, closure_eq_bot_iff, Set.subset_singleton_iff]
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
h : lowerCentralSeries G n ≤ center G
⊢ lowerCentralSeries G (n + 1) = ⊥

tactic: rintro x ⟨y, hy1, z, ⟨⟩, rfl⟩
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
h : lowerCentralSeries G n ≤ center G
⊢ ∀ (y : G), y ∈ {x | ∃ p, p ∈ lowerCentralSeries G n ∧ ∃ q, q ∈ ⊤ ∧ p * q * p⁻¹ * q⁻¹ = x} → y = 1

tactic: rw [mul_assoc, ← mul_inv_rev, mul_inv_eq_one, eq_comm]
state_before: case intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
h : lowerCentralSeries G n ≤ center G
y : G
hy1 : y ∈ lowerCentralSeries G n
z : G
⊢ y * z * y⁻¹ * z⁻¹ = 1

tactic: exact mem_center_iff.mp (h hy1) z
state_before: case intro.intro.intro.intro.intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
n : ℕ
h : lowerCentralSeries G n ≤ center G
y : G
hy1 : y ∈ lowerCentralSeries G n
z : G
⊢ z * y = y * z
Theorem: MeasureTheory.MeasurePreserving.aestronglyMeasurable_comp_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: rw [← hf.map_eq, h₂.aestronglyMeasurable_map_iff]
state_before: α : Type u_2
β✝ : Type ?u.393825
γ : Type u_3
ι : Type ?u.393831
inst✝² : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝¹ : TopologicalSpace β✝
inst✝ : TopologicalSpace γ
f✝ g✝ : α → β✝
β : Type u_1
f : α → β
mα : MeasurableSpace α
μa : Measure α
mβ : MeasurableSpace β
μb : Measure β
hf : MeasurePreserving f
h₂ : MeasurableEmbedding f
g : β → γ
⊢ AEStronglyMeasurable (g ∘ f) μa ↔ AEStronglyMeasurable g μb
Theorem: MulChar.ofUnitHom_coe
File: Mathlib/NumberTheory/LegendreSymbol/MulCharacter.lean

tactic: simp [ofUnitHom]
state_before: R : Type u
inst✝¹ : CommMonoid R
R' : Type v
inst✝ : CommMonoidWithZero R'
f : Rˣ →* R'ˣ
a : Rˣ
⊢ ↑(ofUnitHom f) ↑a = ↑(↑f a)
Theorem: Nat.not_dvd_ord_compl
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rw [Nat.Prime.dvd_iff_one_le_factorization hp (ord_compl_pos p hn).ne']
state_before: n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬p ∣ n / p ^ ↑(factorization n) p

tactic: rw [Nat.factorization_div (Nat.ord_proj_dvd n p)]
state_before: n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬1 ≤ ↑(factorization (n / p ^ ↑(factorization n) p)) p

tactic: simp [hp.factorization]
state_before: n p : ℕ
hp : Prime p
hn : n ≠ 0
⊢ ¬1 ≤ ↑(factorization n - factorization (p ^ ↑(factorization n) p)) p
Theorem: MeasureTheory.meas_ge_le_lintegral_div
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [mul_comm]
state_before: α : Type u_1
β : Type ?u.966398
γ : Type ?u.966401
δ : Type ?u.966404
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f
ε : ℝ≥0∞
hε : ε ≠ 0
hε' : ε ≠ ⊤
⊢ ↑↑μ {x | ε ≤ f x} * ε ≤ ∫⁻ (a : α), f a ∂μ

tactic: exact mul_meas_ge_le_lintegral₀ hf ε
state_before: α : Type u_1
β : Type ?u.966398
γ : Type ?u.966401
δ : Type ?u.966404
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f
ε : ℝ≥0∞
hε : ε ≠ 0
hε' : ε ≠ ⊤
⊢ ε * ↑↑μ {x | ε ≤ f x} ≤ ∫⁻ (a : α), f a ∂μ
Theorem: Complex.arg_cos_add_sin_mul_I_sub
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rw [← one_mul (_ + _), ← ofReal_one, arg_mul_cos_add_sin_mul_I_sub zero_lt_one]
state_before: θ : ℝ
⊢ arg (cos ↑θ + sin ↑θ * I) - θ = 2 * π * ↑⌊(π - θ) / (2 * π)⌋
Theorem: wittStructureInt_prop
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: p : ℕ
R : Type ?u.1510099
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
n : ℕ
⊢ ↑(bind₁ (wittStructureInt p Φ)) (W_ ℤ n) = ↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℤ n)) Φ

tactic: have := wittStructureRat_prop p (map (Int.castRingHom ℚ) Φ) n
state_before: case a
p : ℕ
R : Type ?u.1510099
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
n : ℕ
⊢ ↑(map (Int.castRingHom ℚ)) (↑(bind₁ (wittStructureInt p Φ)) (W_ ℤ n)) =
    ↑(map (Int.castRingHom ℚ)) (↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℤ n)) Φ)

tactic: simpa only [map_bind₁, ← eval₂Hom_map_hom, eval₂Hom_C_left, map_rename, map_wittPolynomial,
  AlgHom.coe_toRingHom, map_wittStructureInt]
state_before: case a
p : ℕ
R : Type ?u.1510099
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
n : ℕ
this :
  ↑(bind₁ (wittStructureRat p (↑(map (Int.castRingHom ℚ)) Φ))) (W_ ℚ n) =
    ↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℚ n)) (↑(map (Int.castRingHom ℚ)) Φ)
⊢ ↑(map (Int.castRingHom ℚ)) (↑(bind₁ (wittStructureInt p Φ)) (W_ ℤ n)) =
    ↑(map (Int.castRingHom ℚ)) (↑(bind₁ fun i => ↑(rename (Prod.mk i)) (W_ ℤ n)) Φ)
Theorem: SimpleGraph.Preconnected.ofBoxProdRight
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: classical
rintro b₁ b₂
obtain ⟨w⟩ := h (Classical.arbitrary _, b₁) (Classical.arbitrary _, b₂)
exact ⟨w.ofBoxProdRight⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82447
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty α
h : Preconnected (G □ H)
⊢ Preconnected H

tactic: rintro b₁ b₂
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82447
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty α
h : Preconnected (G □ H)
⊢ Preconnected H

tactic: obtain ⟨w⟩ := h (Classical.arbitrary _, b₁) (Classical.arbitrary _, b₂)
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.82447
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty α
h : Preconnected (G □ H)
b₁ b₂ : β
⊢ Reachable H b₁ b₂

tactic: exact ⟨w.ofBoxProdRight⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.82447
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty α
h : Preconnected (G □ H)
b₁ b₂ : β
w : Walk (G □ H) (Classical.arbitrary α, b₁) (Classical.arbitrary α, b₂)
⊢ Reachable H b₁ b₂
Theorem: Function.invFunOn_pos
File: Mathlib/Data/Set/Function.lean

tactic: rw [invFunOn, dif_pos h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64809
ι : Sort ?u.64812
π : α → Type ?u.64817
inst✝ : Nonempty α
s : Set α
f : α → β
a : α
b : β
h : ∃ a, a ∈ s ∧ f a = b
⊢ invFunOn f s b ∈ s ∧ f (invFunOn f s b) = b

tactic: exact Classical.choose_spec h
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.64809
ι : Sort ?u.64812
π : α → Type ?u.64817
inst✝ : Nonempty α
s : Set α
f : α → β
a : α
b : β
h : ∃ a, a ∈ s ∧ f a = b
⊢ Classical.choose h ∈ s ∧ f (Classical.choose h) = b
Theorem: Set.Iic.isCoatom_iff
File: Mathlib/Order/Atoms.lean

tactic: rw [← covby_top_iff]
state_before: α : Type u_1
β : Type ?u.7617
inst✝ : PartialOrder α
a✝ b : α
a : ↑(Iic b)
⊢ IsCoatom a ↔ ↑a ⋖ b

tactic: refine' (Set.OrdConnected.apply_covby_apply_iff (OrderEmbedding.subtype fun c => c ≤ b) _).symm
state_before: α : Type u_1
β : Type ?u.7617
inst✝ : PartialOrder α
a✝ b : α
a : ↑(Iic b)
⊢ a ⋖ ⊤ ↔ ↑a ⋖ b

tactic: simpa only [OrderEmbedding.subtype_apply, Subtype.range_coe_subtype] using Set.ordConnected_Iic
state_before: α : Type u_1
β : Type ?u.7617
inst✝ : PartialOrder α
a✝ b : α
a : ↑(Iic b)
⊢ OrdConnected (range ↑(OrderEmbedding.subtype fun c => c ≤ b))
Theorem: gauge_lt_eq
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: ext
state_before: 𝕜 : Type ?u.66870
E : Type u_1
F : Type ?u.66876
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
⊢ {x | gauge s x < a} = ⋃ (r : ℝ) (_ : r ∈ Ioo 0 a), r • s

tactic: simp_rw [mem_setOf, mem_iUnion, exists_prop, mem_Ioo, and_assoc]
state_before: case h
𝕜 : Type ?u.66870
E : Type u_1
F : Type ?u.66876
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
x✝ : E
⊢ x✝ ∈ {x | gauge s x < a} ↔ x✝ ∈ ⋃ (r : ℝ) (_ : r ∈ Ioo 0 a), r • s

tactic: exact
  ⟨exists_lt_of_gauge_lt absorbs, fun ⟨r, hr₀, hr₁, hx⟩ =>
    (gauge_le_of_mem hr₀.le hx).trans_lt hr₁⟩
state_before: case h
𝕜 : Type ?u.66870
E : Type u_1
F : Type ?u.66876
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a✝ : ℝ
absorbs : Absorbent ℝ s
a : ℝ
x✝ : E
⊢ gauge s x✝ < a ↔ ∃ i, 0 < i ∧ i < a ∧ x✝ ∈ i • s
Theorem: Filter.HasBasis.uniformEmbedding_iff'
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: rw [uniformEmbedding_iff, and_comm, h.uniformInducing_iff h']
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
ι : Sort u_1
ι' : Sort u_2
p : ι → Prop
p' : ι' → Prop
s : ι → Set (α × α)
s' : ι' → Set (β × β)
h : HasBasis (𝓤 α) p s
h' : HasBasis (𝓤 β) p' s'
f : α → β
⊢ UniformEmbedding f ↔
    Injective f ∧
      (∀ (i : ι'), p' i → ∃ j, p j ∧ ∀ (x y : α), (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
        ∀ (j : ι), p j → ∃ i, p' i ∧ ∀ (x y : α), (f x, f y) ∈ s' i → (x, y) ∈ s j
Theorem: compl_top
File: Mathlib/Order/Heyting/Basic.lean

tactic: rw [le_compl_iff_disjoint_right, disjoint_top, le_bot_iff]
state_before: ι : Type ?u.161852
α : Type u_1
β : Type ?u.161858
inst✝ : HeytingAlgebra α
a✝ b c a : α
⊢ a ≤ ⊤ᶜ ↔ a ≤ ⊥
Theorem: BinaryHeap.size_pos_of_max
File: Mathlib/Data/BinaryHeap.lean

tactic: simp [BinaryHeap.max, Array.get?, h] at e
state_before: α : Type u_1
x : α
lt : α → α → Bool
self : BinaryHeap α lt
e : max self = some x
h : ¬0 < Array.size self.arr
⊢ False
Theorem: isGδ_iInter
File: Mathlib/Topology/GDelta.lean

tactic: choose T hTo hTc hTs using hs
state_before: α : Type u_2
β : Type ?u.1911
γ : Type ?u.1914
ι : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Encodable ι
s : ι → Set α
hs : ∀ (i : ι), IsGδ (s i)
⊢ IsGδ (⋂ (i : ι), s i)

tactic: obtain rfl : s = fun i => ⋂₀ T i := funext hTs
state_before: α : Type u_2
β : Type ?u.1911
γ : Type ?u.1914
ι : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Encodable ι
s : ι → Set α
T : ι → Set (Set α)
hTo : ∀ (i : ι) (t : Set α), t ∈ T i → IsOpen t
hTc : ∀ (i : ι), Set.Countable (T i)
hTs : ∀ (i : ι), s i = ⋂₀ T i
⊢ IsGδ (⋂ (i : ι), s i)

tactic: refine' ⟨⋃ i, T i, _, countable_iUnion hTc, (sInter_iUnion _).symm⟩
state_before: α : Type u_2
β : Type ?u.1911
γ : Type ?u.1914
ι : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Encodable ι
T : ι → Set (Set α)
hTo : ∀ (i : ι) (t : Set α), t ∈ T i → IsOpen t
hTc : ∀ (i : ι), Set.Countable (T i)
hTs : ∀ (i : ι), (fun i => ⋂₀ T i) i = ⋂₀ T i
⊢ IsGδ (⋂ (i : ι), (fun i => ⋂₀ T i) i)

tactic: simpa [@forall_swap ι] using hTo
state_before: α : Type u_2
β : Type ?u.1911
γ : Type ?u.1914
ι : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : Encodable ι
T : ι → Set (Set α)
hTo : ∀ (i : ι) (t : Set α), t ∈ T i → IsOpen t
hTc : ∀ (i : ι), Set.Countable (T i)
hTs : ∀ (i : ι), (fun i => ⋂₀ T i) i = ⋂₀ T i
⊢ ∀ (t : Set α), (t ∈ ⋃ (i : ι), T i) → IsOpen t
Theorem: Matrix.map_zero
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.36987
m : Type u_1
n : Type u_2
o : Type ?u.36996
m' : o → Type ?u.37001
n' : o → Type ?u.37006
R : Type ?u.37009
S : Type ?u.37012
α : Type v
β : Type w
γ : Type ?u.37019
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
⊢ map 0 f = 0

tactic: simp [h]
state_before: case a.h
l : Type ?u.36987
m : Type u_1
n : Type u_2
o : Type ?u.36996
m' : o → Type ?u.37001
n' : o → Type ?u.37006
R : Type ?u.37009
S : Type ?u.37012
α : Type v
β : Type w
γ : Type ?u.37019
inst✝¹ : Zero α
inst✝ : Zero β
f : α → β
h : f 0 = 0
i✝ : m
x✝ : n
⊢ map 0 f i✝ x✝ = OfNat.ofNat 0 i✝ x✝
Theorem: nhdsWithin_singleton
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [nhdsWithin, principal_singleton, inf_eq_right.2 (pure_le_nhds a)]
state_before: α : Type u_1
β : Type ?u.18761
γ : Type ?u.18764
δ : Type ?u.18767
inst✝ : TopologicalSpace α
a : α
⊢ 𝓝[{a}] a = pure a
Theorem: Finsupp.prod_filter_mul_prod_filter_not
File: Mathlib/Data/Finsupp/Basic.lean

tactic: classical simp_rw [prod_filter_index, support_filter, Finset.prod_filter_mul_prod_filter_not,
  Finsupp.prod]
state_before: α : Type u_2
β : Type ?u.476654
γ : Type ?u.476657
ι : Type ?u.476660
M : Type u_3
M' : Type ?u.476666
N : Type u_1
P : Type ?u.476672
G : Type ?u.476675
H : Type ?u.476678
R : Type ?u.476681
S : Type ?u.476684
inst✝¹ : Zero M
p : α → Prop
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
⊢ prod (filter p f) g * prod (filter (fun a => ¬p a) f) g = prod f g

tactic: simp_rw [prod_filter_index, support_filter, Finset.prod_filter_mul_prod_filter_not,
Finsupp.prod]
state_before: α : Type u_2
β : Type ?u.476654
γ : Type ?u.476657
ι : Type ?u.476660
M : Type u_3
M' : Type ?u.476666
N : Type u_1
P : Type ?u.476672
G : Type ?u.476675
H : Type ?u.476678
R : Type ?u.476681
S : Type ?u.476684
inst✝¹ : Zero M
p : α → Prop
f : α →₀ M
inst✝ : CommMonoid N
g : α → M → N
⊢ prod (filter p f) g * prod (filter (fun a => ¬p a) f) g = prod f g
Theorem: Nat.bitwise'_zero_right
File: Mathlib/Init/Data/Nat/Bitwise.lean

tactic: unfold bitwise'
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
⊢ bitwise' f m 0 = bif f true false then m else 0

tactic: apply bitCasesOn m
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
⊢ binaryRec (fun n => bif f false true then n else 0)
      (fun a m Ia => binaryRec (bif f true false then bit a m else 0) fun b n x => bit (f a b) (Ia n)) m 0 =
    bif f true false then m else 0

tactic: intros
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
⊢ ∀ (b : Bool) (n : ℕ),
    binaryRec (fun n => bif f false true then n else 0)
        (fun a m Ia => binaryRec (bif f true false then bit a m else 0) fun b n x => bit (f a b) (Ia n)) (bit b n) 0 =
      bif f true false then bit b n else 0

tactic: rw [binaryRec_eq, binaryRec_zero]
state_before: f : Bool → Bool → Bool
h : f false false = false
m : ℕ
b✝ : Bool
n✝ : ℕ
⊢ binaryRec (fun n => bif f false true then n else 0)
      (fun a m Ia => binaryRec (bif f true false then bit a m else 0) fun b n x => bit (f a b) (Ia n)) (bit b✝ n✝) 0 =
    bif f true false then bit b✝ n✝ else 0

tactic: exact bitwise'_bit_aux h
state_before: case h
f : Bool → Bool → Bool
h : f false false = false
m : ℕ
b✝ : Bool
n✝ : ℕ
⊢ (binaryRec (bif f true false then bit false 0 else 0) fun b n x => bit (f false b) (bif f false true then n else 0)) =
    fun n => bif f false true then n else 0
Theorem: Nat.succ_sub_succ_eq_sub
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction m with
| zero      => exact rfl
| succ m ih => apply congrArg pred ih
state_before: n m : Nat
⊢ succ n - succ m = n - m

tactic: exact rfl
state_before: case zero
n : Nat
⊢ succ n - succ zero = n - zero

tactic: apply congrArg pred ih
state_before: case succ
n m : Nat
ih : succ n - succ m = n - m
⊢ succ n - succ (succ m) = n - succ m
Theorem: Part.Fix.approx_mono'
File: Mathlib/Control/LawfulFix.lean

tactic: induction i with
| zero => dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
| succ _ i_ih => intro ; apply f.monotone; apply i_ih
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i : ℕ
⊢ approx (↑f) i ≤ approx (↑f) (Nat.succ i)

tactic: dsimp [approx]
state_before: case zero
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
⊢ approx (↑f) Nat.zero ≤ approx (↑f) (Nat.succ Nat.zero)

tactic: apply @bot_le _ _ _ (f ⊥)
state_before: case zero
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
⊢ ⊥ ≤ ↑f ⊥

tactic: intro
state_before: case succ
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
n✝ : ℕ
i_ih : approx (↑f) n✝ ≤ approx (↑f) (Nat.succ n✝)
⊢ approx (↑f) (Nat.succ n✝) ≤ approx (↑f) (Nat.succ (Nat.succ n✝))

tactic: apply f.monotone
state_before: case succ
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
n✝ : ℕ
i_ih : approx (↑f) n✝ ≤ approx (↑f) (Nat.succ n✝)
i✝ : α
⊢ approx (↑f) (Nat.succ n✝) i✝ ≤ approx (↑f) (Nat.succ (Nat.succ n✝)) i✝

tactic: apply i_ih
state_before: case succ.a
α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
n✝ : ℕ
i_ih : approx (↑f) n✝ ≤ approx (↑f) (Nat.succ n✝)
i✝ : α
⊢ approx (↑f) n✝ ≤ approx (↑f) (Nat.succ n✝)
Theorem: Set.einfsep_lt_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [einfsep, iInf_lt_iff]
state_before: α : Type u_1
β : Type ?u.12733
inst✝ : EDist α
x y : α
s t : Set α
d : ℝ≥0∞
⊢ einfsep s < d ↔ ∃ x x_1 y x_2 _h, edist x y < d
Theorem: Cardinal.powerlt_le
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [powerlt, ciSup_le_iff']
state_before: α β : Type u
a b c : Cardinal
⊢ a ^< b ≤ c ↔ ∀ (x : Cardinal), x < b → a ^ x ≤ c

tactic: simp
state_before: α β : Type u
a b c : Cardinal
⊢ (∀ (i : ↑(Iio b)), a ^ ↑i ≤ c) ↔ ∀ (x : Cardinal), x < b → a ^ x ≤ c

tactic: rw [← image_eq_range]
state_before: case h
α β : Type u
a b c : Cardinal
⊢ BddAbove (range fun c => a ^ ↑c)

tactic: exact bddAbove_image.{u, u} _ bddAbove_Iio
state_before: case h
α β : Type u
a b c : Cardinal
⊢ BddAbove (HPow.hPow a '' Iio b)
Theorem: FirstOrder.Language.ElementarilyEquivalent.theory_model_iff
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Theory.model_iff_subset_completeTheory, Theory.model_iff_subset_completeTheory,
  h.completeTheory_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type ?u.909458
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
T : Theory L
h : M ≅[L] N
⊢ M ⊨ T ↔ N ⊨ T
Theorem: add_abs_nonneg
File: Mathlib/Algebra/Order/Group/Abs.lean

tactic: rw [← add_right_neg a]
state_before: α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ 0 ≤ a + abs a

tactic: apply add_le_add_left
state_before: α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ a + -a ≤ a + abs a

tactic: exact neg_le_abs_self a
state_before: case bc
α : Type u_1
inst✝² : AddGroup α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
a✝ b c a : α
⊢ -a ≤ abs a
Theorem: CategoryTheory.Idempotents.idem_of_id_sub_idem
File: Mathlib/CategoryTheory/Idempotents/Basic.lean

tactic: simp only [comp_sub, sub_comp, id_comp, comp_id, hp, sub_self, sub_zero]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : C
p : X ⟶ X
hp : p ≫ p = p
⊢ (𝟙 X - p) ≫ (𝟙 X - p) = 𝟙 X - p
Theorem: Set.sep_ext_iff
File: Mathlib/Data/Set/Basic.lean

tactic: simp_rw [ext_iff, mem_sep_iff, and_congr_right_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
p q : α → Prop
x : α
⊢ {x | x ∈ s ∧ p x} = {x | x ∈ s ∧ q x} ↔ ∀ (x : α), x ∈ s → (p x ↔ q x)
Theorem: PythagoreanTriple.isClassified_of_normalize_isPrimitiveClassified
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: convert h.normalize.mul_isClassified (Int.gcd x y)
      (isClassified_of_isPrimitiveClassified h.normalize hc) <;>
  rw [Int.mul_ediv_cancel']
state_before: x y z : ℤ
h : PythagoreanTriple x y z
hc : IsPrimitiveClassified (_ : PythagoreanTriple (x / ↑(Int.gcd x y)) (y / ↑(Int.gcd x y)) (z / ↑(Int.gcd x y)))
⊢ IsClassified h

tactic: exact Int.gcd_dvd_left x y
state_before: case h.e'_1
x y z : ℤ
h : PythagoreanTriple x y z
hc : IsPrimitiveClassified (_ : PythagoreanTriple (x / ↑(Int.gcd x y)) (y / ↑(Int.gcd x y)) (z / ↑(Int.gcd x y)))
⊢ ↑(Int.gcd x y) ∣ x

tactic: exact Int.gcd_dvd_right x y
state_before: case h.e'_2
x y z : ℤ
h : PythagoreanTriple x y z
hc : IsPrimitiveClassified (_ : PythagoreanTriple (x / ↑(Int.gcd x y)) (y / ↑(Int.gcd x y)) (z / ↑(Int.gcd x y)))
⊢ ↑(Int.gcd x y) ∣ y

tactic: exact h.gcd_dvd
state_before: case h.e'_3
x y z : ℤ
h : PythagoreanTriple x y z
hc : IsPrimitiveClassified (_ : PythagoreanTriple (x / ↑(Int.gcd x y)) (y / ↑(Int.gcd x y)) (z / ↑(Int.gcd x y)))
⊢ ↑(Int.gcd x y) ∣ z
Theorem: CancelDenoms.cancel_factors_le
File: Mathlib/Tactic/CancelDenoms.lean

tactic: rw [mul_le_mul_left, ← ha, ← hb, ← mul_assoc, ← mul_assoc, mul_comm bd, mul_le_mul_left]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b ad bd a' b' gcd : α
ha : ad * a = a'
hb : bd * b = b'
had : 0 < ad
hbd : 0 < bd
hgcd : 0 < gcd
⊢ (a ≤ b) = (1 / gcd * (bd * a') ≤ 1 / gcd * (ad * b'))

tactic: exact mul_pos had hbd
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b ad bd a' b' gcd : α
ha : ad * a = a'
hb : bd * b = b'
had : 0 < ad
hbd : 0 < bd
hgcd : 0 < gcd
⊢ 0 < ad * bd

tactic: exact one_div_pos.2 hgcd
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b ad bd a' b' gcd : α
ha : ad * a = a'
hb : bd * b = b'
had : 0 < ad
hbd : 0 < bd
hgcd : 0 < gcd
⊢ 0 < 1 / gcd
Theorem: Filter.principal_univ
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [le_principal_iff, mem_top, eq_self_iff_true]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.78564
ι : Sort x
f g : Filter α
s t : Set α
⊢ ⊤ ≤ 𝓟 univ
Theorem: continuousWithinAt_Icc_iff_Ici
File: Mathlib/Topology/Order/Basic.lean

tactic: simp only [ContinuousWithinAt, nhdsWithin_Icc_eq_nhdsWithin_Ici h]
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁴ : TopologicalSpace α
inst✝³ : LinearOrder α
inst✝² : OrderClosedTopology α
a✝ b✝ : α
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace β
a b : α
f : α → β
h : a < b
⊢ ContinuousWithinAt f (Icc a b) a ↔ ContinuousWithinAt f (Ici a) a
Theorem: MeasureTheory.SimpleFunc.range_comp_subset_range
File: Mathlib/MeasureTheory/Function/SimpleFunc.lean

tactic: simp only [coe_range, coe_comp, Set.range_comp_subset_range]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.60622
inst✝¹ : MeasurableSpace α
inst✝ : MeasurableSpace β
f : β →ₛ γ
g : α → β
hgm : Measurable g
⊢ ↑(SimpleFunc.range (comp f g hgm)) ⊆ ↑(SimpleFunc.range f)
Theorem: Set.preimage_const_add_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iio]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => a + x) ⁻¹' Ioo b c = Ioo (b - a) (c - a)
Theorem: Basis.toDual_toDual
File: Mathlib/LinearAlgebra/Dual.lean

tactic: refine' b.ext fun i => b.dualBasis.ext fun j => _
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
⊢ LinearMap.comp (toDual (dualBasis b)) (toDual b) = Dual.eval R M

tactic: rw [LinearMap.comp_apply, toDual_apply_left, coe_toDual_self, ← coe_dualBasis,
  Dual.eval_apply, Basis.repr_self, Finsupp.single_apply, dualBasis_apply_self]
state_before: R : Type u
M : Type v
K : Type u₁
V : Type u₂
ι : Type w
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : DecidableEq ι
b : Basis ι R M
inst✝ : _root_.Finite ι
i j : ι
⊢ ↑(↑(LinearMap.comp (toDual (dualBasis b)) (toDual b)) (↑b i)) (↑(dualBasis b) j) =
    ↑(↑(Dual.eval R M) (↑b i)) (↑(dualBasis b) j)