tasksource/leandojo huggingface dataset:
Theorem: FirstOrder.Language.BoundedFormula.realize_sup
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [realize, Sup.sup, realize_not, eq_iff_iff]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.56171
P : Type ?u.56174
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (φ ⊔ ψ) v xs ↔ Realize φ v xs ∨ Realize ψ v xs

tactic: tauto
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.56171
P : Type ?u.56174
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n l : ℕ
φ ψ : BoundedFormula L α l
θ : BoundedFormula L α (Nat.succ l)
v : α → M
xs : Fin l → M
⊢ Realize (∼φ ⟹ ψ) v xs ↔ Realize φ v xs ∨ Realize ψ v xs
Theorem: sbtw_pointReflection_of_ne
File: Mathlib/Analysis/Convex/Between.lean

tactic: refine' ⟨wbtw_pointReflection _ _ _, h, _⟩
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.622495
P : Type u_1
P' : Type ?u.622501
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ Sbtw R y x (↑(pointReflection R x) y)

tactic: nth_rw 1 [← pointReflection_self R x]
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.622495
P : Type u_1
P' : Type ?u.622501
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ x ≠ ↑(pointReflection R x) y

tactic: exact (pointReflection_involutive R x).injective.ne h
state_before: R : Type u_2
V : Type u_3
V' : Type ?u.622495
P : Type u_1
P' : Type ?u.622501
inst✝³ : LinearOrderedField R
inst✝² : AddCommGroup V
inst✝¹ : Module R V
inst✝ : AddTorsor V P
x y : P
h : x ≠ y
⊢ ↑(pointReflection R x) x ≠ ↑(pointReflection R x) y
Theorem: Valuation.one_lt_val_iff
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: simpa using (inv_lt_inv₀ (v.ne_zero_iff.2 h) one_ne_zero).symm
state_before: K : Type u_1
F : Type ?u.2467266
R : Type ?u.2467269
inst✝³ : DivisionRing K
Γ₀ : Type u_2
Γ'₀ : Type ?u.2467278
Γ''₀ : Type ?u.2467281
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v✝ : Valuation R Γ₀
x✝ y z : R
v : Valuation K Γ₀
x : K
h : x ≠ 0
⊢ 1 < ↑v x ↔ ↑v x⁻¹ < 1
Theorem: spectrum.map_pow_of_pos
File: Mathlib/FieldTheory/IsAlgClosed/Spectrum.lean

tactic: simpa only [aeval_X_pow, eval_pow, eval_X]
  using map_polynomial_aeval_of_degree_pos a (X ^ n : 𝕜[X]) (by rwa [degree_X_pow, Nat.cast_pos])
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : IsAlgClosed 𝕜
a : A
n : ℕ
hn : 0 < n
⊢ σ (a ^ n) = (fun x => x ^ n) '' σ a

tactic: rwa [degree_X_pow, Nat.cast_pos]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : IsAlgClosed 𝕜
a : A
n : ℕ
hn : 0 < n
⊢ 0 < degree (X ^ n)
Theorem: Orientation.volumeForm_robust'
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: cases n
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n : ℕ
_i : Fact (finrank ℝ E = n)
o : Orientation ℝ E (Fin n)
b : OrthonormalBasis (Fin n) ℝ E
v : Fin n → E
⊢ abs (↑(volumeForm o) v) = abs (↑(Basis.det (OrthonormalBasis.toBasis b)) v)

tactic: refine' o.eq_or_eq_neg_of_isEmpty.elim _ _ <;> rintro rfl <;> simp
state_before: case zero
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
_i : Fact (finrank ℝ E = Nat.zero)
o : Orientation ℝ E (Fin Nat.zero)
b : OrthonormalBasis (Fin Nat.zero) ℝ E
v : Fin Nat.zero → E
⊢ abs (↑(volumeForm o) v) = abs (↑(Basis.det (OrthonormalBasis.toBasis b)) v)

tactic: rw [o.volumeForm_robust (b.adjustToOrientation o) (b.orientation_adjustToOrientation o),
  b.abs_det_adjustToOrientation]
state_before: case succ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace ℝ E
n✝ : ℕ
_i : Fact (finrank ℝ E = Nat.succ n✝)
o : Orientation ℝ E (Fin (Nat.succ n✝))
b : OrthonormalBasis (Fin (Nat.succ n✝)) ℝ E
v : Fin (Nat.succ n✝) → E
⊢ abs (↑(volumeForm o) v) = abs (↑(Basis.det (OrthonormalBasis.toBasis b)) v)
Theorem: Set.Iic_sInf
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [sInf_eq_iInf, Iic_iInf₂]
state_before: α : Type u_1
β : Type ?u.297838
γ : Type ?u.297841
ι : Sort ?u.297844
ι' : Sort ?u.297847
ι₂ : Sort ?u.297850
κ : ι → Sort ?u.297855
κ₁ : ι → Sort ?u.297860
κ₂ : ι → Sort ?u.297865
κ' : ι' → Sort ?u.297870
inst✝ : CompleteLattice α
s : Set α
⊢ Iic (sInf s) = ⋂ (a : α) (_ : a ∈ s), Iic a
Theorem: Nat.sub_succ_lt_self
File: src/lean/Init/Data/Nat/Basic.lean

tactic: rw [Nat.add_succ, Nat.sub_succ]
state_before: a i : Nat
h : i < a
⊢ a - (i + 1) < a - i

tactic: apply Nat.pred_lt
state_before: a i : Nat
h : i < a
⊢ pred (a - i) < a - i

tactic: apply Nat.not_eq_zero_of_lt
state_before: case a
a i : Nat
h : i < a
⊢ a - i ≠ 0

tactic: apply Nat.zero_lt_sub_of_lt
state_before: case a.h
a i : Nat
h : i < a
⊢ ?a.b✝ < a - i

case a.b
a i : Nat
h : i < a
⊢ Nat

tactic: assumption
state_before: case a.h.h
a i : Nat
h : i < a
⊢ i < a
Theorem: Disjoint.sdiff_eq_of_sup_eq
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [h, hs]
state_before: α : Type u
β : Type ?u.12230
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hi : Disjoint x z
hs : x ⊔ z = y
h : y ⊓ x = x
⊢ y ⊓ x ⊔ z = y

tactic: rw [h, hi.eq_bot]
state_before: α : Type u
β : Type ?u.12230
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
hi : Disjoint x z
hs : x ⊔ z = y
h : y ⊓ x = x
⊢ y ⊓ x ⊓ z = ⊥
Theorem: Nat.decreasingInduction_succ_left
File: Mathlib/Data/Nat/Basic.lean

tactic: rw [Subsingleton.elim mn (le_trans (le_succ m) smn), decreasingInduction_trans,
  decreasingInduction_succ']
state_before: m✝ n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
m n : ℕ
smn : m + 1 ≤ n
mn : m ≤ n
hP : P n
⊢ decreasingInduction h mn hP = h m (decreasingInduction h smn hP)

tactic: apply Nat.le_succ
state_before: case msm
m✝ n✝ k : ℕ
P : ℕ → Sort u_1
h : (n : ℕ) → P (n + 1) → P n
m n : ℕ
smn : m + 1 ≤ n
mn : m ≤ n
hP : P n
⊢ m ≤ m + 1
Theorem: ChartedSpaceCore.open_source'
File: Mathlib/Geometry/Manifold/ChartedSpace.lean

tactic: apply TopologicalSpace.GenerateOpen.basic
state_before: H : Type u
H' : Type ?u.56289
M : Type u_1
M' : Type ?u.56295
M'' : Type ?u.56298
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : LocalEquiv M H
he : e ∈ c.atlas
⊢ IsOpen e.source

tactic: simp only [exists_prop, mem_iUnion, mem_singleton_iff]
state_before: case a
H : Type u
H' : Type ?u.56289
M : Type u_1
M' : Type ?u.56295
M'' : Type ?u.56298
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : LocalEquiv M H
he : e ∈ c.atlas
⊢ e.source ∈ ⋃ (e : LocalEquiv M H) (_ : e ∈ c.atlas) (s : Set H) (_ : IsOpen s), {↑e ⁻¹' s ∩ e.source}

tactic: refine' ⟨e, he, univ, isOpen_univ, _⟩
state_before: case a
H : Type u
H' : Type ?u.56289
M : Type u_1
M' : Type ?u.56295
M'' : Type ?u.56298
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : LocalEquiv M H
he : e ∈ c.atlas
⊢ ∃ i, i ∈ c.atlas ∧ ∃ i_1, IsOpen i_1 ∧ e.source = ↑i ⁻¹' i_1 ∩ i.source

tactic: simp only [Set.univ_inter, Set.preimage_univ]
state_before: case a
H : Type u
H' : Type ?u.56289
M : Type u_1
M' : Type ?u.56295
M'' : Type ?u.56298
inst✝ : TopologicalSpace H
c : ChartedSpaceCore H M
e : LocalEquiv M H
he : e ∈ c.atlas
⊢ e.source = ↑e ⁻¹' univ ∩ e.source
Theorem: Submonoid.LocalizationMap.ofMulEquivOfLocalizations_id
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: ext
state_before: M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type ?u.2927330
inst✝¹ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
Q : Type ?u.2935815
inst✝ : CommMonoid Q
⊢ ofMulEquivOfLocalizations f (MulEquiv.refl N) = f

tactic: rfl
state_before: case h
M : Type u_1
inst✝³ : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝² : CommMonoid N
P : Type ?u.2927330
inst✝¹ : CommMonoid P
f : LocalizationMap S N
g : M →* P
hg : ∀ (y : { x // x ∈ S }), IsUnit (↑g ↑y)
T : Submonoid P
Q : Type ?u.2935815
inst✝ : CommMonoid Q
x✝ : M
⊢ ↑(toMap (ofMulEquivOfLocalizations f (MulEquiv.refl N))) x✝ = ↑(toMap f) x✝
Theorem: ProbabilityTheory.IndepSets.union
File: Mathlib/Probability/Independence/Basic.lean

tactic: intro t1 t2 ht1 ht2
state_before: Ω : Type u_1
ι : Type ?u.972730
inst✝ : MeasurableSpace Ω
s₁ s₂ s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
h₁ : IndepSets s₁ s'
h₂ : IndepSets s₂ s'
⊢ IndepSets (s₁ ∪ s₂) s'

tactic: cases' (Set.mem_union _ _ _).mp ht1 with ht1₁ ht1₂
state_before: Ω : Type u_1
ι : Type ?u.972730
inst✝ : MeasurableSpace Ω
s₁ s₂ s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
h₁ : IndepSets s₁ s'
h₂ : IndepSets s₂ s'
t1 t2 : Set Ω
ht1 : t1 ∈ s₁ ∪ s₂
ht2 : t2 ∈ s'
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: exact h₁ t1 t2 ht1₁ ht2
state_before: case inl
Ω : Type u_1
ι : Type ?u.972730
inst✝ : MeasurableSpace Ω
s₁ s₂ s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
h₁ : IndepSets s₁ s'
h₂ : IndepSets s₂ s'
t1 t2 : Set Ω
ht1 : t1 ∈ s₁ ∪ s₂
ht2 : t2 ∈ s'
ht1₁ : t1 ∈ s₁
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2

tactic: exact h₂ t1 t2 ht1₂ ht2
state_before: case inr
Ω : Type u_1
ι : Type ?u.972730
inst✝ : MeasurableSpace Ω
s₁ s₂ s' : Set (Set Ω)
μ : MeasureTheory.Measure Ω
h₁ : IndepSets s₁ s'
h₂ : IndepSets s₂ s'
t1 t2 : Set Ω
ht1 : t1 ∈ s₁ ∪ s₂
ht2 : t2 ∈ s'
ht1₂ : t1 ∈ s₂
⊢ ↑↑μ (t1 ∩ t2) = ↑↑μ t1 * ↑↑μ t2
Theorem: Complex.abs_eq_one_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: refine' ⟨fun hz => ⟨arg z, _⟩, _⟩
state_before: z : ℂ
⊢ ↑abs z = 1 ↔ ∃ θ, exp (↑θ * I) = z

tactic: calc
  exp (arg z * I) = abs z * exp (arg z * I) := by rw [hz, ofReal_one, one_mul]
  _ = z := abs_mul_exp_arg_mul_I z
state_before: case refine'_1
z : ℂ
hz : ↑abs z = 1
⊢ exp (↑(arg z) * I) = z

tactic: rw [hz, ofReal_one, one_mul]
state_before: z : ℂ
hz : ↑abs z = 1
⊢ exp (↑(arg z) * I) = ↑(↑abs z) * exp (↑(arg z) * I)

tactic: rintro ⟨θ, rfl⟩
state_before: case refine'_2
z : ℂ
⊢ (∃ θ, exp (↑θ * I) = z) → ↑abs z = 1

tactic: exact Complex.abs_exp_ofReal_mul_I θ
state_before: case refine'_2.intro
θ : ℝ
⊢ ↑abs (exp (↑θ * I)) = 1
Theorem: QuaternionGroup.exponent
File: Mathlib/GroupTheory/SpecificGroups/Quaternion.lean

tactic: rw [← normalize_eq 2, ← lcm_mul_left, normalize_eq]
state_before: n : ℕ
⊢ Monoid.exponent (QuaternionGroup n) = 2 * lcm n 2

tactic: norm_num
state_before: n : ℕ
⊢ Monoid.exponent (QuaternionGroup n) = lcm (2 * n) (2 * 2)

tactic: cases' eq_zero_or_neZero n with hn hn
state_before: n : ℕ
⊢ Monoid.exponent (QuaternionGroup n) = lcm (2 * n) 4

tactic: apply Nat.dvd_antisymm
state_before: case inr
n : ℕ
hn : NeZero n
⊢ Monoid.exponent (QuaternionGroup n) = lcm (2 * n) 4

tactic: subst hn
state_before: case inl
n : ℕ
hn : n = 0
⊢ Monoid.exponent (QuaternionGroup n) = lcm (2 * n) 4

tactic: simp only [lcm_zero_left, MulZeroClass.mul_zero]
state_before: case inl

⊢ Monoid.exponent (QuaternionGroup 0) = lcm (2 * 0) 4

tactic: exact Monoid.exponent_eq_zero_of_order_zero orderOf_a_one
state_before: case inl

⊢ Monoid.exponent (QuaternionGroup 0) = 0

tactic: apply Monoid.exponent_dvd_of_forall_pow_eq_one
state_before: case inr.a
n : ℕ
hn : NeZero n
⊢ Monoid.exponent (QuaternionGroup n) ∣ lcm (2 * n) 4

tactic: rintro (m | m)
state_before: case inr.a.hG
n : ℕ
hn : NeZero n
⊢ ∀ (g : QuaternionGroup n), g ^ lcm (2 * n) 4 = 1

tactic: rw [← orderOf_dvd_iff_pow_eq_one, orderOf_a]
state_before: case inr.a.hG.a
n : ℕ
hn : NeZero n
m : ZMod (2 * n)
⊢ a m ^ lcm (2 * n) 4 = 1

tactic: refine' Nat.dvd_trans ⟨gcd (2 * n) m.val, _⟩ (dvd_lcm_left (2 * n) 4)
state_before: case inr.a.hG.a
n : ℕ
hn : NeZero n
m : ZMod (2 * n)
⊢ 2 * n / Nat.gcd (2 * n) (ZMod.val m) ∣ lcm (2 * n) 4

tactic: exact (Nat.div_mul_cancel (Nat.gcd_dvd_left (2 * n) m.val)).symm
state_before: case inr.a.hG.a
n : ℕ
hn : NeZero n
m : ZMod (2 * n)
⊢ 2 * n = 2 * n / Nat.gcd (2 * n) (ZMod.val m) * gcd (2 * n) (ZMod.val m)

tactic: rw [← orderOf_dvd_iff_pow_eq_one, orderOf_xa]
state_before: case inr.a.hG.xa
n : ℕ
hn : NeZero n
m : ZMod (2 * n)
⊢ xa m ^ lcm (2 * n) 4 = 1

tactic: exact dvd_lcm_right (2 * n) 4
state_before: case inr.a.hG.xa
n : ℕ
hn : NeZero n
m : ZMod (2 * n)
⊢ 4 ∣ lcm (2 * n) 4

tactic: apply lcm_dvd
state_before: case inr.a
n : ℕ
hn : NeZero n
⊢ lcm (2 * n) 4 ∣ Monoid.exponent (QuaternionGroup n)

tactic: convert Monoid.order_dvd_exponent (a 1)
state_before: case inr.a.hab
n : ℕ
hn : NeZero n
⊢ 2 * n ∣ Monoid.exponent (QuaternionGroup n)

tactic: exact orderOf_a_one.symm
state_before: case h.e'_3
n : ℕ
hn : NeZero n
⊢ 2 * n = orderOf (a 1)

tactic: convert Monoid.order_dvd_exponent (xa (0 : ZMod (2 * n)))
state_before: case inr.a.hcb
n : ℕ
hn : NeZero n
⊢ 4 ∣ Monoid.exponent (QuaternionGroup n)

tactic: exact (orderOf_xa 0).symm
state_before: case h.e'_3
n : ℕ
hn : NeZero n
⊢ 4 = orderOf (xa 0)
Theorem: FirstOrder.Language.Formula.realize_rel₂
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [Relations.formula₂, realize_rel, iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.237419
P : Type ?u.237422
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ Realize (Relations.formula₂ R t₁ t₂) v ↔ RelMap R ![Term.realize v t₁, Term.realize v t₂]

tactic: refine' congr rfl (funext (Fin.cases _ _))
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.237419
P : Type ?u.237422
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ (RelMap R fun i => Term.realize v (Matrix.vecCons t₁ ![t₂] i)) = RelMap R ![Term.realize v t₁, Term.realize v t₂]

tactic: simp only [Matrix.cons_val_zero]
state_before: case refine'_1
L : Language
L' : Language
M : Type w
N : Type ?u.237419
P : Type ?u.237422
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ Term.realize v (Matrix.vecCons t₁ ![t₂] 0) = Matrix.vecCons (Term.realize v t₁) ![Term.realize v t₂] 0

tactic: simp only [Matrix.cons_val_succ, Matrix.cons_val_fin_one, forall_const]
state_before: case refine'_2
L : Language
L' : Language
M : Type w
N : Type ?u.237419
P : Type ?u.237422
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
n : ℕ
φ ψ : Formula L α
v : α → M
R : Relations L 2
t₁ t₂ : Term L α
⊢ ∀ (i : Fin 1),
    Term.realize v (Matrix.vecCons t₁ ![t₂] (succ i)) = Matrix.vecCons (Term.realize v t₁) ![Term.realize v t₂] (succ i)
Theorem: List.map_subset
File: Std/Data/List/Lemmas.lean

tactic: simp only [mem_map]
state_before: α : Type u_1
β : Type u_2
l₁ l₂ : List α
f : α → β
H : l₁ ⊆ l₂
x : β
⊢ x ∈ map f l₁ → x ∈ map f l₂

tactic: exact .imp fun a => .imp_left (@H _)
state_before: α : Type u_1
β : Type u_2
l₁ l₂ : List α
f : α → β
H : l₁ ⊆ l₂
x : β
⊢ (∃ a, a ∈ l₁ ∧ f a = x) → ∃ a, a ∈ l₂ ∧ f a = x
Theorem: Function.Injective.invFun_restrict
File: Mathlib/Data/Fintype/Basic.lean

tactic: ext ⟨b, h⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.62111
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
⊢ Set.restrict (Set.range f) (invFun f) = invOfMemRange hf

tactic: apply hf
state_before: case h.mk
α : Type u_1
β : Type u_2
γ : Type ?u.62111
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
b : β
h : b ∈ Set.range f
⊢ Set.restrict (Set.range f) (invFun f) { val := b, property := h } = invOfMemRange hf { val := b, property := h }

tactic: simp [hf.left_inv_of_invOfMemRange, @invFun_eq _ _ _ f b (Set.mem_range.mp h)]
state_before: case h.mk.a
α : Type u_1
β : Type u_2
γ : Type ?u.62111
inst✝² : Fintype α
inst✝¹ : DecidableEq β
f : α → β
hf : Injective f
inst✝ : Nonempty α
b : β
h : b ∈ Set.range f
⊢ f (Set.restrict (Set.range f) (invFun f) { val := b, property := h }) =
    f (invOfMemRange hf { val := b, property := h })
Theorem: Filter.prod_atTop_atTop_eq
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: cases isEmpty_or_nonempty α
state_before: ι : Type ?u.270965
ι' : Type ?u.270968
α : Type u_1
β : Type u_2
γ : Type ?u.270977
inst✝¹ : Preorder α
inst✝ : Preorder β
⊢ atTop ×ˢ atTop = atTop

tactic: exact Subsingleton.elim _ _
state_before: case inl
ι : Type ?u.270965
ι' : Type ?u.270968
α : Type u_1
β : Type u_2
γ : Type ?u.270977
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : IsEmpty α
⊢ atTop ×ˢ atTop = atTop

case inr
ι : Type ?u.270965
ι' : Type ?u.270968
α : Type u_1
β : Type u_2
γ : Type ?u.270977
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : Nonempty α
⊢ atTop ×ˢ atTop = atTop

tactic: cases isEmpty_or_nonempty β
state_before: case inr
ι : Type ?u.270965
ι' : Type ?u.270968
α : Type u_1
β : Type u_2
γ : Type ?u.270977
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝ : Nonempty α
⊢ atTop ×ˢ atTop = atTop

tactic: exact Subsingleton.elim _ _
state_before: case inr.inl
ι : Type ?u.270965
ι' : Type ?u.270968
α : Type u_1
β : Type u_2
γ : Type ?u.270977
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : IsEmpty β
⊢ atTop ×ˢ atTop = atTop

case inr.inr
ι : Type ?u.270965
ι' : Type ?u.270968
α : Type u_1
β : Type u_2
γ : Type ?u.270977
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : Nonempty β
⊢ atTop ×ˢ atTop = atTop

tactic: simpa [atTop, prod_iInf_left, prod_iInf_right, iInf_prod] using iInf_comm
state_before: case inr.inr
ι : Type ?u.270965
ι' : Type ?u.270968
α : Type u_1
β : Type u_2
γ : Type ?u.270977
inst✝¹ : Preorder α
inst✝ : Preorder β
h✝¹ : Nonempty α
h✝ : Nonempty β
⊢ atTop ×ˢ atTop = atTop
Theorem: dense_iff_inter_open
File: Mathlib/Topology/Basic.lean

tactic: constructor <;> intro h
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ Dense s ↔ ∀ (U : Set α), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s)

tactic: rintro U U_op ⟨x, x_in⟩
state_before: case mp
α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : Dense s
⊢ ∀ (U : Set α), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s)

tactic: exact mem_closure_iff.1 (h _) U U_op x_in
state_before: case mp.intro
α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : Dense s
U : Set α
U_op : IsOpen U
x : α
x_in : x ∈ U
⊢ Set.Nonempty (U ∩ s)

tactic: intro x
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : ∀ (U : Set α), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s)
⊢ Dense s

tactic: rw [mem_closure_iff]
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : ∀ (U : Set α), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s)
x : α
⊢ x ∈ closure s

tactic: intro U U_op x_in
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : ∀ (U : Set α), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s)
x : α
⊢ ∀ (o : Set α), IsOpen o → x ∈ o → Set.Nonempty (o ∩ s)

tactic: exact h U U_op ⟨_, x_in⟩
state_before: case mpr
α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
h : ∀ (U : Set α), IsOpen U → Set.Nonempty U → Set.Nonempty (U ∩ s)
x : α
U : Set α
U_op : IsOpen U
x_in : x ∈ U
⊢ Set.Nonempty (U ∩ s)
Theorem: HomogeneousIdeal.toIdeal_iSup
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: rw [iSup, toIdeal_sSup, iSup_range]
state_before: ι : Type u_2
σ : Type u_3
R : Type ?u.159728
A : Type u_4
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
s : κ → HomogeneousIdeal 𝒜
⊢ toIdeal (⨆ (i : κ), s i) = ⨆ (i : κ), toIdeal (s i)
Theorem: EReal.toReal_le_toReal
File: Mathlib/Data/Real/EReal.lean

tactic: lift x to ℝ using ⟨ne_top_of_le_ne_top hy h, hx⟩
state_before: x y : EReal
h : x ≤ y
hx : x ≠ ⊥
hy : y ≠ ⊤
⊢ toReal x ≤ toReal y

tactic: lift y to ℝ using ⟨hy, ne_bot_of_le_ne_bot hx h⟩
state_before: case intro
y : EReal
hy : y ≠ ⊤
x : ℝ
h : ↑x ≤ y
hx : ↑x ≠ ⊥
⊢ toReal ↑x ≤ toReal y

tactic: simpa using h
state_before: case intro.intro
x : ℝ
hx : ↑x ≠ ⊥
y : ℝ
hy : ↑y ≠ ⊤
h : ↑x ≤ ↑y
⊢ toReal ↑x ≤ toReal ↑y
Theorem: Pretrivialization.mem_source
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: rw [e.source_eq, mem_preimage]
state_before: ι : Type ?u.4968
B : Type u_2
F : Type u_3
E : B → Type ?u.4979
Z : Type u_1
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x : Z
⊢ x ∈ e.source ↔ proj x ∈ e.baseSet
Theorem: LocalizedModule.mk_cancel_common_right
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: simp [mul_smul]
state_before: R : Type u
inst✝² : CommSemiring R
S : Submonoid R
M : Type v
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s s' : { x // x ∈ S }
m : M
⊢ 1 • s • s' • m = 1 • (s * s') • m
Theorem: geom_sum_two
File: Mathlib/Algebra/GeomSum.lean

tactic: simp [geom_sum_succ']
state_before: α : Type u
inst✝ : Semiring α
x : α
⊢ ∑ i in range 2, x ^ i = x + 1
Theorem: MonoidAlgebra.single_mul_apply_aux
File: Mathlib/Algebra/MonoidAlgebra/Basic.lean

tactic: classical exact
    have : (f.sum fun a b => ite (x * a = y) (0 * b) 0) = 0 := by simp
    calc
      (HMul.hMul (α := MonoidAlgebra k G) (single x r) f) y =
          sum f fun a b => ite (x * a = y) (r * b) 0 :=
        (mul_apply _ _ _).trans <| sum_single_index this
      _ = f.sum fun a b => ite (a = z) (r * b) 0 := by simp only [H]
      _ = if z ∈ f.support then r * f z else 0 := (f.support.sum_ite_eq' _ _)
      _ = _ := by split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.511413
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
⊢ ↑(single x r * f) y = r * ↑f z

tactic: exact
have : (f.sum fun a b => ite (x * a = y) (0 * b) 0) = 0 := by simp
calc
(HMul.hMul (α := MonoidAlgebra k G) (single x r) f) y =
sum f fun a b => ite (x * a = y) (r * b) 0 :=
(mul_apply _ _ _).trans <| sum_single_index this
_ = f.sum fun a b => ite (a = z) (r * b) 0 := by simp only [H]
_ = if z ∈ f.support then r * f z else 0 := (f.support.sum_ite_eq' _ _)
_ = _ := by split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.511413
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
⊢ ↑(single x r * f) y = r * ↑f z

tactic: simp
state_before: k : Type u₁
G : Type u₂
R : Type ?u.511413
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
⊢ (sum f fun a b => if x * a = y then 0 * b else 0) = 0

tactic: simp only [H]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.511413
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
this : (sum f fun a b => if x * a = y then 0 * b else 0) = 0
⊢ (sum f fun a b => if x * a = y then r * b else 0) = sum f fun a b => if a = z then r * b else 0

tactic: split_ifs with h <;> simp at h <;> simp [h]
state_before: k : Type u₁
G : Type u₂
R : Type ?u.511413
inst✝¹ : Semiring k
inst✝ : Mul G
f : MonoidAlgebra k G
r : k
x y z : G
H : ∀ (a : G), x * a = y ↔ a = z
this : (sum f fun a b => if x * a = y then 0 * b else 0) = 0
⊢ (if z ∈ f.support then r * ↑f z else 0) = r * ↑f z
Theorem: map_nonneg
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: rw [← map_zero f]
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.30583
δ : Type ?u.30586
inst✝² : OrderedAddCommMonoid α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : OrderAddMonoidHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ 0 ≤ ↑f a

tactic: exact OrderHomClass.mono _ ha
state_before: F : Type u_3
α : Type u_1
β : Type u_2
γ : Type ?u.30583
δ : Type ?u.30586
inst✝² : OrderedAddCommMonoid α
inst✝¹ : OrderedAddCommMonoid β
inst✝ : OrderAddMonoidHomClass F α β
f : F
a : α
ha : 0 ≤ a
⊢ ↑f 0 ≤ ↑f a